hpdz_dequant.c

JPEG2000实现的源码

{
  hpdz_dequantizer_ref self = (hpdz_dequantizer_ref) base;

  start_tile(self);
  self->decoder->next_tile(self->decoder);
}

/* MITRE General Offset/SQ Begin mods */
/*****************************************************************************/
/* STATIC                      __pull_line_float                             */
/*****************************************************************************/

static void
  __pull_line_float(dequantizer_ref base, float *line_buf,
                    int component_idx, int level_idx, int band_idx, int width)
{
  hpdz_dequantizer_ref self = (hpdz_dequantizer_ref) base;
  hpdz_component_info_ptr comp;
  hpdz_level_info_ptr lev;
  float scale, *dp;
  ifc_int *cast_buf, *sp, val;
  int i;
  double nz;

  /* SAIC TCQ begin */
  int extra_lsbs;
  ifc_int mask;
  /* SAIC TCQ end */

  assert(component_idx < self->num_components);
  comp = self->components + component_idx;
  assert(level_idx <= comp->num_levels);
  lev = comp->levels + level_idx;
  assert((band_idx >= lev->min_band) && (band_idx <= lev->max_band));
  scale = lev->bands[band_idx].scale;
  nz = lev->bands[band_idx].nz;

  /* SAIC TCQ begin */
  extra_lsbs = lev->bands[band_idx].extra_lsbs;
  mask = -1 * (1 << extra_lsbs);
  /* SAIC TCQ end */

  cast_buf = (ifc_int *) line_buf;
  self->decoder->pull_line(self->decoder,cast_buf,
                           component_idx,level_idx,band_idx,width);  
  if (self->three_eighths_mag)
    { /* Modify representation levels. */
      ifc_int mag, lsb_idx, max_mag;

      max_mag = self->three_eighths_mag;
      for (i=width, sp=cast_buf; i > 0; i--, sp++)
        {
          val = *sp;

          /* SAIC TCQ begin */
          if (!(val & mask)) {
            val = 0;
          }
          /* SAIC TCQ end */

          if ((mag = val & MAX_IFC_INT) != 0)
            {
              designal_lsb_idx(mag,lsb_idx);
              if ((mag >> lsb_idx) <= max_mag)
                *sp = val - ((1<<lsb_idx)>>3);
            }
        }
    }
  for (i=width, dp=line_buf+i-1, sp=cast_buf+i-1; i > 0; i--, sp--, dp--)
    {
      val = *sp;

      /* SAIC TCQ begin */
      if (!(val & mask)) {
        val = 0;
      }
      /* SAIC TCQ end */

      val = (val<0)?(MIN_IFC_INT-val):val; /* Make two's-complement. */
      *dp = ((float) val) * scale;
      /* MITRE Generalized Scalar Quant begin */
      if (nz != 0) {
        if (*dp > 0)  *dp -= nz;
        else if (*dp < 0) *dp += nz;
      }
    }

  /* SAIC General Decomp. Begin */
  if (self->wt_output_file != NULL) {
    int line_num;
    int j;

    line_num = self->band_dims[level_idx][band_idx].top_row+
               self->current_band_line[level_idx][band_idx];
    assert(self->band_dims[level_idx][band_idx].cols == width);
    assert(self->current_band_line[level_idx][band_idx] <
           self->band_dims[level_idx][band_idx].rows);
    for (j=self->band_dims[level_idx][band_idx].left_col;
         j<self->band_dims[level_idx][band_idx].left_col +
           self->band_dims[level_idx][band_idx].cols; j++) {
      self->wt_output[line_num][j] =
        line_buf[j-self->band_dims[level_idx][band_idx].left_col];
    }
    self->current_band_line[level_idx][band_idx]++;
  }
  /* SAIC General Decomp. End */

}
/* MITRE General Offset/SQ End mods */

/*****************************************************************************/
/* STATIC                      __pull_line_fixed                             */
/*****************************************************************************/

