hplx_dummy_quant.c

JPEG2000 EBCOT算法源码

  result->base.push_line_float = quantizer__push_line_float;
  result->base.push_line_fixed = quantizer__push_line_fixed;
  result->base.push_block_float = quantizer__push_block_float;
  result->base.push_block_fixed = quantizer__push_block_fixed;
  result->base.push_tree_float = quantizer__push_tree_float;
  result->base.push_tree_fixed = quantizer__push_tree_fixed;
  result->base.terminate = quantizer__terminate;
  return((quantizer_ref) result);
}


/* ========================================================================= */
/* ------------------ Implementation of dummy dequantizer ------------------ */
/* ========================================================================= */

typedef
  struct dummy_dequantizer_obj {
    dequantizer_obj base;
    int num_components;
    component_quant_info_ptr components;
  } dummy_dequantizer_obj, *dummy_dequantizer_ref;

/*****************************************************************************/
/* STATIC                    dequantizer__initialize                         */
/*****************************************************************************/

static void
  dequantizer__initialize(dequantizer_ref base, int decomposition, int levels,
                        int components, int component_rows[],
                        int component_cols[], filter_info_ref info,
                        decoder_ref buf_cast, int argc, char *argv[])
{
  dummy_dequantizer_ref self = (dummy_dequantizer_ref) base;
  component_quant_info_ptr comp_info;
  int comp, n, tmp_rows, tmp_cols, new_rows, new_cols;

  if (decomposition != DECOMPOSITION__MALLAT)
    {
      fprintf(stderr,"The dummy quantizer implementation does not currently\n"
              "support anything other than Mallat decompositions!\n");
      exit(-1);
    }
  self->num_components = components;
  self->components = (component_quant_info_ptr)
    local_malloc(sizeof(component_quant_info)*(size_t) components);
  memset(self->components,0,sizeof(component_quant_info)*(size_t) components);
  for (comp=0; comp < components; comp++)
    {
      comp_info = self->components + comp;
      comp_info->buf = ((float **) buf_cast)[comp];
      comp_info->buf_fixed = ((ifc_int **) buf_cast)[comp];
      comp_info->cols = component_cols[comp];
      comp_info->offsets = (int *)
        local_malloc(sizeof(int)*(size_t)(1+3*levels));
      comp_info->widths = (int *)
        local_malloc(sizeof(int)*(size_t)(1+3*levels));
      tmp_rows = component_rows[comp];
      tmp_cols = component_cols[comp];
      for (n=levels-1; n >= 0; n--, tmp_rows=new_rows, tmp_cols=new_cols)
        {
          new_rows = (tmp_rows+1) >> 1;
          new_cols = (tmp_cols+1) >> 1;
          comp_info->offsets[3*n+HL_BAND] = new_cols;
          comp_info->widths[3*n+HL_BAND] = tmp_cols-new_cols;
          comp_info->offsets[3*n+LH_BAND] = comp_info->cols*new_rows;
          comp_info->widths[3*n+LH_BAND] = new_cols;
          comp_info->offsets[3*n+HH_BAND] = comp_info->cols*new_rows+new_cols;
          comp_info->widths[3*n+HH_BAND] = tmp_cols-new_cols;
        }
      comp_info->offsets[LL_BAND] = 0;
      comp_info->widths[LL_BAND] = tmp_cols;
    }
}

/*****************************************************************************/
/* STATIC                   dequantizer__print_usage                         */
/*****************************************************************************/

static void
  dequantizer__print_usage(dequantizer_ref base, FILE *dest)
{
  return; /* No special command-line options for this object. */
}

/*****************************************************************************/
/* STATIC                dequantizer__pull_line_float                        */
/*****************************************************************************/

static void
  dequantizer__pull_line_float(dequantizer_ref base, float *line_buf,
                               int component_idx, int level_idx,
                               int band_idx, int width)
{
  dummy_dequantizer_ref self = (dummy_dequantizer_ref) base;
  component_quant_info_ptr comp_info;
  float *sp;

  assert(component_idx < self->num_components);
  comp_info = self->components + component_idx;
  assert(width == comp_info->widths[3*level_idx+band_idx]);
  sp = comp_info->buf + comp_info->offsets[3*level_idx+band_idx];
  for (; width > 0; width--)
    *(line_buf++) = *(sp++);
  comp_info->offsets[3*level_idx+band_idx] += comp_info->cols;
}

