hpbit_stream_out.c

JPEG2000实现的源码

        {
          poc_var_long var;

          var.RSpoc = (std_byte)(changes->buf[6*n+0]);
          var.CSpoc = (std_ushort)(changes->buf[6*n+1]);
          var.LYEpoc = (std_ushort)(changes->buf[6*n+2]);
          var.REpoc = (std_byte)(changes->buf[6*n+3]);
          var.CEpoc = (std_ushort)(changes->buf[6*n+4]);
          var.Ppoc = (std_byte)(changes->buf[6*n+5]);
          *(bp++) = var.RSpoc;
          copy_to_big_endian(&(var.CSpoc),bp,2,2); bp += 2*2;
          *(bp++) = var.REpoc;
          copy_to_big_endian(&(var.CEpoc),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;
        }

      if (nvals >= 256)
        *bp |= 0x80; /* Set the 16-bit length flag. */
      bp++;
      *(bp++) = (std_byte) prec; /* Write the precision byte. */
      if (nvals < 256)
        *(bp++) = (std_byte) nvals;
      else
        {
          bp[0] = (std_byte)((nvals >> 8) & 0x00FF);
          bp[1] = (std_byte)(nvals & 0x00FF);
          bp += 2;
        }
      sp = elt->buf;
      switch (prec) {
        case 1:
          {
            for (n=nvals; n > 0; n--, sp++)
              *(bp++) = (std_byte)(*sp & 0x000000FF);
          } break;
        case 2:
          {
            for (n=nvals; n > 0; n--, sp++)
              { /* TJF fix. */
                *(bp++) = (std_byte)((*sp >> 8) & 0x000000FF);
                *(bp++) = (std_byte)((*sp >> 0) & 0x000000FF);
              }
          } break;
        case 4:
          {
            for (n=nvals; n > 0; n--, sp++)
              {
                *(bp++) = (std_byte)((*sp >> 24) & 0x000000FF);
                *(bp++) = (std_byte)((*sp >> 16) & 0x000000FF);
                *(bp++) = (std_byte)((*sp >> 8) & 0x000000FF);
                *(bp++) = (std_byte)((*sp >> 0) & 0x000000FF);
              }
          } break;
        default: assert(0);
      }
    }
  assert((bp - buf) == length);

  add_codestream_marker(markers,buf,length,pm->instance,0);

  pm->translated = 1;
}

/* Begin Aerospace MCT mods (TSW) */
/*****************************************************************************/
/* STATIC                      pre_marker_to_mct                             */
/*****************************************************************************/
static void
pre_marker_to_mct(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
				  hpbit_pre_marker_ptr pm)
{
	mct_marker mct;
	std_byte *bp, *buf, ix, typ, dt;
	hpbit_marker_elt_ptr elt, SPmct;
	long int length;
	int valid;
	float *f;

	/* For now, the value field SPmct must be constructed with the indirect
	method of declaring the marker element. */
	if (markers != &(self->global_markers))
		return;
	memset(&mct,0,sizeof(mct_marker));
	SPmct = NULL;
	valid = 1;
	for (elt=pm->elements; (elt != NULL) && valid; elt=elt->next){
		switch ((char)(elt->element_id)){
			case ELTID_MCT_IX:
				valid = (elt->size == 1);
				ix = (std_byte) elt->buf[0];
				break;
			case ELTID_MCT_TYP:
				valid = (elt->size == 1);
				typ = (std_byte) elt->buf[0];
				break;
			case ELTID_MCT_DT:
				valid = (elt->size == 1);
				dt = (std_byte) elt->buf[0];
				break;
			case ELTID_MCT_SP:
				valid = (elt->data_size_indirect > 0);
				SPmct = elt;
				break;
			default:
				valid = 0;
		}
	}
	if (!valid)
		return;

	length = 7+SPmct->data_size_indirect;
	mct.MCT = MARKER_MCT;
	mct.Lmct = length-2;
	mct.Smct = (std_byte) (dt << 6) | (typ << 4) | ix;
	bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length);
	copy_to_big_endian(&(mct.MCT),bp,1,2); bp += 1*2;
	copy_to_big_endian(&(mct.Lmct),bp,1,4); bp += 1*4;
	*(bp++) = mct.Smct;
	f = (float *) SPmct->buf;

	memcpy(bp, SPmct->buf, SPmct->data_size_indirect);
	add_codestream_marker(markers,buf,length,pm->instance,1);
	if (SPmct->copied_on_set) {
		local_free(SPmct->buf);
		SPmct->buf = NULL;
	}
	pm->translated = 1;
}

