hpbit_stream_out.c

关于视频压缩的jpeg2000压缩算法,C编写

      }
    }


}

/*****************************************************************************/
/* STATIC                      pre_marker_to_siz                             */
/*****************************************************************************/

static void
  pre_marker_to_siz(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
                    hpbit_pre_marker_ptr pm)
{
  siz_marker siz;
  std_byte *bp, *buf;
  hpbit_marker_elt_ptr elt, Ssiz, XRsiz, YRsiz;
  int length, comps, c, valid;

  if (markers != &(self->global_markers))
    return;
  memset(&siz,0,sizeof(siz_marker));
  Ssiz = XRsiz = YRsiz = NULL;
  valid = 1;
  for (elt=pm->elements; (elt != NULL) && valid; elt=elt->next)
    switch ((char)(elt->element_id)) {
      case ELTID_SIZ_X:
        valid = (elt->size == 1); siz.Xsiz = elt->buf[0]; break;
      case ELTID_SIZ_Y:
        valid = (elt->size == 1); siz.Ysiz = elt->buf[0]; break;
      case ELTID_SIZ_XO:
        valid = (elt->size == 1); siz.XOsiz = elt->buf[0]; break;
      case ELTID_SIZ_YO:
        valid = (elt->size == 1); siz.YOsiz = elt->buf[0]; break;
      case ELTID_SIZ_XT:
        valid = (elt->size == 1); siz.XTsiz = elt->buf[0]; break;
      case ELTID_SIZ_YT:
        valid = (elt->size == 1); siz.YTsiz = elt->buf[0]; break;
      case ELTID_SIZ_XTO:
        valid = (elt->size == 1); siz.XTOsiz = elt->buf[0]; break;
      case ELTID_SIZ_YTO:
        valid = (elt->size == 1); siz.YTOsiz = elt->buf[0]; break;
      case ELTID_SIZ_C:
        valid = (elt->size == 1); siz.Csiz = (std_ushort)(elt->buf[0]); break;
      case ELTID_SIZ_CS:
        valid = (elt->size == 1); siz.CSsiz = (std_byte)(elt->buf[0]); break;
      case ELTID_SIZ_S:
        Ssiz = elt; break;
      case ELTID_SIZ_XR:
        XRsiz = elt; break;
      case ELTID_SIZ_YR:
        YRsiz = elt; break;
      default: valid = 0;
    }
  if (!valid)
    return;
  comps = siz.Csiz;
  if ((comps <= 0) ||
      (Ssiz == NULL) || (XRsiz == NULL) || (YRsiz == NULL) ||
      (Ssiz->size != comps) || (XRsiz->size != comps) ||
      (YRsiz->size != comps))
    return;
  length = 41+3*comps;
  siz.SIZ = MARKER_SIZ;
  siz.Lsiz = length-2;
  siz.Rsiz = 0;
  bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
  copy_to_big_endian(&(siz.SIZ),bp,3,2); bp += 3*2;
  copy_to_big_endian(&(siz.Xsiz),bp,8,4); bp += 8*4;
  copy_to_big_endian(&(siz.Csiz),bp,1,2); bp += 1*2;
  *(bp++) = siz.CSsiz;
  for (c=0; c < comps; c++)
    {
      *(bp++) = (std_byte) Ssiz->buf[c];
      *(bp++) = (std_byte) XRsiz->buf[c];
      *(bp++) = (std_byte) YRsiz->buf[c];
    }
  add_codestream_marker(markers,buf,length,pm->instance,0);
  pm->translated = 1;
}

/*****************************************************************************/
/* STATIC                      pre_marker_to_ers                             */
/*****************************************************************************/

static void
  pre_marker_to_ers(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
                    hpbit_pre_marker_ptr pm)
{
  ers_marker ers;
  std_byte *bp, *buf;
  hpbit_marker_elt_ptr elt;
  int length, valid;

  memset(&ers,0,sizeof(ers_marker));
  valid = 1;
  for (elt=pm->elements; (elt != NULL) && valid; elt=elt->next)
    switch ((char)(elt->element_id)) {
      case ELTID_ERS_SOP:
        valid = (elt->size == 1); ers.Sers |= (elt->buf[0])?1:0; break;
      case ELTID_ERS_EPH:
        valid = (elt->size == 1); ers.Sers |= (elt->buf[0])?4:0; break;
      default: valid = 0;
    }
  if (!valid)
    return;
  if ((ers.Sers == 0) && (markers == &(self->global_markers)))
    {
      pm->translated = 1;
      return; /* No need to write any actual codestream marker. */
    }
  length = 5;
  ers.ERS = MARKER_ERS;
  ers.Lers = length-2;
  bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
  copy_to_big_endian(&(ers.ERS),bp,2,2); bp += 2*2;
  *(bp++) = ers.Sers;
  if (ers.Sers & 4)
    self->num_non_compliant_markers++;
  add_codestream_marker(markers,buf,length,pm->instance,0);
  pm->translated = 1;
  return;
}

