hpbit_stream_in.c

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

        qcd.Cqcc = -1;          /* no component number */
        qcd.Sqcc = *(bp++);
        if ((qcd.Sqcc & 0x1F) > 2)
          failure = 1;
        qcd.data = bp;

        break;
      }
  self->failed_marker_translations += failure;
  if (cp==NULL)                 /* No COD found */
    return(0);
  if (failure)
    return(0);

  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
  pm->next = markers->pre_markers;
  markers->pre_markers = pm;
  pm->id = MARKER_QCD & 0x00FF;
  pm->instance = 0;

  /* MARKER_QCD_WHICH is not directly related to syntax, for
     Part I, it is always 0 */
  elt = add_elt(pm,MARKER_QCD_WHICH,1); elt->buf[0] = 0;

  cp->accesses = 1;

  /* Now for each component find the QCC or use the QCD */
  failure = 0;
  for (comp=0; comp < markers->params.num_components; comp++)
    {
      for (cp=markers->codestream_markers; cp != NULL; cp=cp->next)
        if (cp->buf[1] == (MARKER_QCC & 0x00FF))
          {
            if ((markers->params.num_components < 256) &&
                (cp->buf[4] != comp))
              continue;
            if ((markers->params.num_components >=256) &&
                ((cp->buf[4] << 8) + cp->buf[5] != comp))
              continue;
            bp = cp->buf;
            copy_from_big_endian(bp,&(qcc.QCC),2,2); bp += 2*2;
            qcc.Cqcc = *(bp++);
            if (markers->params.num_components >=256)
              qcc.Cqcc = (qcc.Cqcc << 8) + *(bp++);
            qcc.Sqcc = *(bp++);
            qcc.data = bp;
            assert(qcc.QCC == MARKER_QCC);

            cp->accesses = 1;
            break;
          }
      self->failed_marker_translations += failure;
      if (cp == NULL)           /* Didn't find marker */
        {
          /* Note: this code doesn't work if QCD is a marker, but */
          /* QCC is premarker, but only the VM writes pre-markers and */
          /* it either writes both QCD and QCC as markers or as premarkers */
          /* copy from qcd */
          qcc.Lqcc = qcd.Lqcc + 1; /* component # */
          qcc.Cqcc = comp;
          qcc.Sqcc = qcd.Sqcc;
          qcc.data = qcd.data;
        }
      data_size = qcc.Lqcc - 4;/* length, component, selector */
      if ((qcc.Sqcc & 0x1F) != 0)
        data_size /= 2;
  
      pm = (hpbit_pre_marker_ptr)
        local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
      pm->next = markers->pre_markers;
      markers->pre_markers = pm;
      pm->id = MARKER_QCC & 0x00FF;
      pm->instance = comp;

      elt = add_elt(pm,MARKER_QCC_GUARD,1); elt->buf[0] = qcc.Sqcc >> 5;
      if ((qcc.Sqcc & 0x1F) ==0) {
        /* REV */
        int i;
        elt  = add_elt(pm,MARKER_QCC_REV,data_size);
        for(i=0; i<data_size; i++)
          elt->buf[i] = (std_int) qcc.data[i];
      } else {
        /* STEP */
        int i;
        elt = add_elt(pm,MARKER_QCC_STEP,data_size);
        for(i=0; i<data_size; i++) {
          elt->buf[i] = (std_int) qcc.data[2*i] << 8;
          elt->buf[i] |= (std_int) qcc.data[2*i+1];
        }
      }
    }



  return(1);
}

/*****************************************************************************/
/* STATIC                    siz_to_pre_marker                               */
/*****************************************************************************/

static int
  siz_to_pre_marker(hpbit_stream_in_ref self,
                    hpbit_markers_ptr markers,
                    hpbit_codestream_marker_ptr cp)

 /* Returns 1 if successful in translating marker; 0 otherwise. */

