component_mix.c

JPEG2000实现的源码

    for(j=0;j<col->intermed_segment[i].n_output_components;j++)
      if(col->intermed_segment[i].output_components[j] > max_c_number)
    max_c_number = col->intermed_segment[i].output_components[j];
  
  for(i=0;i<col->n_comp_segments;i++)
    for(j=0;j<col->comp_segment[i].n_output_components;j++)
      if(col->comp_segment[i].output_components[j] > max_c_number)
    max_c_number = col->comp_segment[i].output_components[j];
  
  col->n_codestream_components = max_c_number+1;
}

/*****************************************************************************
 * STATIC                    read_the_bitdepths                              *
 *****************************************************************************/
/* This routine allocates an integer array and fills it with the bitdepths that */
/* will go into the codestream as the result of the multi-component transform. */
/* Depending upon the file source, the bitdepths could be those that go into */
/* the CBD marker segment, or those that are required to fill the SIZ marker */
/* fields for the codestream components. */
static void
read_the_bitdepths(char *fname,int **component_bitdepth,
           int *number_of_components)
{
  
  *component_bitdepth = read_cbd_file(fname,number_of_components);

}
/* End Aerospace Mods (JHK) */

/*****************************************************************************/
/* STATIC                          write_the_mcts                            */
/*****************************************************************************/

static void write_the_mcts(the_component_mix_ref self)
{
  int i, n;
  stream_out_ref stream = self->stream;
  forward_info_ref info = self->info;
  matrix_data m;
  vector_data v;
  
  if (self->transforms == NULL)
    return;
  
  if (self->transforms->decorrel_xfms != NULL){
    for(i=1;i<=self->transforms->n_decorrel_xfm;i++){
      stream->declare_marker_elt(stream,-1,MARKER_MCT_IX,i-1,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_IX,i-1,
                 (std_uint) i, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_TYP,i-1,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_TYP,i-1,
                 (std_uint) 0, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_DT,i-1,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_DT,i-1,
                 (std_uint) 2, 0);
      m = self->transforms->decorrel_xfms[i];
      stream->declare_marker_elt_indirect(stream,-1,MARKER_MCT_SP,
                      i-1,(long int) m.width*m.height*sizeof(float));
      stream->set_marker_val_indirect(stream,-1,MARKER_MCT_SP,i-1,
                      (std_uint *) m.matrix_values[0], 1);
    }
  }
  n = self->transforms->n_decorrel_xfm;
  
  if (self->transforms->depend_xfms != NULL){
    for(i=1;i<=self->transforms->n_depend_xfm;i++,n++){
      stream->declare_marker_elt(stream,-1,MARKER_MCT_IX,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_IX,n,
                 (std_uint) i, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_TYP,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_TYP,n,
                 (std_uint) 1, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_DT,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_DT,n,
                 (std_uint) 2, 0);
      m = self->transforms->depend_xfms[i];
      stream->declare_marker_elt_indirect(stream,-1,MARKER_MCT_SP,
                      n,(long int) m.width*m.height*sizeof(float));
      stream->set_marker_val_indirect(stream,-1,MARKER_MCT_SP,n,
                      (std_uint *) m.matrix_values[0], 1);
    }
  }
  
  if (self->transforms->decorrel_offs != NULL){
    for(i=1;i<=self->transforms->n_decorrel_off;i++,n++) {
      stream->declare_marker_elt(stream,-1,MARKER_MCT_IX,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_IX,n,
                 (std_uint) i, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_TYP,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_TYP,n,
                 (std_uint) 2, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_DT,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_DT,n,
                 (std_uint) 2, 0);
      v = self->transforms->decorrel_offs[i];
      stream->declare_marker_elt_indirect(stream,-1,MARKER_MCT_SP,
                      n,(long int) v.length*sizeof(float));
      stream->set_marker_val_indirect(stream,-1,MARKER_MCT_SP,n,
                      (std_uint *) v.vector_values, 1);
    }
  }
  
  if (self->transforms->depend_offs != NULL){
    for(i=1;i<=self->transforms->n_depend_off;i++,n++) {
      stream->declare_marker_elt(stream,-1,MARKER_MCT_IX,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_IX,n,
                 (std_uint) i, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_TYP,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_TYP,n,
                 (std_uint) 3, 0);
      stream->declare_marker_elt(stream,-1,MARKER_MCT_DT,n,8,1);
      stream->set_marker_val(stream,-1,MARKER_MCT_DT,n,
                 (std_uint) 2, 0);
      v = self->transforms->depend_offs[i];
      stream->declare_marker_elt_indirect(stream,-1,MARKER_MCT_SP,
                      n,(long int) v.length*sizeof(float));
      stream->set_marker_val_indirect(stream,-1,MARKER_MCT_SP,n,
                      (std_uint *) v.vector_values, 1);
    }
  }
}

/*****************************************************************************/
/* STATIC                          write_the_mcc                             */
/*****************************************************************************/

