hpbit_stream_in.c

JPEG2000实现的源码

	assert(bp == (cp->buf + length + 2));
	/* Since we're trying to minimize the amount of memory consumed by the
	multi-component stuff, free up the marker data buffer, since we've now
	processed the marker and we won't need to do it again. */
	local_free(cp->buf);
	cp->buf = NULL;

	cp->accesses = 1;
	return(1);
}
/* End Aerospace MCT mods */

/*****************************************************************************/
/* 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)?7:9);
  if (var_bytes != (num_changes * ((var_short)?7:9)))
    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*6);
      for (idx=0; num_changes > 0; num_changes--)
        {
          if (var_short)
            {
              poc_var_short var;

              var.RSpoc = *(bp++);
              var.CSpoc = *(bp++);
              copy_from_big_endian(bp,&(var.LYEpoc),1,2); bp += 2;
              var.REpoc = *(bp++);
              var.CEpoc = *(bp++);
              var.Ppoc = *(bp++);
              changes->buf[idx++] = var.RSpoc;
              changes->buf[idx++] = var.CSpoc;
              changes->buf[idx++] = var.LYEpoc;
              changes->buf[idx++] = var.REpoc;
              changes->buf[idx++] = var.CEpoc;
              changes->buf[idx++] = var.Ppoc;
            }
          else
            {
              poc_var_long var;
              var.RSpoc = *(bp++);
              copy_from_big_endian(bp,&(var.CSpoc),2,2); bp += 4;
              var.REpoc = *(bp++);
              copy_from_big_endian(bp,&(var.CEpoc),1,2); bp += 2;
              var.Ppoc = *(bp++);
              changes->buf[idx++] = var.RSpoc;
              changes->buf[idx++] = var.CSpoc;
              changes->buf[idx++] = var.LYEpoc;
              changes->buf[idx++] = var.REpoc;
              changes->buf[idx++] = var.CEpoc;
              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--;
      elt->description = "<unknown>";
      single_flag = (elt->element_id & 0x40)?1:0;
      size_flag = (elt->element_id & 0x80)?1:0;
      elt->element_id &= 0x3F;
      if (single_flag)
        {
          prec = 1;
          elt->size = 1;
        }
      else
        {
          if (total_bytes < (2+size_flag))
            {
              destroy_pre_marker(pm);
              return(0);
            }
          prec = *(bp++); total_bytes--;
          if ((prec != 1) && (prec != 2) && (prec != 4))
            local_error("CME marker used to pack regular marker segments "
                        "seems to be corrupt!");
          elt->size = *(bp++); total_bytes--;
          if (size_flag)
            {
              elt->size <<= 8;
              elt->size += *(bp++); total_bytes--;
            }
        }
      nvals = elt->size;
      nbytes = nvals * prec;
      if ((total_bytes < nbytes) || (nvals == 0))
        {
          destroy_pre_marker(pm);
          return(0);
        }
      elt->buf = (std_uint *)
        local_malloc(HPBIT_MEM_KEY,nvals*sizeof(std_uint));
      dp = elt->buf;
      switch (prec) {
        case 1:
          {
            for (n=nvals; n > 0; n--, dp++)
              *dp = (std_uint) *(bp++);
          } break;
        case 2:
          {
            for (n=nvals; n > 0; n--, dp++)
              {
                *dp = (std_uint) *(bp++);
                *dp <<= 8; *dp |= (std_uint) *(bp++);
              }
          } break;
        case 4:
          {
            for (n=nvals; n > 0; n--, dp++)
              {
                *dp = (std_uint) *(bp++);
                *dp <<= 8; *dp |= (std_uint) *(bp++);
                *dp <<= 8; *dp |= (std_uint) *(bp++);
                *dp <<= 8; *dp |= (std_uint) *(bp++);
              }
          } break;
        default: assert(0);
      }
      total_bytes -= nbytes;
    }

  /* If we get here, translation was successful.  Add to the list. */
  pm->next = markers->pre_markers;
  markers->pre_markers = pm;
  self->num_non_compliant_markers++;
  return(1);
}

/*****************************************************************************/
/* STATIC                    crg_to_pre_marker                               */
/*****************************************************************************/

static int
  crg_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;
  crg_marker crg;
  std_byte *bp;
  std_ushort x_crg, y_crg; 
  int total_bytes;

  assert(cp->accesses == 0);
  cp->accesses = 1;
  bp = cp->buf;
  copy_from_big_endian(bp,&crg,2,2); bp += 4;
  assert(crg.CRG == MARKER_CRG);
  total_bytes = crg.Lcrg - 4 + 2;

  pm = (hpbit_pre_marker_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));

  pm->id = (int)0x0;


  if (total_bytes == 0)
    {
      destroy_pre_marker(pm);
      return(0);
    }

  while (total_bytes > 0)
    {

      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;
      x_crg = *(bp++) << 8; 
      x_crg |= *(bp++); 
      y_crg = *(bp++) << 8; 
      y_crg |= *(bp++); 
      total_bytes -= 4; 
      local_printf(2,70,"Xcrg=%d Ycrg=%d\n",x_crg,y_crg); 
    }
  /* If we get here, translation was successful.  Add to the list. */
  return(1);
}

/* SAIC/Sharp/Fuji Xmask begin */
/*****************************************************************************/
/* STATIC                    vms_to_pre_marker                               */
/*****************************************************************************/

static int
  vms_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. */

{
  vms_marker vms;
  hpbit_pre_marker_ptr pm;
  hpbit_marker_elt_ptr elt, Svms, Wvms, Rvms, Avms, Bvms;
  std_byte *bp;

  assert(cp->accesses == 0);
  bp = cp-