hpbit_stream_out.c

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

      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;
}

/*****************************************************************************/
/* STATIC                        process_markers                             */
/*****************************************************************************/

static void
  process_markers(hpbit_stream_out_ref self, hpbit_tile_ptr tile)

 /* This function first verifies each of the elements in the pre-markers,
    to make sure that all declared quantities have actually been set.  It
    then augments the pre-markers in individual tiles with any elements
    which appeared in the global header, but not in the tile version.
    It then constructs codestream markers from the pre-markers, updating
    the `total_codestream_bytes' field and setting the `processed' field.
    `tile' is NULL if the global header markers are being processed;
    otherwise, it points to the tile whose markers are to be processed. */

{
  hpbit_markers_ptr markers;
  hpbit_pre_marker_ptr pm, gpm;
  hpbit_marker_elt_ptr elt, gelt;
  int n, tnum, c;

  if (tile == NULL)
    markers = &(self->global_markers);
  else
    markers = &(tile->markers);
  if (markers->processed)
    return;

  /* First, check for incomplete elements. */

  for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
    {
      for (elt=pm->elements; elt != NULL; elt = elt->next)
        { /* Check marker element values correctly set. */
          for (n=0; n < elt->size; n++)
            if (elt->set_buf[n] == 0)
              local_error("One or more declared marker element values not "
                          "set.  Problem encountered in a marker element "
                          "with description, \"%s\"!",elt->description);
            else if (elt->set_buf[n] > 1)
              local_error("One or more declared marker element values set "
                          "multiple times.  Problem encountered in a marker "
                          "element with description, \"%s\"!",
                          elt->description);
        }
    }

  /* Link connected pre-markers. */

  link_connected_pre_markers(markers);

  /* Inherit pre-markers and elements from corresponding global pre-markers
     as necessary */

  if (tile != NULL)
    {
      /* Inherit entire pre-markers necessary. */

      for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
        {
          hpbit_pre_marker_ptr scan;

          if ((pm->link_next == NULL) || (pm->link_prev != NULL))
            continue;

          /* Found the head of a connected list of pre-markers.  Look for
             a corresponding group in the global header. */

          for (gpm=self->global_markers.pre_markers;
               gpm != NULL; gpm = gpm->next)
            if ((gpm->id == pm->id) &&
                (gpm->instance == pm->instance))
              break;
          if (gpm == NULL)
            continue;
          while (gpm->link_prev != NULL)
            gpm = gpm->link_prev;

          /* Inherit any pre-marker from the global header's version of
             this group which does not currently belong to the group in
             the tile header. */

          for (; gpm != NULL; gpm=gpm->link_next)
            {
              for (scan=pm; scan != NULL; scan=scan->link_next)
                if ((scan->id == gpm->id) && (scan->instance == gpm->instance))
                  break;
              if (scan == NULL)
                {
                  scan = (hpbit_pre_marker_ptr)
                    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_pre_marker));
                  scan->next = markers->pre_markers;
                  markers->pre_markers = scan;
                  scan->prev = NULL;
                  scan->next->prev = scan;
                  scan->id = gpm->id;
                  scan->instance = gpm->instance;
                  scan->link_next = pm;
                  pm->link_prev = scan;
                }
            }
        }

      /* Now inherit individual elements as necessary. */

      for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
        {
          for (gpm=self->global_markers.pre_markers;
               gpm != NULL; gpm = gpm->next)
            if ((gpm->id == pm->id) &&
                (gpm->instance == pm->instance))
              break;
          if (gpm == NULL)
            continue;
          for (gelt=gpm->elements; gelt != NULL; gelt=gelt->next)
            {
              for (elt=pm->elements; elt != NULL; elt=elt->next)
                if (elt->element_id == gelt->element_id)
                  break;
              if (elt == NULL)
                {
                  elt = (hpbit_marker_elt_ptr)
                    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_marker_elt));
                  *elt = *gelt;
                  elt->set_buf = NULL; /* No need for this here. */
                  if (elt->size != 0)
                    {
                      elt->buf = (std_int *)
                        local_malloc(HPBIT_MEM_KEY,sizeof(std_int)*elt->size);
                      for (n=0; n < elt->size; n++)
                        elt->buf[n] = gelt->buf[n];
                    }
                  insert_pre_marker_element(elt,pm);
                }
            }
        }
    }

  /* Remove all elements with length 0, since these are only place holders
     to prevent inheritence of global elements. */

  for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
    {
      hpbit_marker_elt_ptr last_elt;

      last_elt = NULL;
      elt = pm->elements;
      while (elt != NULL)
        {
          if (elt->size == 0)
            {
              if (last_elt == NULL)
                pm->elements = elt->next;
              else
                last_elt->next = elt->next;
              if (elt->buf != NULL)
                local_free(elt->buf);
              if (elt->set_buf != NULL)
                local_free(elt->set_buf);
              local_free(elt);
              elt = (last_elt==NULL)?(pm->elements):(last_elt->next);
            }
          else
            {
              last_elt = elt;
              elt = elt->next;
            }
        }
    }

  /* Find potentially redundant pre-markers. */
  
  if (tile != NULL)
    for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
      {
        for (gpm=self->global_markers.pre_markers;
             gpm != NULL; gpm = gpm->next)
          if ((gpm->id == pm->id) &&
              (gpm->instance == pm->instance))
            break;
        if (gpm == NULL)
          continue;
        pm->potentially_redundant = 1; /* Until proven otherwise. */
        for (elt=pm->elements, gelt=gpm->elements; elt != NULL;
             elt=elt->next, gelt=gelt->next)
          {
            if ((gelt == NULL) ||
                (elt->element_id != gelt->element_id) ||
                (elt->size != gelt->size))
              { pm->potentially_redundant = 0; break; }
            for (n=0; n < elt->size; n++)
              if (gelt->buf[n] != elt->buf[n])
                break;
            if (n < elt->size)
              { pm->potentially_redundant = 0; break; }
          }
        if (gelt != NULL)
          pm->potentially_redundant = 0;
      }

  /* Eliminate redundant pre-marker groups. */

  if (tile != NULL)
    {
      int done;
      do {
        done =1;
        for (pm=markers->pre_markers; pm != NULL; pm=pm->next)
          if (pm->potentially_redundant && (pm->link_prev == NULL))
            {
              for (gpm=pm->link_next; gpm != NULL; gpm=gpm->link_next)
                if (!gpm->potentially_redundant)
                  break;
              if (gpm==NULL)
                break;
            }
        while (pm != NULL)
          { /* Need to remove group. */
            gpm = pm->link_next;
            if (pm->prev == NULL)
              markers->pre_markers = pm->next;
            else
              pm->prev->next = pm->next;
            if (pm->next != NULL)
              pm->next->prev = pm->prev;
            destroy_pre_marker(pm);
            pm = gpm;
            done = 0;
          }
      } while (!done);
    }

  /* Finally, convert pre-markers to codestream markers. */

  tnum = (tile == NULL)?-1:(tile->tnum);
  markers->params.num_components = (int)
    self->base.get_marker_val(&(self->base),tnum,MARKER_SIZ_C,0,0);
  markers->params.components = (hpbit_component_params_ptr)
    local_malloc(HPBIT_MEM_KEY,sizeof(hpbit_component_params)*
                 markers->params.num_components);
  for (c=0; c < markers->params.num_components; c++)
    {
      markers->params.components[c].num_levels = (int)
        self->base.get_marker_val(&(self->base),tnum,MARKER_COC_LEVELS,c,0);
      markers->params.components[c].num_bands =
        get_tile_component_bands(self,tnum,c,
                                 markers->params.components[c].num_levels);
    }
  translate_cod_coc_markers(self,markers);
  translate_qcd_qcc_markers(self,markers);

  for (pm=markers->pre_markers; pm != NULL; pm = pm->next)
    {
      if (pm->translated)
        continue;
      if (pm->id == (MARKER_SIZ & 0x00FF))
        pre_marker_to_siz(self,markers,pm);
      else if (pm->id == (MARKER_ERS & 0x00FF))
        pre_marker_to_ers(self,markers,pm);
      else if (pm->id == (MARKER_RGN & 0x00FF))
        pre_marker_to_rgn(self,markers,pm);
      else if (pm->id == (MARKER_POC & 0x00FF))
        pre_marker_to_poc(self,markers,pm);
      if (!pm->translated)
        pre_marker_to_cme(self,markers,pm);
    }
  markers->processed = 1;
}

