compressed.cpp

JPEG2000的C++实现代码

  if ((state->first_apparent_component == 0) &&
      (state->num_apparent_components >= 3))
    return state->use_ycc;
  else
    return false;
}

/*****************************************************************************/
/*                        kdu_tile::get_num_components                       */
/*****************************************************************************/

int
  kdu_tile::get_num_components()
{
  return state->num_apparent_components;
}

/*****************************************************************************/
/*                         kdu_tile::access_component                        */
/*****************************************************************************/

kdu_tile_comp
  kdu_tile::access_component(int comp_idx)
{
  assert((comp_idx >= 0) && (comp_idx < state->num_apparent_components));
  comp_idx += state->first_apparent_component;
  return kdu_tile_comp(state->comps+comp_idx);
}


/* ========================================================================= */
/*                                 kd_tile_comp                              */
/* ========================================================================= */

/*****************************************************************************/
/*                       kd_tile_comp::~kd_tile_comp                         */
/*****************************************************************************/

kd_tile_comp::~kd_tile_comp()
{
  codestream->var_structure_delete(sizeof(*this));
  if (resolutions != NULL)
    delete[] resolutions;
}

/* ========================================================================= */
/*                                kdu_tile_comp                              */
/* ========================================================================= */

/*****************************************************************************/
/*                         kdu_tile_comp::get_reversible                     */
/*****************************************************************************/

bool
  kdu_tile_comp::get_reversible()
{
  return state->reversible;
}

/*****************************************************************************/
/*                        kdu_tile_comp::get_subsampling                     */
/*****************************************************************************/

void
  kdu_tile_comp::get_subsampling(kdu_coords &sub_sampling)
{
  sub_sampling = state->sub_sampling;
  int shift = state->dwt_levels - state->apparent_dwt_levels;
  sub_sampling.x <<= shift;
  sub_sampling.y <<= shift;
  if (state->codestream->transpose)
    sub_sampling.transpose();
}

/*****************************************************************************/
/*                          kdu_tile_comp::get_bit_depth                     */
/*****************************************************************************/

int
  kdu_tile_comp::get_bit_depth(bool internal)
{
  int bit_depth = state->codestream->precision[state->cnum];
  if (internal)
    bit_depth += state->recommended_extra_bits;
  return bit_depth;
}

/*****************************************************************************/
/*                           kdu_tile_comp::get_signed                       */
/*****************************************************************************/

bool
  kdu_tile_comp::get_signed()
{
  return state->codestream->is_signed[state->cnum];
}

/*****************************************************************************/
/*                      kdu_tile_comp::get_num_resolutions                   */
/*****************************************************************************/

int
  kdu_tile_comp::get_num_resolutions()
{
  return state->apparent_dwt_levels+1;
}

/*****************************************************************************/
/*                      kdu_tile_comp::access_resolution                     */
/*****************************************************************************/

kdu_resolution
  kdu_tile_comp::access_resolution(int res_level)
{
  assert((res_level >= 0) && (res_level <= state->apparent_dwt_levels));
  return kdu_resolution(state->resolutions+res_level);
}

/*****************************************************************************/
/*                 kdu_tile_comp::access_resolution (no args)                */
/*****************************************************************************/

kdu_resolution
  kdu_tile_comp::access_resolution()
{
  return kdu_resolution(state->resolutions+state->apparent_dwt_levels);
}


/* ========================================================================= */
/*                                kd_resolution                              */
/* ========================================================================= */

/*****************************************************************************/
/*                      kd_resolution::~kd_resolution                        */
/*****************************************************************************/

kd_resolution::~kd_resolution()
{
  codestream->var_structure_delete(sizeof(*this));
  if (precinct_refs != NULL)
    {
      for (int n=0; n < precinct_indices.size.x*precinct_indices.size.y; n++)
        if ((precinct_refs[n] != NULL) &&
            (precinct_refs[n] != KD_EXPIRED_PRECINCT))
          delete precinct_refs[n];
      delete[] precinct_refs;
      codestream->var_structure_delete(sizeof(kd_precinct *) *
                                       precinct_indices.area());
    }
  if (bands != NULL)
    {
      delete[] bands;
      codestream->var_structure_delete(sizeof(kd_subband)*(max_band+1));
    }
}

