decompress.c

JPEG2000实现的源码

              info->get_fixed_tile_info(info,n,tnum,NULL,NULL,&fix_dims,
                                        NULL,NULL,NULL,NULL,NULL,&precision,&multicomp_xform);                    
              /* MITRE General Offset/SQ End */ /* End Aerospace MCT mods */

              info->get_var_tile_info(info,n,NULL,&var_dims,NULL,&downshift,
                      &dc_offset);
 
              /* OTLPF_CONVENTION begin; JX Wei ADFA, WJ Zeng Sharp */
              adjust_tile_dims(&var_dims, level_reduction, info, 0, otlpf_convention);
              adjust_tile_dims(&fix_dims, level_reduction, info, 0, otlpf_convention);
              /* OTLPF_CONVENTION end; JX Wei ADFA, WJ Zeng Sharp */

              /* MITRE General Offset/SQ Begin */
              local_printf( 0,76, "Comp %d Tile %d Offset %lg\n", n, tnum,
                            dc_offset);

              comps[n].offset = -dc_offset;
              /* MITRE General Offset/SQ End */

              comps[n].tile_rows = fix_dims.rows;
              comps[n].tile_cols = fix_dims.cols;
              comps[n].downshift = (ifc_int) downshift;
              comps[n].ovlp_top = fix_dims.top_row - var_dims.top_row;
              comps[n].ovlp_left = fix_dims.left_col - var_dims.left_col;
              comps[n].ovlp_bottom = var_dims.rows - fix_dims.rows
                                   - comps[n].ovlp_top;
              comps[n].ovlp_right = var_dims.cols - fix_dims.cols
                                  - comps[n].ovlp_left;
              assert(((comps[n].ovlp_top & ~1) == 0) &&
                     ((comps[n].ovlp_bottom & ~1) == 0) &&
                     ((comps[n].ovlp_left & ~1) == 0) &&
                     ((comps[n].ovlp_right & ~1) == 0));
              comps[n].line_remainder = 0.0F;
              comps[n].tile_row_idx = 0;
              comps[n].max_tile_row_idx = comps[n].tile_rows-1;
              if (comps[n].ovlp_top)
                { assert(ynum > 0); comps[n].tile_row_idx--; }
              if (comps[n].ovlp_bottom)
                { assert(ynum < (tiles_down-1)); comps[n].max_tile_row_idx++; }
            }

          /* Now pull lines from the tile components in a synchronized
             fashion. */

          do {
            done = 1;
            for (n=0; n < num_components; n++)
              {
                int tile_cols, r;
                ifc_int *sp, *dp, offset, downshift, val;

                if (comps[n].tile_row_idx > comps[n].max_tile_row_idx)
                  continue;
                done = 0;
                comps[n].line_remainder -= comps[n].line_rate;
                if (comps[n].line_remainder >= 0.0F)
                  continue;
                comps[n].line_remainder += 1.0F;
                r = comps[n].tile_row_idx++;
                if (xnum == (tiles_across-1))
                  release_image_row(comps+n,n,r-1-comps[n].ovlp_bottom,writer);
                buf = get_image_row(comps+n,r);
                assert(comps[n].row_offset >= comps[n].ovlp_left);
                buf += comps[n].row_offset - comps[n].ovlp_left;
                tile_cols = comps[n].tile_cols +
                  (comps[n].ovlp_left + comps[n].ovlp_right);
                assert(comps[n].row_offset-comps[n].ovlp_left+tile_cols <=
                       comps[n].cols);
                assert(tile_cols <= (max_cols+2));
                demixer->pull_line(demixer,work,n,tile_cols);
                downshift = comps[n].downshift;
                /* Begin Aerospace MCT mods (TSW) */
                /* Must check here to see if a multicomponent transform
                was performed for this tile. If so, we skip the downshift
                since it has already been taken out prior to the transform */
                if ( multicomp_xform == 0 ) {
                if (downshift > 0)
                  {
                    offset = (short) floor((comps[n].offset)*(1<<downshift));
                    offset -= (1<<(downshift-1)); /* Add rounding offset. */
                    for (sp=work, k=tile_cols; k > 0; k--)
                      {
                        val = *sp;
                        val -= offset;
                        val >>= downshift;
                        *(sp++) = val;
                      }
                  }
                else
                  {
                    downshift = -downshift;
                    offset = (short) floor(comps[n].offset + 0.5);
                    for (sp=work, k=tile_cols; k > 0; k--)
                      {
                        val = *sp;
                        val <<= downshift;
                        val -= offset;
                        *(sp++) = val;
                      }
                  }
                }
                /* End Aerospace MCT mods */
                if (r < comps[n].tile_bottom_ovlp[xnum])
                  { /* Take average of new and existing row. */
                    for (sp=work, dp=buf, k=tile_cols; k > 0; k--)
                      { val = *dp; val += *(sp++); *(dp++) = (val+1)>>1; }
                  }
                else
                  {
                    
                    int ovlp_cols;

                    ovlp_cols = comps[n].last_right_ovlp + comps[n].ovlp_left;
                    for (sp=work, dp=buf, k=ovlp_cols; k > 0; k-- )
                      { val = *dp; val += *(sp++); *(dp++) = (val+1)>>1; }
                    for (k=tile_cols-ovlp_cols; k > 0; k--)
                      *(dp++) = *(sp++);
                  }
              }
          } while (!done);

          /* Adjust counters for next horizontal tile. */
          for (n=0; n < num_components; n++)
            {
              comps[n].row_offset += comps[n].tile_cols;
              comps[n].last_right_ovlp = comps[n].ovlp_right;
              comps[n].tile_bottom_ovlp[xnum] = comps[n].ovlp_bottom;
            }

          if (info->next_tile(info,0))
            demixer->next_tile(demixer);
        }
    }

  /* Cleanup. */

  for (n=0; n < num_components; n++)
    {
      int r;

      if (comps[n].num_buffer_rows > 0)
        {
          r = comps[n].min_buffer_row_idx + comps[n].num_buffer_rows - 1;
          release_image_row(comps+n,n,r,writer);
        }
      for (r=0; r < comps[n].max_buffer_rows; r++)
        local_free(comps[n].buffer[r]);
      local_free(comps[n].buffer);
      local_free(comps[n].tile_bottom_ovlp);
    }
  local_free(comps);
  local_free(work);
}

