hplx_dummy_quant.c

JPEG2000 EBCOT算法源码

/*****************************************************************************/
/* Copyright 1998, Hewlett-Packard Company                                   */
/* All rights reserved                                                       */
/* Author: David Taubman                                                     */
/* Version: V2.0                                                             */
/* Last Revised: 9/22/98                                                     */
/*****************************************************************************/
#include "local_heap.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "line_block_ifc.h"

/* ========================================================================= */
/* ------------------- Implementation of dummy quantizer ------------------- */
/* ========================================================================= */

typedef
  struct component_quant_info {
    float *buf;
    ifc_int *buf_fixed;
    int cols;
    int *offsets;
    int *widths;
  } component_quant_info, *component_quant_info_ptr;

typedef
  struct dummy_quantizer_obj {
    quantizer_obj base;
    int num_components;
    component_quant_info_ptr components;
  } dummy_quantizer_obj, *dummy_quantizer_ref;

/*****************************************************************************/
/* STATIC                     quantizer__initialize                          */
/*****************************************************************************/

static void
  quantizer__initialize(quantizer_ref base, int decomposition, int levels,
                        int components, int component_rows[],
                        int component_cols[], filter_info_ref info,
                        encoder_ref buf_cast, int argc, char *argv[])
{
  dummy_quantizer_ref self = (dummy_quantizer_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                    quantizer__print_usage                          */
/*****************************************************************************/

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

/*****************************************************************************/
/* STATIC                  quantizer__push_line_float                        */
/*****************************************************************************/

static void
  quantizer__push_line_float(quantizer_ref base, float *line_buf,
                             int component_idx, int level_idx, int band_idx,
                             int width)
{
  dummy_quantizer_ref self = (dummy_quantizer_ref) base;
  component_quant_info_ptr comp_info;
  float *dp;

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

/*****************************************************************************/
/* STATIC                  quantizer__push_line_fixed                        */
/*****************************************************************************/

static void
  quantizer__push_line_fixed(quantizer_ref base, ifc_int *line_buf,
                             int component_idx, int level_idx, int band_idx,
                             int width)
{
  dummy_quantizer_ref self = (dummy_quantizer_ref) base;
  component_quant_info_ptr comp_info;
  ifc_int *dp;

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

/*****************************************************************************/
/* STATIC                 quantizer__push_block_float                        */
/*****************************************************************************/

static void
  quantizer__push_block_float(quantizer_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 \"push_block_float\" function is not implemented by "
          "\"dummy_quantizer\"!\n");
  exit(-1);
}

/*****************************************************************************/
/* STATIC                 quantizer__push_block_fixed                        */
/*****************************************************************************/

static void
  quantizer__push_block_fixed(quantizer_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 \"push_block_fixed\" function is not implemented by "
          "\"dummy_quantizer\"!\n");
  exit(-1);
}

/*****************************************************************************/
/* STATIC                  quantizer__push_tree_float                        */
/*****************************************************************************/

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

/*****************************************************************************/
/* STATIC                  quantizer__push_tree_fixed                        */
/*****************************************************************************/

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

/*****************************************************************************/
/* STATIC                     quantizer__terminate                           */
/*****************************************************************************/

static void
  quantizer__terminate(quantizer_ref base)
{
  dummy_quantizer_ref self = (dummy_quantizer_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_quantizer                         */
/*****************************************************************************/

quantizer_ref
  create_dummy_quantizer(void)
{
  dummy_quantizer_ref result;

  result = (dummy_quantizer_ref)
    local_malloc(sizeof(dummy_quantizer_obj));
  memset(result,0,sizeof(dummy_quantizer_obj));
  result->base.initialize = quantizer__initialize;
  result->base.print_usage = quantizer__print_usage;