hplx_vert.c

来自「JPEG2000 EBCOT算法源码」· C语言 代码 · 共 2,020 行 · 第 1/5 页

          self->frd->set_size(self->frd,(int)(self->w+1)>>1);
          self->frd->decimate_fixed(self->frd,self->next->RawData_I);
        }
        push_line_fixed(self->next,NULL);
      }
      else 
      {
        transform_line_based_analysis_fixed(self,self->frd->buffer_I);
        self->quant->push_line_fixed( self->quant,
          self->frd->buffer_I,self->component_idx,
          self->ZLevel-1,LL_BAND,( self->w +1)/2  );
        self->quant->push_line_fixed( self->quant,
          self->frd->buffer_I + (( self->w +1)>>1) ,
          self->component_idx,self->ZLevel-1, HL_BAND, self->w >> 1  );
      }
    }
    else if ( self->Cpeek < self->ImageRows)
    {
      transform_line_based_analysis_fixed(self,self->frd->buffer_I);
      self->quant->push_line_fixed(self->quant,
        self->frd->buffer_I,self->component_idx,self->ZLevel-1, LH_BAND,
        (self->w+1)/2 );
      self->quant->push_line_fixed(self->quant,
        self->frd->buffer_I+(self->w+1)/2 ,
        self->component_idx,self->ZLevel-1, HH_BAND,  self->w>>1   );
    }
  }
}
#endif /* IMPLEMENTATION_PRECISION */

/*****************************************************************************/
/* STATIC                  push_line_fixed_zero                              */
/*****************************************************************************/
#if (IMPLEMENTATION_PRECISION == 16)
static void
  push_line_fixed_zero(transform_ref self, short int *ptr_indx)
{
  int i;
  int l1,l,fact;
  short int *tmp;
          
  tmp=ptr_indx;
  fact=self->lone_factors[0];
  l=self->shiftFactor;
  l1=1<<(l-1);

  for( i = 0; i<self->w; i++, tmp++)
    *tmp = (short int)((*tmp * fact + l1) >> l);

  self->quant->push_line_fixed(self->quant,
        ptr_indx,self->component_idx,0, 0,self->w);
}
#endif /* IMPLEMENTATION_PRECISION */

/* ========================================================================= */
/* ---------------------------- Pull Functions ----------------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                   internal_pull_line_float                         */
/*****************************************************************************/

static int
  internal_pull_line_float(transform_ref self, float *ptr_indx)
{
  if ( self->Cpoke & 1 ){
    if (self->Cpoke < self->ImageRows){
      self->dequant->pull_line_float(self->dequant,
        self->inv->_data,self->component_idx,self->ZLevel-1,LH_BAND,
        (self->w+1)>>1);
      self->dequant->pull_line_float(self->dequant,
        self->inv->_data + ((self->w+1)>>1),
        self->component_idx,self->ZLevel-1,HH_BAND ,self->w>>1  );
      self->inv->set_size(self->inv,(int)self->w);
      self->inv->interpolate(self->inv,self->RawData); }}
  else
  { if (self->next==NULL){/* Get LL Band from dequantizer. */
           if(self->Cpoke < self->ImageRows )
            self->dequant->pull_line_float( self->dequant,
             self->inv->_data ,self->component_idx,self->ZLevel-1,
             LL_BAND ,(self->w+1) >> 1 );}
    else /* Get LL Band from next level. */
      while (internal_pull_line_float(self->next,self->inv->_data));
    
    if(self->Cpoke < self->ImageRows ) {
      self->dequant->pull_line_float( self->dequant,
        self->inv->_data + (self->w+1)/2,
        self->component_idx,self->ZLevel-1,HL_BAND,self->w>>1);
      self->inv->set_size(self->inv,(int)self->w);
      self->inv->interpolate(self->inv,self->RawData);}
  }
  transform_line_based_update(self);
  if(self->Cpoke > self->Middle )
    transform_line_based_synthesis(self,ptr_indx);
   return(self->Cpoke <= self->Middle);
}

/*****************************************************************************/
/* STATIC                      pull_line_float                               */
/*****************************************************************************/

static void
  pull_line_float(transform_ref self, ifc_int *ptr_indx)
{
  register float *sp;
  int i;
  
  sp = self->inv->_data;
  while (internal_pull_line_float(self,sp));
  i=self->w;
  while(i--)  *(ptr_indx++) = float2int( *(sp++) );
}

/*****************************************************************************/
/* STATIC                    pull_line_float_zero                            */
/*****************************************************************************/