static void
  __pull_line_fixed(dequantizer_ref base, ifc_int *line_buf,
                    int component_idx, int level_idx, int band_idx, int width)
{
  hpdz_dequantizer_ref self = (hpdz_dequantizer_ref) base;
  hpdz_component_info_ptr comp;
  hpdz_level_info_ptr lev;
  ifc_int *sp, shift, val;
  int i;

  /* SAIC TCQ begin */
  int extra_lsbs;
  ifc_int mask;
  /* SAIC TCQ end */

  assert(component_idx < self->num_components);
  comp = self->components + component_idx;
  assert(level_idx <= comp->num_levels);
  lev = comp->levels + level_idx;
  assert((band_idx >= lev->min_band) && (band_idx <= lev->max_band));
  shift = lev->bands[band_idx].left_shift;

  /* SAIC TCQ begin */
  extra_lsbs = lev->bands[band_idx].extra_lsbs;
  mask = -1 * (1 << extra_lsbs);
  /* SAIC TCQ end */

  self->decoder->pull_line(self->decoder,line_buf,
                           component_idx,level_idx,band_idx,width);
  if (self->three_eighths_mag)
    { /* Modify representation levels. */
      ifc_int mag, lsb_idx, max_mag;

      max_mag = self->three_eighths_mag;
      for (i=width, sp=line_buf; i > 0; i--, sp++)
        {
          val = *sp;

          /* SAIC TCQ begin */
          if (!(val & mask)) {
            val = 0;
          }
          /* SAIC TCQ end */

          if ((mag = val & MAX_IFC_INT) != 0)
            {
              designal_lsb_idx(mag,lsb_idx);
              if ((mag >> lsb_idx) <= max_mag)
                *sp = val - ((1<<lsb_idx)>>3);
            }
        }
    }
  if (shift == 0)
    for (sp=line_buf, i=width; i > 0; i--, sp++)
      { /* The `shift'=0 case occurs almost always in practice. */
        val = *sp;

        /* SAIC TCQ begin */
        if (!(val & mask)) {
          val = 0;
        }
        /* SAIC TCQ end */

        val = (val<0)?(MIN_IFC_INT-val):val;
        *sp = val;
      }
  else if (shift > 0)
    for (sp=line_buf, i=width; i > 0; i--, sp++)
      {
        val = *sp;

        /* SAIC TCQ begin */
        if (!(val & mask)) {
          val = 0;
        }
        /* SAIC TCQ end */

        if (val < 0)
          val = - ((val & MAX_IFC_INT) << shift);
        else
          val <<= shift;
        *sp = val;
      }
  else
    for (shift=-shift, sp=line_buf, i=width; i > 0; i--, sp++)
      {
        val = *sp;

        /* SAIC TCQ begin */
        if (!(val & mask)) {
          val = 0;
        }
        /* SAIC TCQ end */

        if (val < 0)
          val = - ((val & MAX_IFC_INT) >> shift);
        else
          val >>= shift;
        *sp = val;
      }

  /* SAIC General Decomp. Begin */
  if (self->wt_output_file != NULL) {
    int line_num;
    int j;

    line_num = self->band_dims[level_idx][band_idx].top_row+
               self->current_band_line[level_idx][band_idx];
    assert(self->band_dims[level_idx][band_idx].cols == width);
    assert(self->current_band_line[level_idx][band_idx] <
           self->band_dims[level_idx][band_idx].rows);
    for (j=self->band_dims[level_idx][band_idx].left_col;
         j<self->band_dims[level_idx][band_idx].left_col +
           self->band_dims[level_idx][band_idx].cols; j++) {
      self->wt_output[line_num][j] = (float)
        line_buf[j-self->band_dims[level_idx][band_idx].left_col];
    }
    self->current_band_line[level_idx][band_idx]++;
  }
  /* SAIC General Decomp. End */

}

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