/*****************************************************************************/
/* STATIC                    find_dec_constructors                           */
/*****************************************************************************/

static void
  find_dec_constructors(dec_constructor_info_ptr constructors, cmdl_ref cmdl)

 /* Fills out the entries of the `constructors' structure.  May use command
    line arguments in the future to decide between different implementations
    of some object.  For the moment, only one implementation is provided
    for each object. */

{
  extern image_writer_ref create_simple_image_writer(void);
  extern stream_in_ref create_reference_stream_in(void);
  extern reverse_info_ref create_std_reverse_info(void);
  extern decoder_ref create_ebcot_decoder(void);
  extern reverse_roi_ref create_reference_reverse_roi(void);
  extern dequantizer_ref create_deadzone_dequantizer(void);
  extern synthesis_ref create_hplx_synthesis(void);
  extern component_demix_ref create_component_demix(void);

  constructors->image_writer = create_simple_image_writer;
  constructors->stream_in = create_reference_stream_in;
  constructors->reverse_info = create_std_reverse_info;
  constructors->decoder = create_ebcot_decoder;
  constructors->reverse_roi = create_reference_reverse_roi;
  constructors->dequantizer = create_deadzone_dequantizer;
  constructors->synthesis = create_hplx_synthesis;
  constructors->component_demix = create_component_demix;
}

/*****************************************************************************/
/* STATIC                    modify_dec_constructors                         */
/*****************************************************************************/

/* EKC mct begin mods */
static void
  modify_dec_constructors(dec_constructor_info_ptr constructors,
                          stream_in_ref stream, cmdl_ref cmdl)
/* EKC mct end mods */

 /* Modifies entries of the `constructors' structure based on stream header. */

{
  int quantizer;

  extern dequantizer_ref create_deadzone_dequantizer(void);
  extern dequantizer_ref create_tcq_dequantizer(void);

  /* EKC mct begin */
  extern image_writer_ref create_mcraw_image_writer(void);
  int k, num_args, have_pgx, have_mcraw;
  char **params;
  /* EKC mct end */

  quantizer = (int) stream->get_marker_val(stream,-1,MARKER_QCD_WHICH,0,0);
  switch (quantizer) {
    case 0:
      local_printf(0, 80, "Uniform quantization");
      /* Already set constructor for this in find_dec_constructors() */
      break;
    case 1:
      local_error("Qmask quantizer no longer available. Qmask now implemented as Xmask!");
      break;
    case 2:
      local_printf(0, 80, "Trellis coded quantization");
      constructors->dequantizer = create_tcq_dequantizer;
      break;
    default:
      local_error("Invalid quantization flag in header!");
  }

  /* EKC mct begin */
  if ((num_args = cmdl->extract(cmdl,"-o",-1,&params)) <= 0) {
     return;
  }
  have_pgx = have_mcraw = 0;
  for (k=0; k < num_args; k++) {
    if ((strstr(params[k], ".img") != NULL) ||
        (strstr(params[k], ".nrm") != NULL) ||
        (strstr(params[k], ".bil") != NULL) ||
        (strstr(params[k], ".raw") != NULL) ||
        (strstr(params[k], ".bsq") != NULL) ||
        (strstr(params[k], ".bip") != NULL))
      have_mcraw = 1;
    else
      have_pgx = 1;
  }
  if ((have_pgx + have_mcraw) > 1) {
    local_error("Unable to support different output file formats on the "
                "same command line...");
  }
  if (have_mcraw) {
    constructors->image_writer = create_mcraw_image_writer;
  }
  /* EKC mct end */

}