static void
  pull_line_float_zero(transform_ref self, ifc_int *ptr_indx)
{
  int i;
  register float *ftmp;
  
  ftmp=self->RawData;
  self->dequant->pull_line_float(self->dequant,
                                 ftmp,self->component_idx,0,0,self->w);
  i=self->w;
  while(i--)
      *(ptr_indx++) = float2int(*(ftmp++));
}

/*****************************************************************************/
/* STATIC                  internal_pull_line_fixed                          */
/*****************************************************************************/
#if (IMPLEMENTATION_PRECISION == 16)
static int 
  internal_pull_line_fixed(transform_ref self, short int *ptr_indx)
{
 if (self->Cpoke & 1){
  if (self->Cpoke < self->ImageRows){
    self->dequant->pull_line_fixed(self->dequant,
      self->RawData_I,self->component_idx,
      self->ZLevel-1,LH_BAND,(self->w+1)>>1);
    self->dequant->pull_line_fixed(self->dequant,
      self->RawData_I + ((self->w+1)>>1) ,
      self->component_idx,self->ZLevel-1,
      HH_BAND,self->w>>1);}
  }
 else {
  if (self->next==NULL) { /* Get LL band from dequantizer. */
   if(self->Cpoke < self->ImageRows )
      self->dequant->pull_line_fixed( self->dequant,
        self->RawData_I ,self->component_idx,
        self->ZLevel-1,LL_BAND ,(self->w+1) >> 1 );}
   else /* Get LL band from lower level. */
      while (internal_pull_line_fixed(self->next,self->RawData_I));
        
   if (self->Cpoke < self->ImageRows) 
      self->dequant->pull_line_fixed( self->dequant,
       self->RawData_I + ((self->w+1)>>1),
       self->component_idx,self->ZLevel-1,HL_BAND,self->w>>1);}

  transform_line_based_update_fixed(self);

  if(self->Cpoke > self->Middle ) {
      transform_line_based_synthesis_fixed(self,self->inv->_data_I);
      self->inv->set_size(self->inv,(int) self->w);
      self->inv->interpolate_fixed(self->inv,ptr_indx);
    }
  return(self->Cpoke <= self->Middle);
}
#endif /* IMPLEMENTATION_PRECISION */

/*****************************************************************************/
/* STATIC                    pull_line_fixed                                 */
/*****************************************************************************/
#if (IMPLEMENTATION_PRECISION == 16)
static void
  pull_line_fixed(transform_ref self, short int *ptr_indx)
{
  while (internal_pull_line_fixed(self,ptr_indx));
}
#endif /* IMPLEMENTATION_PRECISION */

/*****************************************************************************/
/* STATIC                    pull_line_fixed_zero                            */
/*****************************************************************************/
#if (IMPLEMENTATION_PRECISION == 16)
static void
  pull_line_fixed_zero(transform_ref self, short int *ptr_indx)
{
  register int i;
  register int l1,l,fact;
  
  fact=self->lone_factors[0];
  l=self->shiftFactor;
  l1=1<<(l-1);
        
  self->dequant->pull_line_fixed(self->dequant,ptr_indx,
                                 self->component_idx,0,0,self->w);
  for( i = 0; i<self->w;i++, ptr_indx++)  
    *ptr_indx = (short int )((*ptr_indx * fact + l1 ) >> l);
}
#endif /* IMPLEMENTATION_PRECISION */


/* ========================================================================= */
/* ------------------------- Internal Initialization ----------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                      internal_initialize                           */
/*****************************************************************************/