{
  siz_marker siz;
  hpbit_pre_marker_ptr pm;
  hpbit_marker_elt_ptr elt, Ssiz, XRsiz, YRsiz;
  std_byte *bp;
  int comps, c;

  if (markers != &(self->global_markers))
    return(0);
  assert(cp->accesses == 0);
  bp = cp->buf;
  copy_from_big_endian(bp,&(siz.SIZ),3,2); bp += 3*2;
  copy_from_big_endian(bp,&(siz.Xsiz),8,4); bp += 8*4;
  copy_from_big_endian(bp,&(siz.Csiz),1,2); bp += 1*2;
  siz.CSsiz = *(bp++);
  assert(siz.SIZ == MARKER_SIZ);
  comps = siz.Csiz;

  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
  pm->next = markers->pre_markers;
  markers->pre_markers = pm;
  pm->id = MARKER_SIZ & 0x00FF;
  pm->instance = 0;

  elt = add_elt(pm,MARKER_SIZ_X,1); elt->buf[0] = siz.Xsiz;
  elt = add_elt(pm,MARKER_SIZ_Y,1); elt->buf[0] = siz.Ysiz;
  elt = add_elt(pm,MARKER_SIZ_XO,1); elt->buf[0] = siz.XOsiz;
  elt = add_elt(pm,MARKER_SIZ_YO,1); elt->buf[0] = siz.YOsiz;
  elt = add_elt(pm,MARKER_SIZ_XT,1); elt->buf[0] = siz.XTsiz;
  elt = add_elt(pm,MARKER_SIZ_YT,1); elt->buf[0] = siz.YTsiz;
  elt = add_elt(pm,MARKER_SIZ_XTO,1); elt->buf[0] = siz.XTOsiz;
  elt = add_elt(pm,MARKER_SIZ_YTO,1); elt->buf[0] = siz.YTOsiz;
  elt = add_elt(pm,MARKER_SIZ_C,1); elt->buf[0] = siz.Csiz;
  elt = add_elt(pm,MARKER_SIZ_CS,1); elt->buf[0] = siz.CSsiz;

  Ssiz = add_elt(pm,MARKER_SIZ_S,comps);
  XRsiz = add_elt(pm,MARKER_SIZ_XR,comps);
  YRsiz = add_elt(pm,MARKER_SIZ_YR,comps);
  for (c=0; c < comps; c++)
    {
      Ssiz->buf[c] = *(bp++);
      XRsiz->buf[c] = *(bp++);
      YRsiz->buf[c] = *(bp++);
    }
  cp->accesses = 1;
  return(1);
}

/*****************************************************************************/
/* STATIC                    ers_to_pre_marker                               */
/*****************************************************************************/

static int
  ers_to_pre_marker(hpbit_stream_in_ref self,
                    hpbit_markers_ptr markers,
                    hpbit_codestream_marker_ptr cp)

 /* Returns 1 if successful in translating marker; 0 otherwise. */

{
  ers_marker ers;
  hpbit_pre_marker_ptr pm;
  hpbit_marker_elt_ptr elt;
  std_byte *bp;

  if (cp->num_bytes != 5)
    return(0);
  assert(cp->accesses == 0);
  bp = cp->buf;
  copy_from_big_endian(bp,&(ers.ERS),2,2); bp += 2*2;
  ers.Sers = *(bp++);
  assert(ers.ERS == MARKER_ERS);

  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
  pm->next = markers->pre_markers;
  markers->pre_markers = pm;
  pm->id = MARKER_ERS & 0x00FF;
  pm->instance = 0;

  elt = add_elt(pm,MARKER_ERS_SOP,1); elt->buf[0] = (ers.Sers & 1)?1:0;
  elt = add_elt(pm,MARKER_ERS_EPH,1); elt->buf[0] = (ers.Sers & 4)?1:0;

  if (ers.Sers & 4)
    self->num_non_compliant_markers++;
  cp->accesses = 1;
  return(1);
}

/*****************************************************************************/
/* STATIC                    rgn_to_pre_marker                               */
/*****************************************************************************/

static int
  rgn_to_pre_marker(hpbit_stream_in_ref self,
                    hpbit_markers_ptr markers,
                    hpbit_codestream_marker_ptr cp)

 /* Returns 1 if successful in translating marker; 0 otherwise. */

{
  int short_form, instance, valid;
  hpbit_pre_marker_ptr pm;
  hpbit_marker_elt_ptr boosts;
  std_byte *bp, boost;

  short_form = (markers->params.num_components < 256)?1:0;
  if (cp->num_bytes != (8-short_form))
    return(0);
  assert(cp->accesses == 0);
  bp = cp->buf;
  if (short_form)
    {
      rgn_marker_short rgn;

      copy_from_big_endian(bp,&rgn,2,2); bp += 2*2;
      rgn.Crgn = *(bp++);
      rgn.Srgn = *(bp++);
      rgn.SPrgn = *(bp++);
      assert(rgn.RGN == MARKER_RGN);
      instance = (int) rgn.Crgn;
      boost = rgn.SPrgn;
      valid = (rgn.Srgn == 0);
    }
  else
    {
      rgn_marker_long rgn;

      copy_from_big_endian(bp,&rgn,3,2); bp += 3*2;
      rgn.Srgn = *(bp++);
      rgn.SPrgn = *(bp++);
      assert(rgn.RGN == MARKER_RGN);
      instance = (int) rgn.Crgn;
      boost = rgn.SPrgn;
      valid = (rgn.Srgn == 0);
    }
  if (!valid)
    return(0);
  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));

  pm->next = markers->pre_markers;
  markers->pre_markers = pm;

  pm->id = (MARKER_RGN & 0x00FF);
  pm->instance = instance;
  if (boost != 0)
    {
      boosts = add_elt(pm,MARKER_RGN_BOOSTS,1);
      boosts->buf[0] = (std_uint) boost;
    }
  cp->accesses = 1;
  return(1);
}

