hplx_vert.c

JPEG2000 EBCOT算法源码

  
  for(i=0;i<self->h;i++){
    self->_data[i]=self->RawData+i*self->w;
    for( j = 0; j < self->w ; j++)self->_data[i][j]=0;}
  
   self->RawData = self->_data[self->Middle];
  
  if(bufferstogo>1)
    {
      self->next = (transform_ref)
        local_malloc(sizeof(transform_obj));
      memset(self->next,0,sizeof(transform_obj));
      self->next->UsedAsAnalysis = self->UsedAsAnalysis;
      internal_initialize(self->next,component_idx,(rows+1)>>1,(cols+1)>>1,
                          lev+1,bufferstogo-1,info,quant);
    }
  else
    assert(self->next == NULL);
  
  if(self->UsedAsAnalysis)
    {
      if (bufferstogo)
        {
          self->frd=create_decimator(); 
          self->frd->coeff_precision=self->coeff_precision;
          self->frd->fixed=self->fixed;
          self->frd->initialize(self->frd,cols,info,0xF0+bufferstogo-1,
                                self->component_idx);
        }
    }
  else
    {
      if (bufferstogo)
        {
          self->inv=create_interpolator();
          self->inv->coeff_precision=self->coeff_precision;
          self->inv->fixed=self->fixed;
          self->inv->initialize(self->inv,cols,info,0xF0+bufferstogo-1,
                                self->component_idx);
        }
    }
}