static void 
  internal_initialize(transform_ref self, int component_idx, int rows,
                      int cols, int lev, int bufferstogo,
                      filter_info_ref info, quantizer_ref quant)
{
  static float impulse[] = {1.0F};
  int i,j,V_max, V_min;
  int h_neg, h_pos, l_neg, l_pos, Lmin, Lbeyond, Hmin, Hbeyond;
  float *h_taps, *l_taps;

  self->quant = quant;      
  self->dequant = (dequantizer_ref) quant;
  self->component_idx = component_idx;
  
  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;

  if (bufferstogo)
    {
      l_taps = info->get_taps(info,FILTER__VERT,self->component_idx,
                              bufferstogo-1,&l_neg,&l_pos,NULL);
      h_taps = info->get_taps(info,FILTER__VERT | FILTER__HIGH,
                              self->component_idx,
                              bufferstogo-1,&h_neg,&h_pos,NULL);
    }
  else
    {
      l_neg = l_pos = h_neg = h_pos = 0;
      l_taps = h_taps = impulse;
    }  

  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=(float*)
    local_malloc(self->w*sizeof(float));
  
  for(i=0;i<self->w;i++) self->SecBuf[i]=0;
  
  if ( self->LoneLine )
    self->ExtraLine= (float*)
    local_malloc(self->w*sizeof(float));
  
  self->LowA = (float*)
    local_malloc(2*self->h*sizeof(float));
  self->HighA= (float*)
    local_malloc(2*self->h*sizeof(float)); 
  
  self->LowS = (float*)
    local_malloc(2*self->h*sizeof(float));
  self->HighS= (float*)
    local_malloc(2*self->h*sizeof(float)); 
  
  /*****************************************
  ********* set to zero all coefficients
  *****************************************/
  
  for( i = 0 ; i < 2 * self->h ; i++ ) 
    self->LowA[i] = self->HighA[i] =
    self->LowS[i] = self->HighS[i] = 0.0F;
  
  /* analysis filters*/
  
  for( i = (Lbeyond-Lmin-1), j=self->h-Lmin-self->Middle-1;
  i >= 0; i--, j--)  
    self->LowA[j]=self->LowA[self->h+j]=l_taps[i];
  for( i = (Hbeyond-Hmin-1), j=self->h-Hmin-self->Middle-1;
  i >= 0; i--, j--) 
    self->HighA[j]=self->HighA[self->h+j]=h_taps[i];
  
 
  /**************************************************************/
  
  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,
                              self->component_idx,bufferstogo-1,
                              &l_neg,&l_pos,NULL);
      h_taps = info->get_taps(info,FILTER__VERT | FILTER__HIGH | FILTER__SYNTH,
                              self->component_idx,bufferstogo-1,
                              &h_neg,&h_pos,NULL);
    }
  l_taps -= Hmin;
  h_taps -= Lmin;
  
  for(i=0; i < V_max; i+=2)
  {
    if(i-self->EvenFilter < Lbeyond)
      self->HighS[-i-V_min]=h_taps[i-self->EvenFilter];
    else
      self->HighS[-i-V_min]=(float)(0.0);
    
    if(i<Hbeyond)
      self->LowS[-i-self->EvenFilter-V_min]=l_taps[i];
    else
      self->LowS[-i-self->EvenFilter-V_min]=(float)(0.0);
  }
  
  for(i=-2;i>=V_min;i-=2)
  {
    if(i>=Hmin)
      self->LowS[-i-self->EvenFilter-V_min]=l_taps[i];
    else
      self->LowS[-i-self->EvenFilter-V_min]=(float)(0.0);
    if(i-self->EvenFilter >= Lmin)
      self->HighS[-i-V_min]=h_taps[i-self->EvenFilter];
    else
      self->HighS[-i-V_min]=(float)(0.0);
  }       
  for(i=1;i<V_max;i+=2)
  {
    if(i+self->EvenFilter < Lbeyond)
      self->LowS[-i-self->EvenFilter-V_min] =
      h_taps[i+self->EvenFilter];
    else
      self->LowS[-i-self->EvenFilter-V_min]=(float)(0.0);
  }
  
  for(i=1;i<=-V_min;i+=2)
  {                       
    if(i-2*self->EvenFilter < Hbeyond)
      self->HighS[-i-V_min] = l_taps[i-2*self->EvenFilter];
    else
      self->HighS[-i-V_min]=(float)(0.0);
  }
  
  for(i=-1;i>=V_min;i-=2)
  {
    if(i+self->EvenFilter >= Lmin)
      self->LowS[-i-self->EvenFilter-V_min] =
      h_taps[i+self->EvenFilter];
    else
      self->LowS[-i-self->EvenFilter-V_min]=(float)(0.0);
    
    if(i-2*self->EvenFilter >= Hmin)
      self->HighS[-i-V_min] = l_taps[i-2*self->EvenFilter];
    else
      self->HighS[-i-V_min] = (float)(0.0); 
  }
  
  for( i=0; i < self->h; i++)  
  {
    self->LowS[i+self->h]  = self->LowS[i];
    self->HighS[i+self->h] = self->HighS[i];
    self->LowA[i+self->h]  = self->LowA[i];
    self->HighA[i+self->h] = self->HighA[i];
  }

  /***********************************************************************/
  /**********************************************************************/
  
  self->RawData=(float*)
    local_malloc(self->w*self->h*sizeof(float));
  
  self->_data = (float**)
    local_malloc(self->h*sizeof(float*)) ;