std_reverse_info_local.h

JPEG2000实现的源码

    int decomp_sequence[17];
    /* SAIC General Decomp. Begin */
    int *general_decomp_sequence;
    /* SAIC General Decomp. End */
    std_level_info_ptr levels;
    int reversible;
    int sample_downshift;
    int num_guard_bits;
    int implicit_quantization;
    int using_frames_vertically;
    int using_frames_horizontally;
    frame_info frame;
    int ovlp_top, ovlp_bottom, ovlp_left, ovlp_right;

    /* MITRE Gen DC/SQ Begin */
    double adjust_dc;
    int any_nz;
    /* MITRE Gen DC/SQ Begin */

  } std_component_info, *std_component_info_ptr;
  /* Maintains a pointer to the array of `std_level_info' structures, which
     hold most of the useful information.  Note that the array contains
     `num_levels'+1 entries.  The first entry holds only the DC subband, i.e.
     the lowest resolution at which the image is available.  The last entry
     refers to the additional subbands and reconstruction steps required to
     reconstruct the full resolution image from the previous resolution level,
     if any.  The `reversible' field holds one of INFO__REVERSIBLE or
     INFO__IRREVERSIBLE.
         `decomp_sequence' holds a sequence of integers in the range 1 to
     3, terminated with a 0, which identify the `max_hp_descent' value for
     each resolution level, starting at the highest resolution level.
     Once the terminating 0 is encountered, the last specified
     `max_hp_descent' value is used for all remaining levels.
         `component_idx' identifies the zero-based index of the component.
     This is also the instance index of the COC and QCC markers used to
     record specific fields in the codestream.
         `hor_subsampling' and `vert_subsampling' indicate the
     sub-sampling factors to be applied to high resolution grid quantities
     in the top level object in order to derive those for the component.
         `bitdepth' identifies the number of precision bits in the
     original image component.  Similarly, `is_signed' indicates whether
     the original image component was signed or unsigned; all quantities
     which are passed to the compression engine are nominally signed, so
     that originally unsigned quantities must be level shifted.
         `sample_downshift' holds 0 if `reversible' is INFO__REVERSIBLE;
     otherwise, it holds the amount by which raw image samples must be
     shifted down once they have been recovered from the `component_demix'
     object.
         `num_guard_bits' identifies the number of guard bits used for
     establishing dynamic range utilization.
         `using_frames_vertically' and `using_frames_horizontally' indicate
     whether or not frames are being used and hence need to be signalled in
     the codestream in each of the two directions.
         `frame' holds the top-level specification for frames in this
     resolution level; note that the `hor_ssodwt' and `vert_ssodwt' fields
     here identify the number of lowest resolution levels in which the
     SSO-DWT is being used, whereas for interface functions and in
     `std_level_info' structures, the interpretation of those fields is a
     flag indicating whether or not the SSO-DWT is being used for
     the 2D DWT stages belonging to the relevant resolution level.
         `ovlp_top', `ovlp_bottom', `ovlp_left' and `ovlp_right' are
     flags identifying whether or not the tile includes an extra overlap
     sample on each of its boundaries.  The tile dimensions explicitly
     recorded in this object do not include the overlap if any; this is
     added dynamically in calls to `info__get_var_tile_info',
     `info__get_level_info' and `info__get_band_info'.

     SAIC General Decomp. Begin
         `general_decomp_sequence' signals the general decomposition used for
     all current wavelet levels.
     SAIC General Decomp. End */

/*****************************************************************************/
/* STATIC                         std_tile_info                              */
/*****************************************************************************/

