ebcot_decoder.c

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

    cpu_iterations = 1;
  do {
    success = decode_block_once(master,band,info,extra_lsbs);
    if (!success)
      { /* The `info->num_passes' value should now identify the number of
           passes decoded up to but not including the point at which the
           error occurred.  Further adjust the value of `info->num_passes'
           according to our error tolerance and decode again. */
        int verified_bits;

        assert(master->min_erkeep_bits > 0);
        verified_bits = 0;
        for (n=info->num_passes-1; n >= 0; n--)
          {
            verified_bits += master->incremental_er_bits[n];
            if (verified_bits >= master->min_erkeep_bits)
              break;
          }
        info->num_passes = n+1;
        success = decode_block_once(master,band,info,extra_lsbs);
        assert(success);
      }
    cpu_iterations--;
  } while (cpu_iterations > 0);
  if (self->cpu_time >= 0)
    self->cpu_time += (std_int)(clock()-cpu_time);
  /* End of timed section. */

  /* Copy the interleaved sample buffer into the non-interleaved
     `sample_buffer' array. */

  deinterleave_sample_buffer(master,sample_buffer);

  /* Make any necessary adjustments to compensate for ROI activities at
     the encoder. */

  if (roi_boost_delta)
    {
      if (band->roi_implicit)
        {
          assert(master->roi_mask[0] == NULL);
          undo_roi_boost_using_implicit_mask(sample_buffer,info->rows,
                                             info->cols,
                                             master->sample_row_gap,
                                             roi_boost_delta);
        }
      else
        {
          assert(master->roi_mask[0] != NULL);
          undo_roi_boost_using_mask(sample_buffer,info->rows,info->cols,
                                    master->sample_row_gap,roi_boost_delta,
                                    master->roi_mask);
        }
    }

  /* SAIC TCQ begin */  /* Force signalling for non-fully-decoded
                           inverse TCQ See the note under
                           decoder__pull_line__func in ifc.h for details. */
  if ((info->num_passes == info->max_passes) ||
       ((info->passes[info->max_passes-1].layer_bytes == 0) &&
        (info->num_passes == (info->max_passes - 1)))) {

    int ii;

    for (ii=0; ii<master->sample_row_gap*info->rows; ii++) {
      sample_buffer[ii] |= 1 << (band->extra_lsbs - 1);
    }
  }
  /* SAIC TCQ end */

  /* Release storage used for block code-stream. */

  while ((heap = info->first_unit) != NULL)
    {
      info->first_unit = heap->next;
      self->code_heap_mgr->return_unit(self->code_heap_mgr,heap);
    }
}


/* ========================================================================= */
/* -------------------- Configuration Management Functions ----------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                      set_code_block_dims                           */
/*****************************************************************************/

static void
  set_code_block_dims(stream_in_ref stream, ebcot_component_info_ptr comp_info)
{
  int tnum = comp_info->tnum;
  int instance = comp_info->component_idx;
  int xcb, ycb;

  xcb = 2 + (int)
    stream->get_marker_val(stream,tnum,MARKER_COC_XCB,instance,0);
  ycb = 2 + (int)
    stream->get_marker_val(stream,tnum,MARKER_COC_YCB,instance,0);
  comp_info->master.max_height = (1<<ycb);
  comp_info->master.max_width = (1<<xcb);
}

/*****************************************************************************/
/* STATIC                   set_packet_partition_dims                        */
/*****************************************************************************/

static void
  set_packet_partition_dims(stream_in_ref stream,
                            ebcot_component_info_ptr comp_info)
{
  int tnum = comp_info->tnum;
  int instance = comp_info->component_idx;
  ebcot_level_info_ptr lev;
  int x_specs, y_specs, n;

  x_specs = stream->size_marker_elt(stream,tnum,MARKER_COC_PPX,instance);
  y_specs = stream->size_marker_elt(stream,tnum,MARKER_COC_PPY,instance);
  assert(x_specs == y_specs);
  if (x_specs == 0)
    { /* No packet partition. */
      for (n=0; n <= comp_info->num_levels; n++)
        {
          lev = comp_info->levels + n;
          lev->ppx = lev->ppy = -1;
        }
    }
  else
    {
      assert(x_specs == (comp_info->num_levels+1));
      for (n=0; n <= comp_info->num_levels; n++)
        {
          lev = comp_info->levels + n;
          lev->ppx = (int)
            stream->get_marker_val(stream,tnum,MARKER_COC_PPX,instance,n);
          lev->ppy = (int)
            stream->get_marker_val(stream,tnum,MARKER_COC_PPY,instance,n);
        }
    }
}

/*****************************************************************************/
/* STATIC                       set_respect_frames                           */
/*****************************************************************************/

static void
  set_respect_frames(stream_in_ref stream, ebcot_component_info_ptr comp_info)
{
  int tnum = comp_info->tnum;
  int instance = comp_info->component_idx;

  if (stream->size_marker_elt(stream,tnum,MARKER_COC_CCB,instance))
    comp_info->respect_frames = (int)
      stream->get_marker_val(stream,tnum,MARKER_COC_CCB,instance,0);
}

/*****************************************************************************/
/* STATIC                        set_mode_flags                              */
/*****************************************************************************/

