hpbit_stream_out.c

JPEG2000实现的源码

            local_printf(5,72,"Got QCD %d don't understand it",elt->element_id);
          }
        if (!valid)
          return;
      } else if (pm->id == (MARKER_QCC & 0x00FF)) {
        hpbit_marker_elt_ptr elt;
        for (elt=pm->elements; elt != NULL && valid; elt=elt->next)
          switch ((char)(elt->element_id)) {
          case ELTID_QCC_REV:
          case ELTID_QCC_STEP:
          case ELTID_QCC_NZ:
          case ELTID_QCC_GUARD:
            break;
          default: valid = 0;
            local_printf(5,72,"Got QCC %d don't understand it",elt->element_id);
          }
      }
      if (!valid)
        return;
    }
   /* Now write a QCD and components - 1 QCCs */
  /* make component 0 the QCD and write others as QCC for now */
  /* TODO: eliminate duplicates */

  for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
    {
      int type;

      if (pm->translated)
        continue;
      else if (pm->id == (MARKER_QCD & 0x00FF)) {
        pm->translated = 1;
      } else if (pm->id == (MARKER_QCC & 0x00FF)) {
        hpbit_marker_elt_ptr elt;
        std_byte *buf, *bp;
        int component= pm->instance;
        int qcc_data_size=0;  /* TJF: =0 to avoid warnings */
        int qcc_data_type=0;  /* TJF: =0 to avoid warnings */
        int *qcc_data=NULL;  /* TJF: =NULL to avoid warnings */
        /* MITRE: Part 2 QCD Marker Begin */
        int qcc_data2_size=0;
        int qcc_data2_type=0;
        int *qcc_data2=NULL;
        /* MITRE: Part 2 QCD Marker End */
        memset(&qcc,0,sizeof(qcc));

        for (elt=pm->elements; elt != NULL && valid; elt=elt->next)
          switch ((char)(elt->element_id)) {
          case ELTID_QCC_REV:
            qcc_data_size = elt->size;
            qcc_data = elt->buf;
            qcc_data_type = 1;
            qcc.Sqcc |= 0; /* a noop */
            break;
          case ELTID_QCC_STEP:
            qcc_data_size = elt->size;
            qcc_data = elt->buf;
            qcc_data_type = 2;
            if (elt->size == 1)
              qcc.Sqcc |= 1;
            else
              qcc.Sqcc |= 2;
            break;
          /* MITRE: Part 2 QCD Marker Begin */
          case ELTID_QCC_NZ:
            qcc_data2_size = elt->size;
            qcc_data2 = elt->buf;
            qcc_data2_type = 2;
            if (qcc.Sqcc & 0x03 == 1)
              qcc.Sqcc |= 2;
            else {
              qcc.Sqcc |= 4;
              qcc.Sqcc &= 0xFC;
              if (elt->size != 1)
                qcc.Sqcc |= 1;
            }
            break;
          /* MITRE: Part 2 QCD Marker End */
          case ELTID_QCC_GUARD:
            qcc.Sqcc |= (elt->buf[0] << 5);
            break;
          default: valid = 0;
            local_printf(5,72,"Got QCC %d don't understand it",elt->element_id);
          }
        /* write it out */
        qcc.QCC = MARKER_QCC;
        /* Begin Aerospace correction for #components > 256 */
        /*        qcc.Lqcc = 4+ qcc_data_size * qcc_data_type;*/
        qcc.Lqcc = 5+ qcc_data_size * qcc_data_type
          + qcc_data2_size*qcc_data2_type;  /* MITRE Part 2 Update */
        if (component == 0) {
          /*qcc.Lqcc--; */          /* no component # */
          qcc.Lqcc -= 2;
          qcc.QCC = MARKER_QCD;
          bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,qcc.Lqcc+2);
          copy_to_big_endian(&(qcc.QCC),bp,2,2); bp += 2*2;
          /* no component # */

        } else {
          std_ushort us_comp = component;

          if (!short_components)
            qcc.Lqcc--;
          bp = buf = (std_byte *) local_malloc(HPBIT_MEM_KEY,qcc.Lqcc+2);
          copy_to_big_endian(&(qcc.QCC),bp,2,2); bp += 2*2;

          if (short_components)
            *(bp++) = (std_byte) ((0xFF00 & us_comp) >> 8);
          *(bp++) = (std_byte) ((0x00FF) & us_comp);
          /* End Aerospace correction for #components > 256 */
        }

        type = qcc.Sqcc & 0x1F; /* MITRE Part 2 QCD Marker */

        *(bp++) = qcc.Sqcc;
        if (qcc_data_type == 1) {
          /* REV data */
          int i;
          for(i=0; i<qcc_data_size; i++)
            *(bp++) = (std_byte) qcc_data[i] << 3;
        } else {
          /* STEP or NZ data */
          int i;
          if (type <3) {
            for(i=0; i<qcc_data_size; i++) {
              *(bp++) = (std_byte) (qcc_data[i] >> 8);
              *(bp++) = (std_byte) (qcc_data[i] & 0xff);
            }
          } else if (qcc_data_size == qcc_data2_size) {
            for(i=0; i<qcc_data_size; i++) {
              *(bp++) = (std_byte) (qcc_data2[i] >> 8);
              *(bp++) = (std_byte) (qcc_data2[i] & 0xff);
              *(bp++) = (std_byte) (qcc_data[i] >> 8);
              *(bp++) = (std_byte) (qcc_data[i] & 0xff);
            }
          } else {
              *(bp++) = (std_byte) (qcc_data2[0] >> 8);
              *(bp++) = (std_byte) (qcc_data2[0] & 0xff);
              for(i=0; i<qcc_data_size; i++) {
                *(bp++) = (std_byte) (qcc_data[i] >> 8);
                *(bp++) = (std_byte) (qcc_data[i] & 0xff);
              }
          }
        }
        add_codestream_marker(markers,buf,qcc.Lqcc+2,pm->instance,0);
        pm->translated = 1;

      }
    }
}

/*****************************************************************************/
/* 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_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 = 40+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;
  for (c=0; c < comps; c++)
    {
      *(bp++) = (std_byte) Ssiz->buf[c] - 1;
      *(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_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=NULL;  /* TJF: =NULL to avoid warnings */
  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 % 6); changes=elt; break;
      default:
        valid = 0;
    }
  if (!valid)
    return;
  num_changes = changes->size / 6;
  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[6*n+0] & byte_mask) ||
        (changes->buf[6*n+1] & component_mask) ||
        (changes->buf[6*n+2] & word_mask) ||
        (changes->buf[6*n+3] & byte_mask) ||
        (changes->buf[6*n+4] & component_mask) ||
        (changes->buf[6*n+5] & byte_mask))
      return;
  length = 4 + num_changes * ((var_short)?7:9);
  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.RSpoc = (std_byte)(changes->buf[6*n+0]);
          var.CSpoc = (std_byte)(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_byte)(changes->buf[6*n+4]);
          var.Ppoc = (std_byte)(changes->buf[6*n+5]);
          *(bp++) = var.RSpoc;
          *(bp++) = var.CSpoc;
          copy_to_big_endian(&(var.LYEpoc),bp,1,2); bp  += 2;
          *(bp++) = var.REpoc;
          *(bp++) = var.CEpoc;
          *(bp++) = var.Ppoc;
        }
      else