std_reverse_info.c

JPEG2000实现的源码

    stream->get_marker_val(stream,-1,MARKER_SIZ_YO,0,0);
  grid_dims->cols =
    stream->get_marker_val(stream,-1,MARKER_SIZ_X,0,0) - grid_dims->left_col;
  grid_dims->rows = 
    stream->get_marker_val(stream,-1,MARKER_SIZ_Y,0,0) - grid_dims->top_row;
  tile_dims->cols =
    stream->get_marker_val(stream,-1,MARKER_SIZ_XT,0,0);
  tile_dims->rows =
    stream->get_marker_val(stream,-1,MARKER_SIZ_YT,0,0);
  tile_dims->left_col =
    stream->get_marker_val(stream,-1,MARKER_SIZ_XTO,0,0);
  tile_dims->top_row =
    stream->get_marker_val(stream,-1,MARKER_SIZ_YTO,0,0);
  for (n=0; n < num_components; n++)
    {
      std_byte precision;

      precision = (std_byte)
        stream->get_marker_val(stream,-1,MARKER_SIZ_S,0,n);
      components[n].bitdepth = precision & 0x7F;
      components[n].is_signed = precision & 0x80;
      components[n].hor_subsampling =
        stream->get_marker_val(stream,-1,MARKER_SIZ_XR,0,n);
      components[n].vert_subsampling =
        stream->get_marker_val(stream,-1,MARKER_SIZ_YR,0,n);
    }
}

/*****************************************************************************/
/* STATIC             retrieve_num_guard_bits_from_stream                    */
/*****************************************************************************/

static void
  retrieve_num_guard_bits_from_stream(stream_in_ref stream, int tnum,
                                      std_component_info_ptr comp_info)
{
  int instance;

  instance = comp_info->component_idx;
  comp_info->num_guard_bits =
    stream->get_marker_val(stream,tnum,MARKER_QCC_GUARD,instance,0);
}

/*****************************************************************************/
/* STATIC              retrieve_reversibility_from_stream                    */
/*****************************************************************************/

static void
  retrieve_reversibility_from_stream(stream_in_ref stream, int tnum,
                                     std_component_info_ptr comp_info)
{
  int instance, is_reversible;

  instance = comp_info->component_idx;
  is_reversible =
    stream->get_marker_val(stream,tnum,MARKER_COC_REV,instance,0);
  comp_info->reversible = (is_reversible)?INFO__REVERSIBLE:INFO__IRREVERSIBLE;
  if (is_reversible)
    comp_info->sample_downshift = 0;
  else
    comp_info->sample_downshift = IMPLEMENTATION_PRECISION -
    comp_info->num_guard_bits - comp_info->bitdepth;

}

/*****************************************************************************/
/* STATIC              retrieve_partition_info_from_stream                   */
/*****************************************************************************/

static void
  retrieve_partition_info_from_stream(stream_in_ref stream, int tnum,
                                      std_component_info_ptr comp_info)
 /* Saves the frame partition and partitioning anchor point information to
    the COC marker whose instance corresponds to the index of the supplied
    image component.  Note that frames are known as cells in the WD/CD. */

{
  int instance;

  instance = comp_info->component_idx;
  if (stream->size_marker_elt(stream,tnum,MARKER_COC_XCL,instance))
    { /* Horizontal partition information available. */
      comp_info->using_frames_horizontally = 1;
      comp_info->frame.col_rdx =
        stream->get_marker_val(stream,tnum,MARKER_COC_XCL,instance,0);
      comp_info->frame.dims.left_col =
        stream->get_marker_val(stream,tnum,MARKER_COC_XAP,instance,0);
      comp_info->frame.hor_ssodwt =
        stream->get_marker_val(stream,tnum,MARKER_COC_SSOX,instance,0);
    }
  else
    { /* Set horizontal defaults. */
      comp_info->using_frames_horizontally = 0;
      comp_info->frame.col_rdx = 28; /* A large value. */
    }
  comp_info->frame.dims.cols = 1 << comp_info->frame.col_rdx;

  if (stream->size_marker_elt(stream,tnum,MARKER_COC_YCL,instance))
    { /* Vertical partition information available. */
      comp_info->using_frames_vertically = 1;
      comp_info->frame.row_rdx =
        stream->get_marker_val(stream,tnum,MARKER_COC_YCL,instance,0);
      comp_info->frame.dims.top_row =
        stream->get_marker_val(stream,tnum,MARKER_COC_YAP,instance,0);
      comp_info->frame.vert_ssodwt =
        stream->get_marker_val(stream,tnum,MARKER_COC_SSOY,instance,0);
    }
  else
    { /* Set vertical defaults. */
      comp_info->using_frames_vertically = 0;
      comp_info->frame.row_rdx = 28; /* A large value. */
    }
  comp_info->frame.dims.rows = 1 << comp_info->frame.row_rdx;
}