/*****************************************************************************/
/* STATIC                dequantizer__pull_line_fixed                        */
/*****************************************************************************/

static void
  dequantizer__pull_line_fixed(dequantizer_ref base, ifc_int *line_buf,
                               int component_idx, int level_idx,
                               int band_idx, int width)
{
  dummy_dequantizer_ref self = (dummy_dequantizer_ref) base;
  component_quant_info_ptr comp_info;
  ifc_int *sp;

  assert(component_idx < self->num_components);
  comp_info = self->components + component_idx;
  assert(width == comp_info->widths[3*level_idx+band_idx]);
  sp = comp_info->buf_fixed + comp_info->offsets[3*level_idx+band_idx];
  for (; width > 0; width--)
    *(line_buf++) = *(sp++);
  comp_info->offsets[3*level_idx+band_idx] += comp_info->cols;
}

/*****************************************************************************/
/* STATIC               dequantizer__pull_block_float                        */
/*****************************************************************************/

static void
  dequantizer__pull_block_float(dequantizer_ref base, float **block_buf,
                                int component_idx, int level_idx, int band_idx,
                                int block_rows, int block_cols,
                                int top_row, int left_col)
{
  fprintf(stderr,"The \"pull_block_float\" function is not implemented by "
          "\"dummy_dequantizer\"!\n");
  exit(-1);
}

/*****************************************************************************/
/* STATIC               dequantizer__pull_block_fixed                        */
/*****************************************************************************/

static void
  dequantizer__pull_block_fixed(dequantizer_ref base, ifc_int **block_buf,
                                int component_idx, int level_idx, int band_idx,
                                int block_rows, int block_cols,
                                int top_row, int left_col)
{
  fprintf(stderr,"The \"pull_block_fixed\" function is not implemented by "
          "\"dummy_dequantizer\"!\n");
  exit(-1);
}

/*****************************************************************************/
/* STATIC                dequantizer__pull_tree_float                        */
/*****************************************************************************/

static void
  dequantizer__pull_tree_float(dequantizer_ref base, float **tree_buf,
                               int levels, int component_idx,
                               int root_row, int root_col)
{
  fprintf(stderr,"The \"pull_tree_float\" function is not implemented by "
          "\"dummy_dequantizer\"!\n");
  exit(-1);
}

/*****************************************************************************/
/* STATIC                dequantizer__pull_tree_fixed                        */
/*****************************************************************************/

static void
  dequantizer__pull_tree_fixed(dequantizer_ref base, ifc_int **tree_buf,
                               int levels, int component_idx,
                               int root_row, int root_col)
{
  fprintf(stderr,"The \"pull_tree_fixed\" function is not implemented by "
          "\"dummy_dequantizer\"!\n");
  exit(-1);
}

/*****************************************************************************/
/* STATIC                   dequantizer__terminate                           */
/*****************************************************************************/

static void
  dequantizer__terminate(dequantizer_ref base)
{
  dummy_dequantizer_ref self = (dummy_dequantizer_ref) base;
  component_quant_info_ptr comp_info;
  int n;

  if (self->components != NULL)
    {
      for (n=0; n < self->num_components; n++)
        {
          comp_info = self->components + n;
          local_free(comp_info->offsets);
          local_free(comp_info->widths);
        }
      local_free(self->components);
    }
  local_free(self);
}

/*****************************************************************************/
/* EXTERN                   create_dummy_dequantizer                         */
/*****************************************************************************/

dequantizer_ref
  create_dummy_dequantizer(void)
{
  dummy_dequantizer_ref result;

  result = (dummy_dequantizer_ref)
    local_malloc(sizeof(dummy_dequantizer_obj));
  memset(result,0,sizeof(dummy_dequantizer_obj));
  result->base.initialize = dequantizer__initialize;
  result->base.print_usage = dequantizer__print_usage;
  result->base.pull_line_float = dequantizer__pull_line_float;
  result->base.pull_line_fixed = dequantizer__pull_line_fixed;
  result->base.pull_block_float = dequantizer__pull_block_float;
  result->base.pull_block_fixed = dequantizer__pull_block_fixed;
  result->base.pull_tree_float = dequantizer__pull_tree_float;
  result->base.pull_tree_fixed = dequantizer__pull_tree_fixed;
  result->base.terminate = dequantizer__terminate;
  return((dequantizer_ref) result);
}