hpdz_quant.c

JPEG2000 EBCOT算法源码

         (band_idx < comp_info->num_bands));
  shift = comp_info->info[comp_info->num_bands*level_idx+band_idx].right_shift;
  if (shift == 0)
    for (spp=block_buf, j=block_rows; j > 0; j--, spp++)
      for (sp=*spp, i=block_cols; i > 0; i--, sp++)
        { /* The `shift'=0 case occurs almost always in practice. */
          val = *sp;
          val = (val<0)?(MIN_IFC_INT-val):val;
          *sp = val;
        }
  else if (shift > 0)
    for (spp=block_buf, j=block_rows; j > 0; j--, spp++)
      for (sp=*spp, i=block_cols; i > 0; i--, sp++)
        {
          val = *sp;
          if (val < 0)
            val = MIN_IFC_INT + ((-val) >> shift);
          else
            val >>= shift;
          *sp = val;
        }
  else
    for (shift=-shift, spp=block_buf, j=block_rows; j > 0; j--, spp++)
      for (sp=*spp, i=block_cols; i > 0; i--, sp++)
        {
          val = *sp;
          if (val < 0)
            val = MIN_IFC_INT + ((-val) << shift);
          else
            val <<= shift;
          *sp = val;
        }
  self->encoder->push_block(self->encoder,block_buf,component_idx,level_idx,
                            band_idx,block_rows,block_cols,top_row,left_col);
}

/*****************************************************************************/
/* STATIC                     __push_tree_float                             */
/*****************************************************************************/

static void
  __push_tree_float(quantizer_ref base, float **tree_buf,
                    int component_idx, int levels, int root_row, int root_col)
{
  dz_quantizer_ref self = (dz_quantizer_ref) base;
  component_info_ptr comp_info;
  float *scp, **scpp, *sp, **spp;
  ifc_int **cast_buf, *dp, **dpp, val;
  int i, j;

  assert(component_idx < self->num_components);
  comp_info = self->components + component_idx;
  if (comp_info->tree_scales == NULL)
    {
      int lev, b, r, c;
      float scale;

      if (comp_info->num_bands != 4)
        {
          fprintf(stderr,"The quantizer's `push_tree' functions may be used "
                  "only with\n  Mallat-style decompositions!\n");
          exit(-1);
        }
      comp_info->tree_scales = scpp = (float **)
        local_malloc(sizeof(float *)*(size_t)(1<<comp_info->num_levels));
      for (r=0; r < (1<<comp_info->num_levels); r++)
        scpp[r] = (float *)
          local_malloc(sizeof(float)*(size_t)(1<<comp_info->num_levels));
      for (lev=0; lev < comp_info->num_levels; lev++)
        {
          for (b=(lev==0)?0:1; b < 4; b++)
            {
              scale = comp_info->info[comp_info->num_bands*lev+b].scale;
              switch (b) {
                case LL_BAND: r = c = 0; break;
                case HL_BAND: r = 0; c = (1<<lev); break;
                case LH_BAND: r = (1<<lev); c = 0; break;
                case HH_BAND: r = c = (1<<lev); break;
                default: assert(0);
              }
              for (j=1<<lev; j > 0; j--, r++)
                for (scp=scpp[r]+c, i=1<<lev; i > 0; i--)
                  *(scp++) = scale;
            }
        }
    }

  cast_buf = (ifc_int **) tree_buf;
  for (scpp=comp_info->tree_scales, spp=tree_buf, dpp=cast_buf,
       j=1<<levels; j > 0; j--, scpp++, spp++, dpp++)
    for (scp=*scpp, sp=*spp, dp=*dpp,
         i=1<<levels; i > 0; i--, sp++, dp++, scp++)
      {
        val = (ifc_int)(*sp * *scp);
        val = (val<0)?(MIN_IFC_INT-val):val;
        *dp = val;
      }
  self->encoder->push_tree(self->encoder,cast_buf,levels,
                           component_idx,root_row,root_col);
}

/*****************************************************************************/
/* STATIC                      __push_tree_fixed                             */
/*****************************************************************************/