/*****************************************************************************/
/* STATIC                        output_markers                              */
/*****************************************************************************/

static void
  output_markers(hpbit_stream_out_ref self, hpbit_markers_ptr markers)

 /* Writes the codestream markers to the output file. */

{
  hpbit_codestream_marker_ptr cp;

  assert(markers->processed);
  for (cp=markers->codestream_markers; cp != NULL; cp = cp->next)
    emit_bytes(self,(std_byte *)(cp->buf),cp->num_bytes);
}

/*****************************************************************************/
/* STATIC                        destroy_markers                             */
/*****************************************************************************/

static void
  destroy_markers(hpbit_markers_ptr markers)
{
  hpbit_codestream_marker_ptr cp;
  hpbit_pre_marker_ptr pm;

  while ((cp = markers->codestream_markers) != NULL)
    {
      markers->codestream_markers = cp->next;
      local_free(cp->buf);
      local_free(cp);
    }
  while ((pm = markers->pre_markers) != NULL)
    {
      markers->pre_markers = pm->next;
      destroy_pre_marker(pm);
    }
  if (markers->params.components != NULL)
    local_free(markers->params.components);
  markers->params.components = NULL;
}

/* ========================================================================= */
/* ------------------------- Interface Implementation ---------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                         __initialize                               */
/*****************************************************************************/

static void
  __initialize(stream_out_ref base, int max_bytes, char *filename,
               cmdl_ref cmdl)