/* ========================================================================= */
/*                             kdu_resolution                                */
/* ========================================================================= */

/*****************************************************************************/
/*                       kdu_resolution::access_next                         */
/*****************************************************************************/

kdu_resolution
  kdu_resolution::access_next()
{
  assert(state != NULL);
  return kdu_resolution((state->res_level==0)?NULL:(state-1));
}

/*****************************************************************************/
/*                         kdu_resolution::which                             */
/*****************************************************************************/

int
  kdu_resolution::which()
{
  assert(state != NULL);
  return state->res_level;
}

/*****************************************************************************/
/*                       kdu_resolution::get_dwt_level                       */
/*****************************************************************************/

int
  kdu_resolution::get_dwt_level()
{
  return state->dwt_level;
}

/*****************************************************************************/
/*                         kdu_resolution::get_dims                          */
/*****************************************************************************/

void
  kdu_resolution::get_dims(kdu_dims &result)
{
  assert(state != NULL);
  result = state->region;
  state->codestream->to_apparent(result);
}

/*****************************************************************************/
/*                      kdu_resolution::access_subband                       */
/*****************************************************************************/

kdu_subband
  kdu_resolution::access_subband(int band_idx)
{
  assert((band_idx >= state->min_band) && (band_idx <= state->max_band));
  if (state->codestream->transpose)
    {
      if (band_idx == HL_BAND)
        band_idx = LH_BAND;
      else if (band_idx == LH_BAND)
        band_idx = HL_BAND;
    }
  return kdu_subband(state->bands+band_idx);
}

/*****************************************************************************/
/*                      kdu_resolution::get_reversible                       */
/*****************************************************************************/

bool
  kdu_resolution::get_reversible()
{
  return state->tile_comp->reversible;
}

/*****************************************************************************/
/*                      kdu_resolution::get_kernel_id                        */
/*****************************************************************************/

int
  kdu_resolution::get_kernel_id()
{
  return state->tile_comp->kernel_id;
}

/*****************************************************************************/
/*                      kdu_resolution::propagate_roi                        */
/*****************************************************************************/

bool
  kdu_resolution::propagate_roi()
{
  return state->propagate_roi;
}


/* ========================================================================= */
/*                               kdu_subband                                 */
/* ========================================================================= */

/*****************************************************************************/
/*                            kdu_subband::which                             */
/*****************************************************************************/

int
  kdu_subband::which()
{
  int band_idx = state->which_band;
  if (state->codestream->transpose)
    {
      if (band_idx == HL_BAND)
        band_idx = LH_BAND;
      else if (band_idx == LH_BAND)
        band_idx = HL_BAND;
    }
  return band_idx;
}

/*****************************************************************************/
/*                          kdu_subband::get_K_max                           */
/*****************************************************************************/

int
  kdu_subband::get_K_max()
{
  return state->K_max;
}

/*****************************************************************************/
/*                       kdu_subband::get_K_max_prime                        */
/*****************************************************************************/

int
  kdu_subband::get_K_max_prime()
{
  return state->K_max_prime;
}

/*****************************************************************************/
/*                        kdu_subband::get_reversible                        */
/*****************************************************************************/

bool
  kdu_subband::get_reversible()
{
  return state->resolution->tile_comp->reversible;
}

/*****************************************************************************/
/*                           kdu_subband::get_delta                          */
/*****************************************************************************/

float
  kdu_subband::get_delta()
{
  return (state->resolution->tile_comp->reversible)?0.0F:state->delta;
}

/*****************************************************************************/
/*                          kdu_subband::get_msb_wmse                        */
/*****************************************************************************/

float
  kdu_subband::get_msb_wmse()
{
  double result = state->delta;
  result *= (1<<(state->K_max_prime-1));
  result *= result;
  result *= state->G_b;
  result *= state->W_b;
  result *= state->W_b; // Squares the W_b weight.
  return (float) result;
}

/*****************************************************************************/
/*                         kdu_subband::get_roi_weight                       */
/*****************************************************************************/

bool
  kdu_subband::get_roi_weight(float &energy_weight)
{