/*****************************************************************************/
/* STATIC                      pre_marker_to_rgn                             */
/*****************************************************************************/

static void
  pre_marker_to_rgn(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
                    hpbit_pre_marker_ptr pm)
{
  hpbit_marker_elt_ptr elt, boosts;
  std_byte *bp, *buf;
  int valid, short_form, length, boost_val;

  boosts = NULL;
  valid = 1;
  for (elt=pm->elements; (elt != NULL) && valid; elt=elt->next)
    switch (elt->element_id) {
      case ELTID_RGN_BOOSTS:
        valid = (elt->size == 1); boosts=elt; break;
      default:
        valid = 0;
    }
  if (!valid)
    return;
  if (pm->instance >= markers->params.num_components)
    {
      pm->translated = 1;
      return; /* No need to record anything for this marker. */
    }
  if (boosts == NULL)
    boost_val = 0;
  else
    {
      boost_val = (int) boosts->buf[0];
      if (boosts->buf[0] > 255)
        return;
    }
  if ((boost_val == 0) && (markers == &(self->global_markers)))
    {
      pm->translated = 1;
      return; /* No need for the marker. */
    }

  short_form = (markers->params.num_components < 256);
  if (short_form)
    {
      rgn_marker_short rgn;

      length = 7;
      rgn.RGN = MARKER_RGN;
      rgn.Lrgn = length - 2;
      rgn.Crgn = (std_byte) pm->instance;
      rgn.Srgn = 0;
      rgn.SPrgn = (std_byte) boost_val;
      bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
      copy_to_big_endian(&(rgn.RGN),bp,2,2); bp += 2*2;
      *(bp++) = rgn.Crgn;
      *(bp++) = rgn.Srgn;
      *(bp++) = rgn.SPrgn;
    }
  else
    {
      rgn_marker_long rgn;

      length = 8;
      rgn.RGN = MARKER_RGN;
      rgn.Lrgn = length - 2;
      rgn.Crgn = (std_ushort) pm->instance;
      rgn.Srgn = 0;
      rgn.SPrgn = (std_byte) boost_val;
      bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
      copy_to_big_endian(&(rgn.RGN),bp,3,2); bp += 3*2;
      *(bp++) = rgn.Srgn;
      *(bp++) = rgn.SPrgn;
    }
  add_codestream_marker(markers,buf,length,pm->instance,0);
  pm->translated = 1;
  return;
}

/*****************************************************************************/
/* STATIC                      pre_marker_to_poc                             */
/*****************************************************************************/