/*****************************************************************************/
/* STATIC                 internal_initialize_fixed                          */
/*****************************************************************************/
#if (IMPLEMENTATION_PRECISION == 16)
static int 
  internal_initialize_fixed(transform_ref self, int component_idx, int rows,
                            int cols, int lev, int bufferstogo,
                            filter_info_ref info, quantizer_ref quant,
                            int precision)
{
  static float impulse[] = {1.0F};
  int k, i,j,V_max, V_min;
  int h_neg, h_pos, l_neg, l_pos, Lmin, Lbeyond, Hmin, Hbeyond;
  float *h_taps, *l_taps;
  float band_factors[4], max_factor, min_factor;
  int zero_based_lev;
  int analysis_shift, synthesis_shift;
  
  self->quant = quant;      
  self->dequant = (dequantizer_ref) quant;
  self->component_idx = component_idx;
  self->fixed = (precision==0)?0:1;
  self->coeff_precision = precision;

  if (self->UsedAsAnalysis)
    self->dequant = NULL;
  else
    self->quant= NULL;
  
  self->ZLevel= bufferstogo;
  self->CmpLevel=lev;
  self->term=0;
  self->TrueExtra=0;
  self->ImageRows= rows ;
  
  /*****************************************/
  
  /*****************************************/
  self->Cpoke=self->Cpeek=0;
  self->w=cols;
  
  zero_based_lev = max(0,bufferstogo - 1);
  if (zero_based_lev == 0)
    {
      min_factor = 100.0F;
      max_factor = 0.0F;
      k = 0;
    }
  else
    {
      band_factors[0] = min_factor = max_factor = 1.0F;
      k = 1;
    }
  for (; k < ((bufferstogo)?4:1); k++)
   {
       int exponent;
       float step;
    
       info->get_quant_info(info,self->component_idx,zero_based_lev,k,
                           &step,&exponent,NULL,NULL);
       if (exponent >= 0)
         band_factors[k] = ((float)(1<<exponent)) / step;
       else
         band_factors[k] = 1.0F / (((float)(1<<-exponent)) * step);
       if (band_factors[k] > max_factor)
         max_factor = band_factors[k];
       if (band_factors[k] < min_factor)
         min_factor = band_factors[k];
    }

  if (bufferstogo)
    {
      l_taps = info->get_taps(info,FILTER__VERT,self->component_idx,
                              zero_based_lev,&l_neg,&l_pos,NULL);
      h_taps = info->get_taps(info,FILTER__VERT | FILTER__HIGH,
                              self->component_idx,
                              zero_based_lev,&h_neg,&h_pos,NULL);
    }
  else
    {
      l_neg = l_pos = h_neg = h_pos = 0;
      l_taps = h_taps = impulse;
    }
  analysis_shift = compute_shift_factor(l_taps,l_neg+l_pos+1,
                                        h_taps,h_neg+h_pos+1,
                                        self->coeff_precision,max_factor);
  self->EvenFilter = (l_neg+l_pos) & 1;
  Lmin = -l_pos; Lbeyond = l_neg+1;
  Hmin = -h_pos; Hbeyond = h_neg+1;
  
  if (self->EvenFilter)
    { Hmin--; Hbeyond--; }

  /*Height of the Vertical Buffer*/ 
  self->h = max(Lbeyond-Lmin,Hbeyond-Hmin); 

  /* set if even length filters and odd number of rows*/
  self->LoneLine = (rows & 1) & ! (self->h&1);

  /* Effective Length of signal*/
  self->maxY =self->LoneLine? ( ( rows >> 1 ) << 1) : rows;

  self->Middle = self->h >> 1 ;
  self->SecBuf_I=(short int *)
    local_malloc(self->w*sizeof(short int ));
  self->BufFast=( int *)
    local_malloc(self->w*sizeof( int ));

  for(i=0;i<self->w;i++)
    self->SecBuf_I[i]=(short int)0;
  
  if ( self->LoneLine)
    self->ExtraLine_I= (short int *)
      local_malloc(self->w*sizeof(short int ));
  for (k=0; k < 2; k++)
    {
      float l_factor, h_factor;
    
      if (k == 0)
        {
          l_factor = band_factors[LL_BAND];
          h_factor = band_factors[LH_BAND];
        }
      else
        {
          l_factor = band_factors[HL_BAND];
          h_factor = band_factors[HH_BAND];
        }
      self->LowA_I[k] = ( int *)
        local_malloc(2*self->h*sizeof( int ));
      self->HighA_I[k] = ( int *)
        local_malloc(2*self->h*sizeof( int )); 
      
      /*****************************************
       ********* set to zero all coefficients
       *****************************************/
    
    for( i = 0 ; i < 2 * self->h ; i++ ) 
      (self->LowA_I[k])[i] = (self->HighA_I[k])[i] = 0;
    
    /* analysis filters*/
    
    for(i = (Lbeyond-Lmin-1), j=self->h-Lmin-self->Middle-1;
        i >= 0; i--, j--)  
      (self->LowA_I[k])[j] =
        (self->LowA_I[k])[self->h+j] =
          roundshift(l_taps[i]*l_factor,analysis_shift);
    
    for (i = (Hbeyond-Hmin-1), j=self->h-Hmin-self->Middle-1;
         i >= 0; i--, j--) 
      (self->HighA_I[k])[j] =
        (self->HighA_I[k])[self->h+j] =
          roundshift(h_taps[i]*h_factor,analysis_shift);
    }
  
  /**************************************************************/
  
  /**************************************************************/
  
  V_max = (self->h+1)>>1;
  V_min = -((self->h)>>1);
  
  /* synthesis filters*/

  if (bufferstogo)
    {
      l_taps = info->get_taps(info,FILTER__VERT | FILTER__SYNTH,
                              component_idx,zero_based_lev,&l_neg,&l_pos,NULL);
      h_taps = info->get_taps(info,FILTER__VERT | FILTER__HIGH | FILTER__SYNTH,
                              component_idx,zero_based_lev,&h_neg,&h_pos,NULL);
    }
  synthesis_shift = compute_shift_factor(l_taps,l_neg+l_pos+1,
                                         h_taps,h_neg+h_pos+1,
                                         self->coeff_precision,
                                         1.0F/min_factor);
  l_taps -= Hmin;
  h_taps -= Lmin;
  for (k=0; k < 2; k++)
    {
      float l_factor, h_factor;
    
      if (k == 0)
        {
          l_factor = 1.0F / band_factors[LL_BAND];
          h_factor = 1.0F / band_factors[LH_BAND];
        }
      else
        {
          l_factor = 1.0F / band_factors[HL_BAND];
          h_factor = 1.0F / band_factors[HH_BAND];
        }
    self->LowS_I[k] = ( int *)
      local_malloc(2*self->h*sizeof( int ));
    self->HighS_I[k] = ( int *)
      local_malloc(2*self->h*sizeof( int )); 
    for( i = 0 ; i < 2 * self->h ; i++ ) 
      (self->LowS_I[k])[i] = (self->HighS_I[k])[i] = 0;
    for(i=0; i < V_max; i+=2)
      {
        if (i-self->EvenFilter < Lbeyond)
          (self->HighS_I[k])[-i-V_min] =
            roundshift(h_taps[i-self->EvenFilter]*h_factor,
                       synthesis_shift);
        else
          (self->HighS_I[k])[-i-V_min]=0;
        if(i<Hbeyond)
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] =
            roundshift(l_taps[i]*l_factor,synthesis_shift);
        else
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] = 0;
      }
    
    for(i=-2;i>=V_min;i-=2)
      {
        if (i>=Hmin)
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] =
            roundshift(l_taps[i]*l_factor,synthesis_shift);
        else
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] = 0;
        if (i-self->EvenFilter >= Lmin)
          (self->HighS_I[k])[-i-V_min] =
          roundshift(h_taps[i-self->EvenFilter]*h_factor,synthesis_shift);
        else
          (self->HighS_I[k])[-i-V_min]=0;
      }       
    for(i=1;i<V_max;i+=2)
      {
        if (i+self->EvenFilter < Lbeyond)
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] =
            roundshift(h_taps[i+self->EvenFilter]*h_factor,synthesis_shift);
        else
          (self->LowS_I[k])[-i-self->EvenFilter-V_min]=0;
      }
    
    for(i=1;i<=-V_min;i+=2)
      {                       
        if (i-2*self->EvenFilter < Hbeyond)
          (self->HighS_I[k])[-i-V_min] =
            roundshift(l_taps[i-2*self->EvenFilter]*l_factor,synthesis_shift);
        else
          self->HighS_I[k][-i-V_min]=0;
      }
    
    for(i=-1;i>=V_min;i-=2)
      {
        if (i+self->EvenFilter >= Lmin)
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] =
            roundshift(h_taps[i+self->EvenFilter]*h_factor,synthesis_shift);
        else
          (self->LowS_I[k])[-i-self->EvenFilter-V_min] = 0;
        if (i-2*self->EvenFilter >= Hmin)
          (self->HighS_I[k])[-i-V_min] =
            roundshift(l_taps[i-2*self->EvenFilter]*l_factor,synthesis_shift);
        else
          (self->HighS_I[k])[-i-V_min] = 0;
      }
    }
  
  for (k=0; k < 2; k++)
    for( i=0; i < self->h; i++)  
      {
        (self->LowS_I[k])[i+self->h] =
          (self->LowS_I[k])[i];
        (self->HighS_I[k])[i+self->h] =
          (self->HighS_I[k])[i];
        (self->LowA_I[k])[i+self->h] =
          (self->LowA_I[k])[i];
        (self->HighA_I[k])[i+self->h] =
          (self->HighA_I[k])[i];
     }
    /*********************************************************************/
    /*********************************************************************/
   if(bufferstogo)    
    self->RawData_I=(short int *)
      local_malloc(self->w*self->h*sizeof( short int ));
   else
    self->RawData_I=(short int *)
      local_malloc(self->w*self->h*sizeof( float ));

    
    self->_data_I = (short int **)
      local_malloc( self->h *  sizeof( short int * ) ) ; 
    for (i=0;i<self->h;i++)
      {
        self->_data_I[i]=self->RawData_I+i*self->w;
        for( j = 0; j < self->w ; j++)
          self->_data_I[i][j]=0;
      }
    
     self->RawData_I = self->_data_I[self->Middle];
    
    if(bufferstogo>1)
      {
        self->next = (transform_ref)
          local_malloc(sizeof(transform_obj));
        memset(self->next,0,sizeof(transform_obj));
        self->next->UsedAsAnalysis = self->UsedAsAnalysis;
        internal_initialize_fixed(self->next,component_idx,
                                  (rows+1)>>1,(cols+1)>>1,
                                  lev+1,bufferstogo-1,info,quant,precision);
      }
    else
      assert(self->next == NULL);
    if(self->UsedAsAnalysis)
      {
        if (bufferstogo)
          {
            self->frd=create_decimator();
            self->frd->coeff_precision=self->coeff_precision;
            self->frd->fixed=self->fixed;
            self->frd->initialize_fixed(self->frd,cols,info,
                                        0xF0+bufferstogo-1,
                                        self->component_idx);
          }
        self->shiftFactor = analysis_shift;
        self->lone_factors[0] =
          roundshift(band_factors[LL_BAND],analysis_shift);
        self->lone_factors[1] =
          roundshift(band_factors[HL_BAND],analysis_shift);
      }
    else
      {
        if (bufferstogo)
          {
            self->inv=create_interpolator();
            self->inv->coeff_precision=self->coeff_precision;
            self->inv->fixed=self->fixed;
            self->inv->initialize_fixed(self->inv,cols,info,
                                        0xF0+bufferstogo-1,
                                        self->component_idx);
          }
        self->shiftFactor = synthesis_shift;
        self->lone_factors[0] =
          roundshift(1.0F/band_factors[LL_BAND],synthesis_shift);
        self->lone_factors[1] =
          roundshift(1.0F/band_factors[HL_BAND],synthesis_shift);
      }
    return(1);
}
#endif /* IMPLEMENTATION_PRECISION */

/* ========================================================================= */
/* -------------------------- Internal Termination ------------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                    internal_terminate_fixed                        */
/*****************************************************************************/
#if (IMPLEMENTATION_PRECISION == 16)
static void
  internal_terminate_fixed(transform_ref self)
{
  int m, k;

  if(self->ZLevel)/* if we did have a transform*/
  {
  if(!self->CmpLevel) {
   if(self->UsedAsAnalysis)  {
    self->term=1;
    for (m=0;m<self->Middle*((1<<self->ZLevel)-1)+(self->ImageRows&1); m++)
        push_line_fixed(self,NULL); } }