static void
  __terminate(dequantizer_ref base)
{
  hpdz_dequantizer_ref self = (hpdz_dequantizer_ref) base;
  int c;

  /* SAIC General Decomp. Begin */
  if (self->wt_output_file != NULL) {
    canvas_dims tile_dims;
    hpdz_component_info_ptr comp;
    hpdz_level_info_ptr lev;
    float max, min;
    int num_levels;
    int i, j, n, b;
    unsigned char **usc_wt_output;
    FILE *fp;


    comp = self->components;
    num_levels = comp->num_levels;
    /* Begin Aerospace MCT mods */
    self->info->get_fixed_tile_info(self->info, 0, 0, NULL, NULL, &tile_dims,
                                    NULL, NULL, NULL, NULL,NULL,NULL,NULL);
    /* End Aerospace MCT mods */
    usc_wt_output = (unsigned char **)
      local_malloc(HPDZ_MEM_KEY, tile_dims.rows * sizeof(unsigned char *));
    usc_wt_output[0] = (unsigned char *)
      local_malloc(HPDZ_MEM_KEY, tile_dims.rows * tile_dims.cols *
                                 sizeof(unsigned char));
    for (i=1; i<tile_dims.rows; i++) {
      usc_wt_output[i] = usc_wt_output[i-1] + tile_dims.cols;
    }
    for (n=0; n<=num_levels; n++) {
      lev = comp->levels + n;
      for (b=lev->min_band; b<=lev->max_band; b++) {
        if (!self->valid_band[n][b])
          continue;
        max = min =
          self->wt_output[self->band_dims[n][b].top_row]
                         [self->band_dims[n][b].left_col];
        for (i=self->band_dims[n][b].top_row;
             i<self->band_dims[n][b].top_row +
               self->band_dims[n][b].rows; i++) {
          for (j=self->band_dims[n][b].left_col;
               j<self->band_dims[n][b].left_col +
                 self->band_dims[n][b].cols; j++) {
            if (self->wt_output[i][j] > max)
              max = self->wt_output[i][j];
            if (self->wt_output[i][j] < min)
              min = self->wt_output[i][j];
          }
        }
        if ((min == 0.0F) && (max == 0.0F))
          max = 1.0F;  /* Avoid divide by zero */
        for (i=self->band_dims[n][b].top_row;
             i<self->band_dims[n][b].top_row +
               self->band_dims[n][b].rows; i++) {
          for (j=self->band_dims[n][b].left_col;
               j<self->band_dims[n][b].left_col +
                 self->band_dims[n][b].cols; j++) {
            if (n == 0) {
              self->wt_output[i][j] =
                255*(self->wt_output[i][j] - min)/(max - min);
            }
            else {
              self->wt_output[i][j] = (float)
                (1024*fabs(self->wt_output[i][j])/MAX(fabs(min), fabs(max)));
              if (self->wt_output[i][j] > 255)
                self->wt_output[i][j] = 255;
            }
            usc_wt_output[i-tile_dims.top_row][j-tile_dims.left_col] =
              (unsigned char) self->wt_output[i][j];
          }
        }
      }
      local_free(self->valid_band[n]);
      local_free(self->current_band_line[n]);
      local_free(self->band_dims[n]);
    }
    local_free(self->valid_band);
    local_free(self->current_band_line);
    local_free(self->band_dims);
    local_free(self->min_band);
    local_free(self->max_band);

    fp = fopen(self->wt_output_file, "wb");
    fprintf(fp, "P5\n%d %d\n255\n", tile_dims.cols, tile_dims.rows);
    fwrite(usc_wt_output[0], sizeof(unsigned char), tile_dims.rows * tile_dims.cols, fp);
    fclose(fp);
    self->wt_output[tile_dims.top_row] += tile_dims.left_col;
    local_free(self->wt_output[tile_dims.top_row]);
    self->wt_output += tile_dims.top_row;
    local_free(self->wt_output);
    local_free(usc_wt_output[0]);
    local_free(usc_wt_output);
  }
  /* SAIC General Decomp. End */

  if (self->components != NULL)
    {
      for (c=0; c < self->num_components; c++)
        destroy_component_structures(self->components + c);
      local_free(self->components);
    }
  local_free(self);
}

/*****************************************************************************/
/* EXTERN                  create_deadzone_dequantizer                       */
/*****************************************************************************/

dequantizer_ref
  create_deadzone_dequantizer(void)
{
  hpdz_dequantizer_ref result;

  result = (hpdz_dequantizer_ref)
    local_malloc(HPDZ_MEM_KEY,sizeof(hpdz_dequantizer_obj));
  result->base.initialize = __initialize;
  result->base.get_usage = __get_usage;
  result->base.pull_line_float = __pull_line_float;
  result->base.pull_line_fixed = __pull_line_fixed;
  result->base.next_tile = __next_tile;
  result->base.terminate = __terminate;
  return((dequantizer_ref) result);
}