/*****************************************************************************/
/* STATIC                      print_generic_usage                           */
/*****************************************************************************/

static void
  print_generic_usage(char **usage)

 /* Formats and prints the usage information recovered from the `get_usage'
    function offered by any of the standard objects. */

{
  if (usage == NULL)
    return;
  for (; *usage != NULL; usage += 2)
    {
      local_printf(4,70,"%s",usage[0]);
      if (usage[1] != NULL)
        local_printf(7,70,"%s",usage[1]);
    }
}

/*****************************************************************************/
/* STATIC                          print_usage                               */
/*****************************************************************************/

static void
  print_usage(int default_verbose, dec_constructor_info_ptr constructors)
{

  /* EKC mct begin */
  extern image_writer_ref create_simple_image_writer(void);
  extern image_writer_ref create_mcraw_image_writer(void);
  /* EKC mct end */

  image_writer_ref image;
  stream_in_ref stream;
  reverse_info_ref info;
  decoder_ref decoder;
  reverse_roi_ref roi;
  dequantizer_ref dequantizer;
  synthesis_ref synthesis;
  component_demix_ref demixer;
  
  local_printf(0,70,"\nThe following arguments are recognized:");

  /* EKC mct begin mods */
  image = create_simple_image_writer();
  print_generic_usage(image->get_usage(image));
  image->terminate(image);

  image = create_mcraw_image_writer();
  print_generic_usage(image->get_usage(image));
  image->terminate(image);
  /* EKC mct end mods */

  local_printf(4,70,"-i <name of compressed bit-stream file>");
  local_printf(4,70,"-red <reconstruction level reduction> (default = 0)");
  local_printf(7,70,"Identifies number of highest frequency resolution "
               "levels to discard from each tile.  An error will be "
               "generated if a tile is encountered which has fewer "
               "decomposition levels in its Wavelet transform.");
  local_printf(4,70,"-parse <max rate in bpp> (default = no limit)");
  local_printf(7,70,"Reduces the bit-rate by simulated parsing.  You "
               "should use this only if truncation with the `-trunc' "
               "argument is inappropriate (e.g. if you are using tiles or "
               "a non-layer-progressive packet order).");
  local_printf(4,70,"-trunc <max rate in bpp> (default = no truncation)");
  local_printf(7,70,"Reduce the bit-rate by placing a hard limit on the "
               "number of bytes which can be read from the input file.  ");
  local_printf(4,70,"-comp <max reconstructed components> (default = all)");
  local_printf(4,70,"-mem [<stop id>]");  /* SAIC addition */
  local_printf(7,70,"Print memory usage report.  If the optional `stop_id' "
               "parameter is supplied, the program will halt when allocating "
               "memory with the supplied non-zero identifier.  This is the "
               "same identifier printed by the memory report if memory "
               "leaks are detected.");
  local_printf(4,70,"-verbose (default = %s)",
               (default_verbose)?"verbose":"quiet");
  local_printf(4,70,"-quiet (default = %s)",
               (default_verbose)?"verbose":"quiet");

  stream = constructors->stream_in();
  print_generic_usage(stream->get_usage(stream));
  stream->terminate(stream);
  info = constructors->reverse_info();
  print_generic_usage(info->get_usage(info));
  info->terminate(info);
  decoder = constructors->decoder();
  print_generic_usage(decoder->get_usage(decoder));
  decoder->terminate(decoder);
  roi = constructors->reverse_roi();
  print_generic_usage(roi->get_usage(roi));
  roi->terminate(roi);
  dequantizer = constructors->dequantizer();
  print_generic_usage(dequantizer->get_usage(dequantizer));
  dequantizer->terminate(dequantizer);
  synthesis = constructors->synthesis();
  print_generic_usage(synthesis->get_usage(synthesis));
  synthesis->terminate(synthesis);
  demixer = constructors->component_demix();