static void write_the_mcc(stream_out_ref stream, collection_ref cptr, 
              int tile_num, int index)
{
  int i, j, nseg, nin, nout, cmax;
  std_uint *inlist_ptr, *outlist_ptr, *il, *ol;
  
  if (cptr == NULL)
    return;
  
  if(cptr->comp_segment != NULL){
    nseg = cptr->n_comp_segments;
    nin = nout = 0;
    for(i=0;i<cptr->n_comp_segments;i++){
      nin += cptr->comp_segment[i].n_input_components;
      nout += cptr->comp_segment[i].n_output_components;
    }
    
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_IX,index,8,1);
    stream->set_marker_val(stream,tile_num,MARKER_MCC_IX,index,
               (std_uint) index, 0);    
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_XMX,index,2,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_XWDO,index,4,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_NMCS,index,2,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_NMCN,index,14,nseg);    
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_MMCS,index,2,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_MMCN,index,14,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_TMCX,index,8,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MCC_TMCO,index,8,nseg);
    inlist_ptr = (std_uint *) local_malloc(MIXING_MEM_KEY,
                       nin*sizeof(std_uint));
    outlist_ptr = (std_uint *) local_malloc(MIXING_MEM_KEY,
                        nout*sizeof(std_uint));
    
    for(i=0,il=inlist_ptr,ol=outlist_ptr;i<nseg;i++){
      stream->set_marker_val(stream,tile_num,MARKER_MCC_XMX,index,
                 (std_uint) 0,i);
      stream->set_marker_val(stream,tile_num,MARKER_MCC_XWDO,index,
                 (std_uint) 0,i);
      for( j=0,cmax=-1;j<cptr->comp_segment[i].n_input_components;j++)
    if(cptr->comp_segment[i].input_components[j]>cmax)
      cmax = cptr->comp_segment[i].input_components[j];
      stream->set_marker_val(stream,tile_num,MARKER_MCC_NMCS,index,
                 (std_uint) (cmax >= 256)?1:0 , i);
      stream->set_marker_val(stream,tile_num,MARKER_MCC_NMCN,index,
                 (std_uint) cptr->comp_segment[i].n_input_components, i);
      for( j=0,cmax=-1;j<cptr->comp_segment[i].n_output_components;j++)
    if(cptr->comp_segment[i].output_components[j] > cmax)
      cmax = cptr->comp_segment[i].output_components[j];
      stream->set_marker_val(stream,tile_num,MARKER_MCC_MMCS,index,
                 (std_uint) (cmax >= 256)?1:0, i);
      stream->set_marker_val(stream,tile_num,MARKER_MCC_MMCN,index,
                 (std_uint) cptr->comp_segment[i].n_output_components, i);
      stream->set_marker_val(stream,tile_num,MARKER_MCC_TMCX,index,
                 (std_uint) cptr->comp_segment[i].xfm_matrix, i);
      stream->set_marker_val(stream,tile_num,MARKER_MCC_TMCO,index,
                 (std_uint) cptr->comp_segment[i].off_vector, i); 
      for(j=0;j<cptr->comp_segment[i].n_input_components;j++)
    *(il++) = (std_uint) cptr->comp_segment[i].input_components[j];
      for(j=0;j<cptr->comp_segment[i].n_output_components;j++)
    *(ol++) = (std_uint) cptr->comp_segment[i].output_components[j];
    }
    
    stream->declare_marker_elt_indirect(stream,-1,MARKER_MCC_CMC,
                    index, (long int) nin*sizeof(std_uint));    
    stream->set_marker_val_indirect(stream,-1,MARKER_MCC_CMC,index,
                    inlist_ptr, 1);                   
    stream->declare_marker_elt_indirect(stream,-1,MARKER_MCC_WMC,
                    index, (long int) nout*sizeof(std_uint));    
    stream->set_marker_val_indirect(stream,-1,MARKER_MCC_WMC,index,
                    outlist_ptr, 1);                    
    local_free(inlist_ptr);
    local_free(outlist_ptr);
  }
}

/*****************************************************************************/
/* STATIC                          write_the_mic                             */
/*****************************************************************************/