static void
  pre_marker_to_poc(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
                    hpbit_pre_marker_ptr pm)
{
  poc_marker poc;
  std_byte *bp, *buf;
  hpbit_marker_elt_ptr elt, changes;
  int length, valid, num_changes, n, var_short;
  std_uint component_mask, byte_mask, word_mask;

  if (pm->elements == NULL)
    return;
  valid = 1;
  for (elt=pm->elements; (elt != NULL) && valid; elt=elt->next)
    switch (elt->element_id) {
      case ELTID_POC_CHANGES:
        valid = !(elt->size & 3); changes=elt; break;
      default:
        valid = 0;
    }
  if (!valid)
    return;
  num_changes = changes->size >> 2;
  if ((num_changes == 0) && (markers == &(self->global_markers)))
    {
      pm->translated = 1;
      return; /* No need to send anything at all. */
    }
  var_short = (markers->params.num_components < 256);
  byte_mask = 0xFFFFFF00;
  word_mask = 0xFFFF0000;
  component_mask = (var_short)?byte_mask:word_mask;
  for (n=0; n < num_changes; n++)
    if ((changes->buf[4*n+0] & word_mask) ||
        (changes->buf[4*n+1] & byte_mask) ||
        (changes->buf[4*n+2] & component_mask) ||
        (changes->buf[4*n+3] & byte_mask))
      return;
  length = 4 + num_changes * ((var_short)?5:6);
  poc.POC = MARKER_POC;
  poc.Lpoc = length-2;
  bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
  copy_to_big_endian(&(poc.POC),bp,2,2); bp += 2*2;
  for (n=0; n < num_changes; n++)
    {
      if (var_short)
        {
          poc_var_short var;

          var.LYpoc = (std_ushort)(changes->buf[4*n+0]);
          var.Rpoc = (std_byte)(changes->buf[4*n+1]);
          var.Cpoc = (std_byte)(changes->buf[4*n+2]);
          var.Ppoc = (std_byte)(changes->buf[4*n+3]);
          copy_to_big_endian(&(var.LYpoc),bp,1,2); bp  += 2;
          *(bp++) = var.Rpoc;
          *(bp++) = var.Cpoc;
          *(bp++) = var.Ppoc;
        }
      else
        {
          poc_var_long var;

          var.LYpoc = (std_ushort)(changes->buf[4*n+0]);
          var.Rpoc = (std_byte)(changes->buf[4*n+1]);
          var.Cpoc = (std_ushort)(changes->buf[4*n+2]);
          var.Ppoc = (std_byte)(changes->buf[4*n+3]);
          copy_to_big_endian(&(var.LYpoc),bp,1,2); bp += 2;
          *(bp++) = var.Rpoc;
          copy_to_big_endian(&(var.Cpoc),bp,1,2); bp += 2;
          *(bp++) = var.Ppoc;
        }
    }
  add_codestream_marker(markers,buf,length,pm->instance,0);
  pm->translated = 1;
  return;
}

/*****************************************************************************/
/* STATIC                       pre_marker_to_cme                            */
/*****************************************************************************/

static void
  pre_marker_to_cme(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
                    hpbit_pre_marker_ptr pm)

 /* This function creates a new CME marker to represent the specific
    supplied pre-marker.  This function should be used less and less as
    the implementation of the standard codestream markers draws to
    completion. */

{
  cme_marker cme;
  int size, length, n;
  hpbit_marker_elt_ptr elt;
  std_byte *bp, *buf;
  std_uint *sp;

  self->num_non_compliant_markers++;

  /* First determine the size of the packed contents. */

  size = 1; /* 1 byte for the instance number. */
  assert(pm->instance < 256);
  for (elt=pm->elements; elt != NULL; elt=elt->next)
    {
      int nvals, prec;

      if (elt->size == 0)
        continue; /* Nothing saved for empty elements. */
      if (elt->precision <= 8)
        prec = 1;
      else if (elt->precision <= 16)
        prec = 2;
      else if (elt->precision <= 32)
        prec = 4;
      else
        assert(0);
      nvals = elt->size;
      
      size++; /* 1 byte for the element ID. */
      size += nvals*prec;
      if ((nvals == 1) && (prec == 1))
        continue; /* Set the 1-byte-only flag reserved in the elt ID byte. */
      size++; /* Need 1 byte to store the precision. */
      if (nvals < 256)
        size++; /* Need 1 byte only to store the sizes. */
      else
        {
          size += 2; /* Need a 16-bit size specifier.  Marked by a flag
                        reserved in the elt ID byte. */
          assert(nvals < (1<<16));
        }
    }

  length = 6 + size;
  cme.CME = MARKER_CME;
  cme.Lcme = length-2;
  cme.Rcme = (std_ushort) 0xFF00;
  cme.Rcme += (std_ushort)(pm->id);
  bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
  copy_to_big_endian(&cme,bp,3,2); bp += 6;
  *(bp++) = (std_byte)(pm->instance);
  for (elt=pm->elements; elt != NULL; elt=elt->next)
    {
      int nvals, prec;

      if (elt->size == 0)
        continue; /* Nothing saved for empty elements. */
      if (elt->precision <= 8)
        prec = 1;
      else if (elt->precision <= 16)
        prec = 2;
      else if (elt->precision <= 32)
        prec = 4;
      else
        assert(0);
      nvals = elt->size;
      *bp = (std_byte)(elt->element_id);
      assert(*bp == (*bp & 0x3F));
      if ((nvals == 1) && (prec == 1))
        { /* Set the 1-byte-only flag and write the 1 byte field. */
          *(bp++) |= 0x40;
          *(bp++) = (std_byte)(elt->buf[0] & 0x00FF);
          continue;
        }