typedef
  struct std_tile_info {
    int idx, x_idx, y_idx;
    canvas_dims dims;
    /* Begin Aerospace MCT mods (TSW) */
    int multicomp_transform;
    /* End Aerospace MCT mods */
    std_component_info_ptr components;
    int visited;
  } std_tile_info, *std_tile_info_ptr;
  /* This structure manages information specific to one tile.
         The `idx', `x_idx' and `y_idx' fields hold the zero-based index
     of the tile (tile number), the horizontal index of the tile and the
     vertical index of the tile, respectively.
         The `dims' field holds the dimensions and location of the tile
     on the hi-res reference grid.  The dimensions and location of the tile
     in any given image component, resolution level or subband may be derived
     from these dimensions.
         The `components' field currently points to exactly the same array
     as the `default_components' field in the `std_reverse_info_obj'
     structure.  In the future, we will allow for specific tiles to have
     `components' fields which point to distinct arrays containing non-default
     coding parameters for that tile.  Even though some parameters cannot
     change from tile to tile, the entire components structure must be
     reproduced in any tile containing parameter variations.
         /* Begin Aerospace MCT mods (TSW)
         The multicomp_transform field is a flag which is set to one
         if a multicomponent linear transform is performed for the given tile.
         This info is needed to control where downshifting occurs in 
         relation to the linear transform.
         /* End Aerospace MCT mods
         The `visited' flag indicates whether or not this tile has been
     the current tile before.  If so, there is no need to attempt once
     more to determine whether or not there are tile-specific coding
     parameters which require the construction of a separate `components'
     array. */

/*****************************************************************************/
/*                             std_reverse_info_obj                          */
/*****************************************************************************/

typedef
  struct std_reverse_info_obj {
    reverse_info_obj base;
    canvas_dims grid_dims;
    canvas_dims tile_dims;
    int tiles_wide, tiles_high, total_tiles;
    std_tile_info_ptr tiles;
    int current_tile_idx;
    int num_components;
    std_component_info_ptr default_components;

    /* OTLPF_CONVENTION begin; JX Wei ADFA, WJ Zeng Sharp */
    int otlpf_convention;
    /* OTLPF_CONVENTION end; JX Wei ADFA, WJ Zeng Sharp */

    int use_convolution;
    stream_in_ref stream;
    int no_nz; /* MITRE */
  } std_reverse_info_obj, *std_reverse_info_ref;
  /* This structure defines the augmented state of the `reverse_info'
     object created by `create_std_reverse_info'.
        `grid_dims' identifies the dimensions and location of the image in
     the high resolution grid from which each of the component's dimensions
     and locations are derived via sub-sampling factors.  The `left_col'
     and `top_row' fields in this structure identify the coordinates of the
     upper left hand corner relative to the origin of the canvas.  These
     will frequently be zero.  The `rows' and `cols' fields in the structure
     identify the dimensions of the image.  The dimensions of the canvas
     itself may be obtained by adding `top_row' and `left_col' to these
     dimensions, respectively.  Note that `top_row' and `left_col' may also
     be interpreted as the dimensions of the "missing image" as described in
     the special topic entitled "Blocks, Tiles and Frames" in "ifc.h".
         `tile_dims' identifies the nominal tile dimensions and the
     partitioning reference point.  The nominal tile dimensions are stored
     in the `rows' and `cols' fields, while the partitioning reference
     point is stored in the `top_row' and `left_col' fields.  For a
     detailed explanation of the interpretation of these quantities, consult
     the special topic entitled "Blocks, Tiles and Frames" in "ifc.h".  Note
     that all quantities here are expressed with respect to the canvas
     coordinate system and on the high resolution grid.  The component
     sub-sampling factors must be used to derive the tile structure, locations
     and dimensions of each individual component.
         `tiles_high' and `tiles_wide' identify the number of tiles down
     and across the image.
         `tiles' points to an array containing `tiles_high'*`tiles_wide'
     elements holding information specific to each tile.
         `current_tile_idx' holds the zero-based index of the currently
     active tile in the `tiles' array.
         `default_components' points to an array with `num_components' entries
     which holds all default compression parameters.  A pointer to this
     same array usually is found in each tile; however, individual tiles
     may override the default coding parameters, in which case their
     `components' arrays will be separately allocated and initialized.
         `use_convolution' indicates whether or not the user has requested
     that non-reversible transforms be implemented using convolution.  This
     fact needs to be stored since tile-specific component structures are
     constructed only just-in-time to minimize the need to look ahead in
     the codestream into the tile headers. */

#endif /* STD_REVERSE_INFO_LOCAL_H */