static void write_the_mic(stream_out_ref stream, collection_ref cptr, 
              int tile_num, int index)
{
  int i, j, nseg, nin, nout, cmax;
  std_uint *inlist_ptr, *outlist_ptr, *il, *ol;
  
  if (cptr == NULL)
    return;
  
  if (cptr->intermed_segment != NULL) {
    nseg = cptr->n_intermed_segments;
    nin = nout = 0;
    for(i=0;i<cptr->n_intermed_segments;i++){
      nin += cptr->intermed_segment[i].n_input_components;
      nout += cptr->intermed_segment[i].n_output_components;
    }
    
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_IX,index,8,1);
    stream->set_marker_val(stream,tile_num,MARKER_MIC_IX,index,
               (std_uint) index, 0);    
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_NMCS,index,2,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_NMCN,index,14,nseg);    
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_MMCS,index,2,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_MMCN,index,14,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_TMCX,index,8,nseg);
    stream->declare_marker_elt(stream,tile_num,MARKER_MIC_TMCO,index,8,nseg);
    inlist_ptr = (std_uint *) local_malloc(MIXING_MEM_KEY,
                       nin*sizeof(std_uint));
    outlist_ptr = (std_uint *) local_malloc(MIXING_MEM_KEY,
                        nout*sizeof(std_uint));
    
    for(i=0,il=inlist_ptr,ol=outlist_ptr;i<nseg;i++){
      for(j=0,cmax=-1;j<cptr->intermed_segment[i].n_input_components;j++)
    if(cptr->intermed_segment[i].input_components[j]>cmax)
      cmax = cptr->intermed_segment[i].input_components[j];
      stream->set_marker_val(stream,tile_num,MARKER_MIC_NMCS,index,
                 (std_uint) (cmax >= 256)?1:0 , i);
      stream->set_marker_val(stream,tile_num,MARKER_MIC_NMCN,index,
                 (std_uint) cptr->intermed_segment[i].n_input_components, i);
      for(j=0,cmax=-1;j<cptr->intermed_segment[i].n_output_components;j++)
    if(cptr->intermed_segment[i].output_components[j]>cmax)
      cmax = cptr->intermed_segment[i].output_components[j];
      stream->set_marker_val(stream,tile_num,MARKER_MIC_MMCS,index,
                 (std_uint) (cmax >= 256)?1:0,i);
      stream->set_marker_val(stream,tile_num,MARKER_MIC_MMCN,index,
                 (std_uint) cptr->intermed_segment[i].n_output_components, i);
      stream->set_marker_val(stream,tile_num,MARKER_MIC_TMCX,index,
                 (std_uint) cptr->intermed_segment[i].xfm_matrix, i);
      stream->set_marker_val(stream,tile_num,MARKER_MIC_TMCO,index,
                 (std_uint) cptr->intermed_segment[i].off_vector, i);
      for(j=0;j<cptr->intermed_segment[i].n_input_components;j++)
    *(il++)=(std_uint)cptr->intermed_segment[i].input_components[j];
      for(j=0;j<cptr->intermed_segment[i].n_output_components;j++)
    *(ol++)=(std_uint)cptr->intermed_segment[i].output_components[j];
    }
    
    stream->declare_marker_elt_indirect(stream,-1,MARKER_MIC_CMC,
                    index, (long int) nin*sizeof(std_uint));    
    stream->set_marker_val_indirect(stream,-1,MARKER_MIC_CMC,index,
                    inlist_ptr, 1);                   
    stream->declare_marker_elt_indirect(stream,-1,MARKER_MIC_WMC,
                    index, (long int) nout*sizeof(std_uint));    
    stream->set_marker_val_indirect(stream,-1,MARKER_MIC_WMC,index,
                    outlist_ptr, 1);                    
    local_free(inlist_ptr);
    local_free(outlist_ptr);
  }
}

/*****************************************************************************/
/* STATIC                          write_the_cbd                             */
/*****************************************************************************/

static void write_the_cbd(stream_out_ref stream, int *bitdepths, int num)
{
  stream->declare_marker_elt(stream,-1,MARKER_CBD_N,0,15,1);
  stream->set_marker_val(stream,-1,MARKER_CBD_N,0,(std_uint) num, 0);
  stream->declare_marker_elt_indirect(stream,-1,MARKER_CBD_BD, 0, 
                      (long int) num*sizeof(int));    
  stream->set_marker_val_indirect(stream,-1,MARKER_CBD_BD,0,bitdepths,1);
}
/* End Aerospace MCT mods (TSW) */

/*****************************************************************************/
/* STATIC                          modify_for_wavelet                        */
/*****************************************************************************/

static void
modify_for_wavelet(std_kernel_info third_d_kernel,float *relative_l2_norm_gains,
           float *relative_nominal_gains,int num_components)
     /* This function traces the synthesis operations from each subband back to
    the original image, computing the expansion in nominal range (DC gain)
    and the expansion in squared error (wmse) and recording this information
    in the `nominal_gain' and `l2_norm' fields of each `band_info'
    structure. */
{
  float nominal_gain;
  int n;
  int l;
  int c;
  int level_depth;
  int third_d_levels;
  int low_size;
  int high_start = 0;  /* TJF: =0 to avoid warnings */
  int high_size = 0;   /* TJF: =0 to avoid warnings */
  float l2_norm;
  std_tap_info conv_t1, conv_t2, tmp_taps;
  float t_low_gain = 0, t_high_gain = 0;
  
  /* Initialize the temporary synthesis waveform structures. */
  
  create_unit_waveform(&conv_t1);
  create_unit_waveform(&conv_t2);
  
  third_d_levels = (int) floor(log(num_components)/log(2.0F)-1);
  
  /* Now descend through the resolution levels, updating the base
     synthesis waveform in `conv_t1' as we go to represent
     the LL band in each successive resolution level, and determining the
     waveforms for each of the level's high-pass band as branches from this
     main path. */
  
  nominal_gain = 1.0F;
  t_low_gain = get_nominal_gain(third_d_kernel.low);
  t_high_gain = get_nominal_gain(third_d_kernel.high);