/*****************************************************************************/
/* STATIC                retrieve_decomp_info_from_stream                    */
/*****************************************************************************/

static void
  retrieve_decomp_info_from_stream(stream_in_ref stream, int tnum,
                                   std_component_info_ptr comp_info)
 /* Retrieves the number of decomposition levels and the decomposition
    structure from the COC marker whose instance corresponds to the index of
    the supplied image component. */

{
  int n, instance, length, *decomp;

  /* SAIC General Decomp. Begin */
  int tmp_decomp;
  /* SAIC General Decomp. End */

  instance = comp_info->component_idx;

  /* Get number of levels. */

  comp_info->num_levels =
    stream->get_marker_val(stream,tnum,MARKER_COC_LEVELS,instance,0);

  /* Get decomposition structure. */

  decomp = comp_info->decomp_sequence;
  decomp[0] = 1; decomp[1] = 0;
  length = stream->size_marker_elt(stream,tnum,MARKER_COC_DECOMP,instance);
  if (length > 0)
    { /* Have PART-2 element identifying specific decomposition structure. */

      /* SAIC General Decomp. Begin mods */
      for (n=0; n < length; n++) {
        if ((n+1) > 16)
          local_error("No support for specific decomposition structure "
                      "sequences with specifications for more than  16 "
                      "different resolution levels!");
        tmp_decomp =
          stream->get_marker_val(stream,tnum,MARKER_COC_DECOMP,instance,n);
        if (tmp_decomp == 0)
          break;
        else
          decomp[n] = tmp_decomp;
      }
      if (n > 0)
        decomp[n] = 0;
      if (n < length) {
        int general_decomp_start_n;

        comp_info->general_decomp_sequence = (int *) 
          local_malloc(INFO_MEM_KEY, (length - n + 1) * sizeof(int));
        n++;
        general_decomp_start_n = n;
        for (; n<length; n++) {
          comp_info->general_decomp_sequence[n-general_decomp_start_n] =
            stream->get_marker_val(stream,tnum,MARKER_COC_DECOMP,instance,n);
        }
        comp_info->general_decomp_sequence[n-general_decomp_start_n] = -1;
      }
      /* SAIC General Decomp. End mods */
    }
}

/*****************************************************************************/
/* STATIC            retrieve_use_defined_kernel_from_stream                 */
/*****************************************************************************/

static void
  retrieve_user_defined_kernel_from_stream(stream_in_ref stream, int tnum,
                                           std_user_defined_ptr user,
                                           int marker_instance,
                                           int *supp_idx, int *taps_idx)

 /* Retrieves information for the next user defined kernel in sequence from
    the relevant COC marker in the codestream.  The variables pointed to
    by `supp_idx' and `taps_idx' hold the zero-based index of the next
    element in the COC_SUPP and COC_TAPS elements of the COC marker,
    respectively. */

{
  int supp_byte;
  int s, t;

  s = 0;
  do {
    assert(s < 8);
    supp_byte = stream->get_marker_val(stream,tnum,MARKER_COC_SUPP,
                                       marker_instance,*(supp_idx)+s);
    user->step_supports[s] = supp_byte & 7;
    user->downshifts[s] = (supp_byte >> 3) & 0x0F;
    s++;
    } while (!(supp_byte & 0x80));
  user->num_steps = s;
  (*supp_idx) += s;
  for (s=0; s < user->num_steps; s++)
    for (t=0; t < user->step_supports[s]; t++, (*taps_idx)++)
      {
        std_int val;

        val =
          stream->get_marker_val(stream,tnum,MARKER_COC_TAPS,marker_instance,
                                 *taps_idx);
        if (val & 0x00008000)
          val |= 0xFFFF0000; /* Sign extension. */
        user->taps[s][t] = val;
      }
}