static void
  __push_tree_fixed(quantizer_ref base, ifc_int **tree_buf,
                    int component_idx, int levels, int root_row, int root_col)
{
  dz_quantizer_ref self = (dz_quantizer_ref) base;
  component_info_ptr comp_info;
  ifc_int *shp, **shpp, *sp, **spp, shift, val;
  int i, j;

  assert(component_idx < self->num_components);
  comp_info = self->components + component_idx;
  if (comp_info->tree_scales == NULL)
    {
      int lev, b, r, c;
      ifc_int shift;

      if (comp_info->num_bands != 4)
        {
          fprintf(stderr,"The quantizer's `push_tree' functions may be used "
                  "only with\n  Mallat-style decompositions!\n");
          exit(-1);
        }
      comp_info->tree_shifts = shpp = (ifc_int **)
        local_malloc(sizeof(ifc_int *)*(size_t)(1<<comp_info->num_levels));
      for (r=0; r < (1<<comp_info->num_levels); r++)
        shpp[r] = (ifc_int *)
          local_malloc(sizeof(ifc_int)*(size_t)(1<<comp_info->num_levels));
      for (lev=0; lev < comp_info->num_levels; lev++)
        {
          for (b=(lev==0)?0:1; b < 4; b++)
            {
              shift=comp_info->info[comp_info->num_bands*lev+b].right_shift;
              switch (b) {
                case LL_BAND: r = c = 0; break;
                case HL_BAND: r = 0; c = (1<<lev); break;
                case LH_BAND: r = (1<<lev); c = 0; break;
                case HH_BAND: r = c = (1<<lev); break;
                default: assert(0);
              }
              for (j=1<<lev; j > 0; j--, r++)
                for (shp=shpp[r]+c, i=1<<lev; i > 0; i--)
                  *(shp++) = shift;
            }
        }
    }

  for (shpp=comp_info->tree_shifts, spp=tree_buf,
       j=1<<levels; j > 0; j--, shpp++, spp++)
    for (shp=*shpp, sp=*spp, i=1<<levels; i > 0; i--, sp++, shp++)
      {
        shift = *shp;
        val = *sp;
        if (shift >= 0)
          {
            if (val < 0)
              val = MIN_IFC_INT + ((-val) >> shift);
            else
              val >>= shift;
          }
        else
          {
            if (val < 0)
              val = MIN_IFC_INT + ((-val) << shift);
            else
              val <<= shift;
          }
        *sp = val;
      }
  self->encoder->push_tree(self->encoder,tree_buf,levels,
                           component_idx,root_row,root_col);
}

/*****************************************************************************/
/* STATIC                         __terminate                                */
/*****************************************************************************/

static void
  __terminate(quantizer_ref base)
{
  dz_quantizer_ref self = (dz_quantizer_ref) base;
  component_info_ptr comp_info;
  int comp, r;

  if (self->components != NULL)
    {
      for (comp=0; comp < self->num_components; comp++)
        {
          comp_info = self->components + comp;
          local_free(comp_info->info);
          if (comp_info->tree_scales != NULL)
            {
              for (r=0; r < (1<<comp_info->num_levels); r++)
                local_free(comp_info->tree_scales[r]);
              local_free(comp_info->tree_scales);
            }
          if (comp_info->tree_shifts != NULL)
            {
              for (r=0; r < (1<<comp_info->num_levels); r++)
                local_free(comp_info->tree_shifts[r]);
              local_free(comp_info->tree_shifts);
            }
        }
      local_free(self->components);
    }
  local_free(self);
}

/*****************************************************************************/
/* EXTERN                   create_deadzone_quantizer                        */
/*****************************************************************************/

quantizer_ref
  create_deadzone_quantizer(void)
{
  dz_quantizer_ref result;

  result = (dz_quantizer_ref)
    local_malloc(sizeof(dz_quantizer_obj));
  memset(result,0,sizeof(dz_quantizer_obj));
  result->base.initialize = __initialize;
  result->base.print_usage = __print_usage;
  result->base.push_line_float = __push_line_float;
  result->base.push_line_fixed = __push_line_fixed;
  result->base.push_block_float = __push_block_float;
  result->base.push_block_fixed = __push_block_fixed;
  result->base.push_tree_float = __push_tree_float;
  result->base.push_tree_fixed = __push_tree_fixed;
  result->base.terminate = __terminate;
  return((quantizer_ref) result);
}