static void
  set_mode_flags(stream_in_ref stream, ebcot_component_info_ptr comp_info)
{
  int tnum = comp_info->tnum;
  int instance = comp_info->component_idx;
  std_byte mode_byte;

  mode_byte = (std_byte)
    stream->get_marker_val(stream,tnum,MARKER_COC_MOD,instance,0);
  comp_info->master.causal =
    (mode_byte & MODE_FLAG_CAUSAL)?1:0;
  comp_info->master.reset =
    (mode_byte & MODE_FLAG_RESET)?1:0;
  comp_info->master.terminate_each_pass =
    (mode_byte & MODE_FLAG_TERMINATE)?1:0;
  comp_info->master.lazy =
    (mode_byte & MODE_FLAG_LAZY)?1:0;
  comp_info->master.error_resilient_termination =
    (mode_byte & MODE_FLAG_ERTERM)?1:0;
  comp_info->master.segmark =
    (mode_byte & MODE_FLAG_SEGMARK)?1:0;
}

/*****************************************************************************/
/* STATIC                      set_progression_order                         */
/*****************************************************************************/

static void
  set_progression_order(stream_in_ref stream, ebcot_tile_ptr tile)
{
  int tnum = tile->tnum;
  int num_changes, n;
  int last_layers, last_levels, last_components;
  ebcot_order_ptr order, last_order;

  tile->progression = (int)
    stream->get_marker_val(stream,tnum,MARKER_COD_PROG,0,0);
  num_changes = stream->size_marker_elt(stream,tnum,MARKER_POC_CHANGES,0);
  assert(!(num_changes & 3));
  num_changes >>= 2;
  order = last_order = NULL;
  last_layers = last_levels = last_components = 0;
  for (n=0; n < num_changes; n++)
    {
      order = (ebcot_order_ptr)
        local_malloc(EBCOT_MEM_KEY,sizeof(ebcot_order));
      if (last_order == NULL)
        tile->progression_changes = order;
      else
        last_order->next = order;
      last_order = order;
      order->max_layers = (int)
        stream->get_marker_val(stream,tnum,MARKER_POC_CHANGES,0,4*n+0);
      order->max_levels = (int)
        stream->get_marker_val(stream,tnum,MARKER_POC_CHANGES,0,4*n+1);
      order->max_components = (int)
        stream->get_marker_val(stream,tnum,MARKER_POC_CHANGES,0,4*n+2);
      order->new_progression = (int)
        stream->get_marker_val(stream,tnum,MARKER_POC_CHANGES,0,4*n+3);
      if ((order->max_layers < last_layers) ||
          (order->max_levels < last_levels) ||
          (order->max_components < last_components))
        local_error("The constraints specified for the number of "
                    "quality layers, resolution levels and image "
                    "components to which a progression order applied "
                    "in the POC marker must be non-decreasing!");
      last_layers = order->max_layers;
      last_levels = order->max_levels;
      last_components = order->max_components;
    }
}

/*****************************************************************************/
/* STATIC                         set_num_layers                             */
/*****************************************************************************/

static void
  set_num_layers(stream_in_ref stream, ebcot_tile_ptr tile)
{
  int tnum = tile->tnum;

  tile->num_layers = (int)
    stream->get_marker_val(stream,tnum,MARKER_COD_LAYERS,0,0);
  assert(tile->num_layers > 0);
}


/* ========================================================================= */
/* ---------------------- Structure Management Functions ------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                  construct_layer_progression                       */
/*****************************************************************************/

static int
  construct_layer_progression(ebcot_tile_ptr tile,
                              ebcot_sequence_ptr seq,
                              int max_layers, int max_levels,
                              int max_components)
{
  ebcot_component_info_ptr comp_info;
  ebcot_level_info_ptr lev;
  ebcot_packet_info_ptr packet;
  int new_packets;
  int layer, n, c, p;

  new_packets = 0;
  for (layer=0; layer < max_layers; layer++)
    for (n=0; n < max_levels; n++)
      for (c=0; c < max_components; c++)
        {
          comp_info = tile->components + c;
          if (n > comp_info->num_levels)
            continue;
          lev = comp_info->levels + n;
          for (p=0; p < lev->total_packets; p++)
            {
              packet = lev->packets + p;
              if (packet->included_layers > layer)
                continue;
              assert(packet->included_layers == layer);
              packet->included_layers++;
              seq->layer_idx = layer;
              seq->packet = packet;
              new_packets++;
              seq++;
            }
        }
  return(new_packets);
}

/*****************************************************************************/
/* STATIC             construct_resolution_layer_progression                 */
/*****************************************************************************/

static int
  construct_resolution_layer_progression(ebcot_tile_ptr tile,
                                         ebcot_sequence_ptr seq,
                                         int max_layers, int max_levels,
                                         int max_components)
{
  ebcot_component_info_ptr comp_info;
  ebcot_level_info_ptr lev;
  ebcot_packet_info_ptr packet;
  int new_packets;
  int layer, n, c, p;

  new_packets = 0;
  for (n=0; n < max_levels; n++)
    for (layer=0; layer < max_layers; layer++)
      for (c=0; c < max_components; c++)
        {
          comp_info = tile->components + c;
          if (n > comp_info->num_levels)
            continue;
          lev = comp_info->levels + n;
          for (p=0; p < lev->total_packets; p++)
            {
              packet = lev->packets + p;
              if (packet->included_layers > layer)
                continue;
              assert(packet->included_layers == layer);
              packet->included_layers++;
              seq->layer_idx = layer;
              seq->packet = packet;
              new_packets++;
              seq++;
            }
        }
  return(new_packets);
}

/*****************************************************************************/
/* STATIC          construct_resolution_position_progression                 */
/*****************************************************************************/

static int
  construct_resolution_position_progression(ebcot_tile_ptr tile,
                                            ebcot_sequence_ptr seq,
                                            int max_layers, int max_levels,
                                            int max_components)
{
  ebcot_component_info_ptr comp_info;
  ebcot_level_info_ptr lev;