/*****************************************************************************/
/* STATIC                retrieve_kernel_info_from_stream                    */
/*****************************************************************************/

static void
  retrieve_kernel_info_from_stream(stream_in_ref stream, int tnum,
                                   std_component_info_ptr comp_info)
 /* Retrieves Wavelet kernel information from the COC marker whose instance
    corresponds to the index of the supplied image component. */

{
  int instance, is_reversible, part2, kernel_byte, supp_idx, taps_idx;
  int n, k, h_val, v_val;
  std_level_info_ptr lev;
  std_user_defined user;

  instance = comp_info->component_idx;
  is_reversible = (comp_info->reversible == INFO__REVERSIBLE);
  part2 =
    (stream->size_marker_elt(stream,tnum,MARKER_COC_KERNEL,instance) != 0);
  if (is_reversible)
    kernel_byte = 2; /* Default kernel is W5X3. */
  else
    kernel_byte = 3; /* Default kernel is W9X7. */
  kernel_byte += (1<<3); /* By default, use same kernels in both directions. */
  if (part2)
    kernel_byte += (1<<6); /* Not the last kernel type spec. */
  supp_idx = taps_idx = 0;
  for (n=comp_info->num_levels, k=0; n > 0; n--, k++)
    {
      lev = comp_info->levels + n;
      if (kernel_byte & (1<<6))
        kernel_byte = 
          stream->get_marker_val(stream,tnum,MARKER_COC_KERNEL,instance,k);
      h_val = kernel_byte & 7;
      v_val = (kernel_byte >> 3) & 7;
      if (!(kernel_byte & (1<<6)))
        kernel_byte = 0; /* From now on, we repeat last level's kernels */
      switch (h_val) {
        case 0:
          if (n == comp_info->num_levels)
            local_error("Invalid kernel code found in MARKER_CO_KERNEL "
                        "element.  Cannot use the \"repeat last kernel in "
                        "same direction\" flag in the first kernel code for a "
                        "component!");
          copy_kernel(&(lev[1].hor_kernel),&(lev[0].hor_kernel));
          break;
        case 1:
          if (n == comp_info->num_levels)
            local_error("Invalid kernel code found in MARKER_CO_KERNEL "
                        "element.  Cannot use the \"repeat last kernel in "
                        "opposite direction\" flag for the horizontal "
                        "direction in the first kernel code for a component!");
          copy_kernel(&(lev[1].vert_kernel),&(lev[0].hor_kernel));
          break;
        case 2:
          std_translate_kernel("W5X3",NULL,&(lev->hor_kernel));
          break;
        case 3:
          std_translate_kernel("W9X7",NULL,&(lev->hor_kernel));
          break;
        case 4:
          retrieve_user_defined_kernel_from_stream(stream,tnum,&user,instance,
                                                   &supp_idx,&taps_idx);
          std_translate_kernel(NULL,&user,&(lev->hor_kernel));
          break;
        default: assert(0);
      }
      switch (v_val) {
        case 0:
          if (n == comp_info->num_levels)
            local_error("Invalid kernel code found in MARKER_CO_KERNEL "
                        "element.  Cannot use the \"repeat last kernel in "
                        "same direction\" flag in the first kernel code for a "
                        "component!");
          copy_kernel(&(lev[1].vert_kernel),&(lev[0].vert_kernel));
          break;
        case 1:
          copy_kernel(&(lev[0].hor_kernel),&(lev[0].vert_kernel));
          break;
        case 2:
          std_translate_kernel("W5X3",NULL,&(lev->vert_kernel));
          break;
        case 3:
          std_translate_kernel("W9X7",NULL,&(lev->vert_kernel));
          break;
        case 4:
          retrieve_user_defined_kernel_from_stream(stream,tnum,&user,instance,
                                                   &supp_idx,&taps_idx);
          std_translate_kernel(NULL,&user,&(lev->vert_kernel));
          break;
        default: assert(0);
      }
    }
}

/*****************************************************************************/
/* STATIC             retrieve_quantization_info_from_stream                 */
/*****************************************************************************/