/*****************************************************************************/
/* STATIC                    poc_to_pre_marker                               */
/*****************************************************************************/

static int
  poc_to_pre_marker(hpbit_stream_in_ref self,
                    hpbit_markers_ptr markers,
                    hpbit_codestream_marker_ptr cp)

 /* Returns 1 if successful in translating marker; 0 otherwise. */

{
  int var_short, num_changes, var_bytes;
  poc_marker poc;
  hpbit_pre_marker_ptr pm;
  hpbit_marker_elt_ptr changes;
  std_byte *bp, idx;

  var_short = (markers->params.num_components < 256)?1:0;
  if (cp->num_bytes < 4)
    return(0);
  assert(cp->accesses == 0);
  bp = cp->buf;
  copy_from_big_endian(bp,&(poc.POC),2,2); bp += 2*2;
  assert(poc.POC == MARKER_POC);
  var_bytes = ((int) poc.Lpoc) - 2;
  if (var_bytes != (cp->num_bytes-4))
    return(0);
  num_changes = var_bytes / ((var_short)?5:6);
  if (var_bytes != (num_changes * ((var_short)?5:6)))
    return(0);

  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
  pm->next = markers->pre_markers;
  markers->pre_markers = pm;
  pm->id = MARKER_POC & 0x00FF;
  pm->instance = 0;

  if (num_changes > 0)
    {
      changes = add_elt(pm,MARKER_POC_CHANGES,num_changes*4);
      for (idx=0; num_changes > 0; num_changes--)
        {
          if (var_short)
            {
              poc_var_short var;

              copy_from_big_endian(bp,&(var.LYpoc),1,2); bp += 2;
              var.Rpoc = *(bp++);
              var.Cpoc = *(bp++);
              var.Ppoc = *(bp++);
              changes->buf[idx++] = var.LYpoc;
              changes->buf[idx++] = var.Rpoc;
              changes->buf[idx++] = var.Cpoc;
              changes->buf[idx++] = var.Ppoc;
            }
          else
            {
              poc_var_long var;
              copy_from_big_endian(bp,&(var.LYpoc),1,2); bp += 2;
              var.Rpoc = *(bp++);
              copy_from_big_endian(bp,&(var.Cpoc),1,2); bp += 2;
              var.Ppoc = *(bp++);
              changes->buf[idx++] = var.LYpoc;
              changes->buf[idx++] = var.Rpoc;
              changes->buf[idx++] = var.Cpoc;
              changes->buf[idx++] = var.Ppoc;
            }
        }
    }
  cp->accesses = 1;
  return(1);
}

/*****************************************************************************/
/* STATIC                    cme_to_pre_marker                               */
/*****************************************************************************/

static int
  cme_to_pre_marker(hpbit_stream_in_ref self,
                    hpbit_markers_ptr markers,
                    hpbit_codestream_marker_ptr cp)

 /* Returns 1 if successful in translating marker; 0 otherwise. */

{
  hpbit_pre_marker_ptr pm;
  hpbit_marker_elt_ptr elt;
  cme_marker cme;
  std_byte *bp;
  std_uint *dp;
  int total_bytes, n;

  assert(cp->accesses == 0);
  cp->accesses = 1;
  bp = cp->buf;
  copy_from_big_endian(bp,&cme,3,2); bp += 6;
  assert(cme.CME == MARKER_CME);
  total_bytes = cme.Lcme - 6 + 2;
  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
  pm->id = (int)(cme.Rcme & 0x00FF);
  if (total_bytes == 0)
    {
      destroy_pre_marker(pm);
      return(0);
    }
  pm->instance = *(bp++); total_bytes--;
  while (total_bytes > 0)
    {
      int size_flag, single_flag, prec, nbytes, nvals;

      elt = (hpbit_marker_elt_ptr)
        local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_marker_elt));
      elt->next = pm->elements;
      pm->elements = elt;
      elt->marker_id = pm->id;
      elt->element_id = *(bp++); total_bytes--;