/*****************************************************************************/
/* STATIC                      pre_marker_to_mcc                             */
/*****************************************************************************/
static void
pre_marker_to_mcc(hpbit_stream_out_ref self, hpbit_markers_ptr markers,
				  hpbit_pre_marker_ptr pm)
{
	std_byte *bp, *buf, index;
	hpbit_marker_elt_ptr elt,cmc_nullme,wmc_nullme;
	long int length;
	int valid, nseg=-1, i, cmc_copied, wmc_copied;
	std_ushort sh;
	std_uint *xmx,*xwdo,*nmcs,*nmcn,*mmcs,*mmcn,*tmcx;
	std_uint *tmco,*cmc,*wmc,*ilptr,*olptr,j;

	/* for the moment, the MCC is required in the main header. This eliminates
	   a difficulty that will occur in reading the marker from a tile-part 
	   header. Also, this routine will not properly construct the MCC marker
	   if its index (instance) is non-zero and it appears in a tile-part
	   header. FOr a tile-part MCC, instance will be zero since there can
	   only be one. Index is always supplied.*/

	if (markers != &(self->global_markers))
		return;

	valid = 1;
	for (elt=pm->elements; (elt != NULL) && valid; elt=elt->next){
		switch ((char)(elt->element_id)){
			case ELTID_MCC_IX:
				valid = (elt->size == 1);
				index = (std_byte) elt->buf[0];
				break;
			case ELTID_MCC_XMX:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				xmx = elt->buf;
				break;
			case ELTID_MCC_XWDO:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				xwdo = elt->buf;
				break;
			case ELTID_MCC_NMCS:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				nmcs = elt->buf;
				break;
			case ELTID_MCC_NMCN:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				nmcn = elt->buf;
				break;
			case ELTID_MCC_MMCS:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				mmcs = elt->buf;
				break;
			case ELTID_MCC_MMCN:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				mmcn = elt->buf;
				break;
			case ELTID_MCC_TMCX:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				tmcx = elt->buf;
				break;
			case ELTID_MCC_TMCO:
				nseg = (nseg<0)?elt->size:nseg;
				valid = (elt->size == nseg);
				tmco = elt->buf;
				break;
			case ELTID_MCC_CMC:
				cmc = elt->buf;
				cmc_nullme = elt;
				cmc_copied = elt->copied_on_set;
				break;
			case ELTID_MCC_WMC:
				wmc = elt->buf;
				wmc_nullme = elt;
				wmc_copied = elt->copied_on_set;
				break;
			default:
				valid = 0;
		}
	}
	if (!valid)
		return;

	length = 5 + 6 * nseg;
	for( i=0; i<nseg; i++ ) {
		length += ( nmcn[i] * (nmcs[i] + 1) );
		length += ( mmcn[i] * (mmcs[i] + 1) );
	}
	bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,length+2);
	sh = MARKER_MCC; 
	copy_to_big_endian(&sh,bp,1,2); bp += 1*2;
	copy_to_big_endian(&length,bp,1,4); bp += 1*4;
	*(bp++) = index;
	for( i=0, ilptr=cmc, olptr=wmc; i<nseg; i++ ) {
		*(bp++) = (((std_byte) *(xwdo+i) & 0x0F) << 4) | 
			((std_byte) *(xmx+i) & 0x0F);
		sh = ((std_ushort) *(nmcs+i) &0x0003 << 14) |
			((std_ushort) *(nmcn+i) & 0x3FFF);
		copy_to_big_endian(&sh,bp,1,2); bp += 1*2;
		for( j=0; j<*(nmcn+i); j++ )
			if ( *(nmcs+i) == 0 )
				*(bp++) = (std_byte) *(ilptr++);
			else {
				sh = (std_ushort) *(ilptr++);
				copy_to_big_endian(&sh,bp,1,2); bp += 1*2; 
			}
			sh = ((std_ushort) *(mmcs+i) &0x0003 << 14) |
				((std_ushort) *(mmcn+i) & 0x3FFF);
			copy_to_big_endian(&sh,bp,1,2); bp += 1*2;
			for( j=0; j<*(mmcn+i); j++ )
				if ( *(mmcs+i) == 0 )
					*(bp++) = (std_byte) *(olptr++);
				else {
					sh = (std_ushort) *(olptr++);
					copy_to_big_endian(&sh,bp,1,2); bp += 1*2; 
				}
				*(bp++) = (((std_byte) *(tmco+i) & 0x0F) << 4) | 
					((std_byte) *(tmcx+i) & 0x0F);      
	}
	assert(bp == (buf+length+2));
	add_codestream_marker(markers,buf,length+2,pm->instance,1);
	if(cmc_copied==1){
		local_free(cmc);
		cmc_nullme->buf = NULL;
	}
	if(wmc_copied==1){
		local_free(wmc);
		wmc_nullme->buf = NULL;
	}
    
		/*  if (SPmct->copied_on_set) {
		local_free(SPmct->buf);
		SPmct->buf = NULL;
    }*/
	pm->translated = 1;
}

/*****************************************************************************/
/* STATIC                      pre_marker_to_mic                             */
/*****************************************************************************/

static void