hplx_hor.c

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

	  i>>=1;
	  while(i--){
		  ftmp=*(downH++);
          tmpf=SindxH++;
	      tmpf1=Sindex1--;
	      tmp_ptr=self->BufFast;
	      k=j;
		  if(evenF) { /*Even Length Filter*/
	        if(flag) while(k--) *(tmp_ptr++) = 
				   ftmp* (*(tmpf +=2 )-*(tmpf1 +=2)) ;
	        else   while(k--) *(tmp_ptr++) += 
				ftmp* ((int)*(tmpf +=2 )-(int)*(tmpf1 +=2)); }
		  else  {  /*Odd length Filter*/
	        if(flag) while(k--)  *(tmp_ptr++) = 
				ftmp* ((int)*(tmpf +=2 )+(int)*(tmpf1 +=2)) ;
	        else  while(k--) *(tmp_ptr++) += 
				ftmp* ((int)*(tmpf +=2 )+(int)*(tmpf1 +=2)); }
		  flag=0;
         }

       if(!evenF)  {/*Odd Length filter*/
            ftmp=*(downH++);
            tmpf=SindxH++;
            tmp_ptr=self->BufFast;
            k=j;
	        if(flag) while(k--)*(tmp_ptr++) = 
				         ftmp* *(tmpf += 2 );
	        else  while(k--)    *(tmp_ptr++) += 
				         ftmp* *(tmpf += 2 );}
      tmp_ptr=self->BufFast;
	  k=j;
	  /* Write data to Output Buffer*/
      while(k--)  *(V++) = (*(tmp_ptr++) +l1)>>l;
}

/************************************************************************/
decimator_ref
  create_decimator(void)
{
  decimator_ref result;
  
  result = (decimator_ref)
    local_malloc(sizeof(decimator));
  memset(result,0,sizeof(decimator));
  result->initialize_fixed = decimator__initialize_fixed;
  result->initialize       = decimator__initialize;
  result->decimate        =  decimator__decimate;
  result->decimate_fixed  =  decimator__decimate_fixed;
  result->set_size   =  decimator__set_size;
  result->terminate  =  decimator__terminate;
  return((decimator_ref) result);
}

/************************************************************************/
static int
  interpolator__terminate(interpolator_ref self)
{
  if(!self->fixed)
  {
    local_free(self->buffer-=self->V_max);
    if (self->_data != NULL)
      local_free(self->_data);
    local_free(self->VL_Low+=self->V_min-self->VL_min);
    local_free(self->VH_Low+=self->V_min-self->VH_min);
  }
  else
  {
    local_free(self->buffer_I-=self->V_max);
    if (self->_data_I != NULL)
      local_free(self->_data_I);
    local_free(self->VL_Low_I+=self->V_min-self->VL_min);
    local_free(self->VH_Low_I+=self->V_min-self->VH_min);
    local_free(self->BufFast);
  }
  local_free(self);
  return(0);
}

/************************************************************************/
/*
*  initialization routine for class interpolator
*
*/
/************************************************************************/

static void
  interpolator__initialize_fixed(interpolator_ref self, 
                                 int  X,filter_info_ref info,int c_levs,
                                 int component_idx)
{
  int i,PLUSMINUS1;
  int  *Lfilt,*Hfilt;
  float *l_taps, *h_taps;
  int h_neg, h_pos, l_neg, l_pos, Lmin, Lbeyond, Hmin, Hbeyond;
  char *built_in_id;

  
  self->DefaultFB = 0;
  self->component_idx = component_idx;
  
  l_taps = info->get_taps(info,FILTER__SYNTH,component_idx,0x0F & c_levs,
                          &l_neg,&l_pos,NULL);
  h_taps = info->get_taps(info,FILTER__HIGH | FILTER__SYNTH,component_idx,
                          0x0F & c_levs,&h_neg,&h_pos,&built_in_id);
  self->shiftFactor = compute_shift_factor(l_taps,l_neg+l_pos+1,
    h_taps,h_neg+h_pos+1,
    self->coeff_precision,1.0F);
  
  if (strcmp(built_in_id,"0") == 0)
    self->DefaultFB = 1;
  
  self->EvenFilter = (l_neg+l_pos) & 1;
  Lmin = -l_neg; Lbeyond = l_pos+1;
  Hmin = -h_neg; Hbeyond = h_pos+1;
  if (self->EvenFilter)
  { Lmin--; Lbeyond--; }
  
  self->VH_min = Hmin;
  self->VH_max = Hbeyond;
  self->VL_min = Lmin;
  self->VL_max = Lbeyond;
  self->V_min = min( self->VL_min, self->VH_min );
  self->V_max = max( self->VL_max, self->VH_max );
  
  self->_data_I = (short int *)
    local_malloc(sizeof(short int )*X);
  
  self->xdim = self->Length = X;
  PLUSMINUS1 = self->EvenFilter?(-1):1; 
  
  i= max(max(self->VL_max,abs(self->VL_min)),
    max(self->VH_max,abs(self->VH_min)));
  
 
  self->buffer_I =
    ((short int *)
    local_malloc((self->Length-self->V_min + self->V_max)*sizeof(short int )))
    + self->V_max;

  Lfilt =
    ((int *)
    local_malloc((self->V_max-self->V_min+1)*sizeof( int )))
    - self->V_min;
  Hfilt =
    ((int *)
    local_malloc((self->V_max-self->V_min+1)*sizeof( int )))
    - self->V_min;
  
  for(i = self->V_min; i <self->V_max ; i++)
    Lfilt[i]=Hfilt[i]=0;
  
  l_taps -= Lmin;
  h_taps -= Hmin; /* Get centres. */
  
  for(i=0;i<self->V_max;i+=2)
  {
    if(i-self->EvenFilter<self->VH_max)
      Hfilt[-i]=roundshift(h_taps[i-self->EvenFilter],self->shiftFactor);
    else
      Hfilt[-i]=(short int )(0.0);
    
    if(i<self->VL_max)
      Lfilt[-i-self->EvenFilter]=roundshift(l_taps[i],self->shiftFactor);
    else
      Lfilt[-i-self->EvenFilter]=(short int )(0.0);
  }
  
  for(i=-2;i>=self->V_min;i-=2)
  {
    if(i>=self->VL_min)
      Lfilt[-i-self->EvenFilter]=roundshift(l_taps[i],self->shiftFactor);
    else
      Lfilt[-i-self->EvenFilter]=(short int )(0.0);
    if(i-self->EvenFilter>=self->VH_min)
      Hfilt[-i]=roundshift(h_taps[i-self->EvenFilter],self->shiftFactor);
    else
      Hfilt[-i]=(short int )(0.0);
  }       
  
  for(i=1;i<self->V_max;i+=2)
  {
    if(i+self->EvenFilter<self->VH_max)
      Lfilt[-i-self->EvenFilter]=roundshift(h_taps[i+self->EvenFilter],self->shiftFactor);
    else
      Lfilt[-i-self->EvenFilter]=(short int )(0.0);
  }
  
  for(i=1;i<=-self->V_min;i+=2)
  {                       
    if(i-2*self->EvenFilter<self->VL_max)
      Hfilt[-i]=roundshift(l_taps[i-2*self->EvenFilter],self->shiftFactor);
    else
      Hfilt[-i]=(short int )(0.0);
  }
  
  for(i=-1;i>=self->V_min;i-=2)
  {
    if(i+self->EvenFilter>=self->VH_min)
      Lfilt[-i-self->EvenFilter]=roundshift(h_taps[i+self->EvenFilter],self->shiftFactor);
    else
      Lfilt[-i-self->EvenFilter]=(short int )(0.0);
    
    if(i-2*self->EvenFilter>=self->VL_min)
      Hfilt[-i]=roundshift(l_taps[i-2*self->EvenFilter],self->shiftFactor);
    else
      Hfilt[-i]=(short int )(0.0);    
    
    /*** Problem detected here.  Accesses one beyond nominal array bounds. */
    
  }
  
  self->VL_min = self->V_min;
  self->VL_max = self->V_max;
  self->VH_min = self->V_min;
  self->VH_max = self->V_max;
  
  if(self->EvenFilter)
  {
    self->VL_Low_I  = self->VL_High_I = Hfilt;
    self->VH_Low_I  = self->VH_High_I = Lfilt;
  }
  else
  {
    self->VL_Low_I  = self->VL_High_I = Lfilt;
    self->VH_Low_I  = self->VH_High_I = Hfilt;
  }
  
  self->VL_Low_I  += self->VL_min; 
  self->VL_High_I += self->VL_max;
  self->VH_Low_I  += self->VH_min; 
  self->VH_High_I += self->VH_max;

  self->BufFast =
    (( int *)
    local_malloc((self->Length)*sizeof(int ))); 


}

/************************************************************************/
/*
*    c_levs -> number of levels in the inverse WT
*
*/
/************************************************************************/
static void
  interpolator__interpolate_fixed(interpolator_ref self,short int  *Output)
{
  int i,j, g2H,g2L,z,l,l1,lengthH,lengthL,g;    
  short int  *SindxLI,*tmp;
  int shift_factorL, shift_factorH,NotBothOdd,_Strange;
  int OddSignal;
  int *downL=self->VL_Low_I;  
  int *downH=self->VH_Low_I;
  int PLUSMINUS1=self->EvenFilter?(-1):1;
  int evenF=self->EvenFilter;
 
  l=self->shiftFactor;
  l1= 1<<(l-1);
  
  z=self->Length;
  OddSignal = z & 1;
  _Strange = OddSignal && evenF;
  lengthL = ((z+1) >> 1)  - _Strange;
  lengthH = z>>1;
  NotBothOdd =  (!OddSignal) || evenF ;
  shift_factorL =
	  - 2 * ( evenF ||OddSignal)
	  + 2 * (int)(!NotBothOdd) ;
  shift_factorH = - 1;
  g2L = 2 * (lengthL - !NotBothOdd );
  g2H = 2 * ( lengthH + !NotBothOdd -  !evenF ) + 1 ;

      
      /************************************************/
        
        SindxLI = self->_data_I +  lengthL + _Strange;     
      
        /***********************************************
        ** This is the main part of the signal high pass
      ***********************************************/
      
      for ( j = 0, tmp = self->buffer_I - 1 ;
            j < (int)(lengthH); j++ )
        *(tmp+=2)=*(SindxLI++);
      
      /************************************************/
      
          SindxLI = self->_data_I;
       
      
      /***********************************************
      ** This is the main part of the signal low pass
      ***********************************************/
      
      for ( j = 0, tmp = self->buffer_I - 2;
            j < (int)(lengthL); j++ ) 
        *(tmp+=2)=*(SindxLI++);
      
      if (_Strange)    
        *( Output  + z - 1) = *( SindxLI  ) ;
      
      
        /***********************************************
        ** Extension to the left of the signal low pass
      ***********************************************/
      
      for ( j = -2 , i = shift_factorL ;
            j > - self->VL_max - 1; j-=2)
        self->buffer_I[j] =  self->buffer_I[i+=2];
      
        /***********************************************
        ** Extension to the right of the signal low pass
      ***********************************************/
      
      for ( j = (int)(z)-(int)(_Strange)+!NotBothOdd,
            i = g2L;
            j < (int)(z) - (int)(_Strange) - self->VL_min ;
            j+=2 ) 
        self->buffer_I[j] =  self->buffer_I[i-=2];
      
        /***********************************************
        ** Extension to the left of the signal high pass
      ***********************************************/
      
      for( j = -1 , i = shift_factorH;
           j > -self->VH_max; j-=2 )
        self->buffer_I[j]= PLUSMINUS1 * self->buffer_I[i+=2];
      
        /***********************************************
        ** Extension to the right of the signal high pass
      ***********************************************/
      
      for( j = (int)(z) + NotBothOdd - (int)(_Strange),
           i = g2H; j < (int)(z) -  self->VH_min ; j+=2 ) 
        self->buffer_I[j]= PLUSMINUS1 * self->buffer_I[i-=2];
      
      SindxLI = self->buffer_I   - self->V_max   + 1 ;                       
      
      /******************************************
      *      filtering done here
      ******************************************/

	 
     j=((int)(z) - (int)(_Strange))>>1;
     g=self->VL_max-self->VL_min;

if(!evenF)
{
  int flag;
  short int *Sindex1,*SindxL,*tmpf,*tmpf1,*SindxH;
  register int ftmp,*tmp_ptr;
  register int k;	 

  if(OddSignal)j++;
  flag=1;
  SindxL= SindxLI-2;
  Sindex1=SindxL+g-1;
  i=g>>1;
  while(i--){
	  ftmp=*(downL++);
	  tmpf=SindxL++;
	  tmpf1=Sindex1--;
	  tmp_ptr=self->BufFast-2;
	  k=j;
	  if(flag) while(k--) *(tmp_ptr+=2) = 
		  ftmp* ((int)*(tmpf +=2 )+(int)*(tmpf1 +=2)) ;
	  else     while(k--) *(tmp_ptr+=2) += 
		  ftmp* ((int)*(tmpf +=2 )+(int)*(tmpf1 +=2));
	  flag=0; }
  
  if(!evenF) {  /*Oddlength Filter */
	  ftmp=*(downL++);
	  tmpf=SindxL++;
	  tmp_ptr=self->BufFast-2;
	  k=j;
	  if(flag)   while(k--)*(tmp_ptr+=2) = 
		  ftmp* *((tmpf +=2) );
	  else    while(k--) *(tmp_ptr+=2) += 
		  ftmp* *(tmpf +=2);}
  
     
      /*  High Pass */  

	  j=((int)(z) - (int)(_Strange))>>1;
	  flag=1;
	  SindxH= SindxLI-1;
	  Sindex1=SindxH+g-1;
	  i=g>>1;
	  while(i--){
		  ftmp=*(downH++);
          tmpf=SindxH++;
		  tmpf1=Sindex1--;
		  tmp_ptr=self->BufFast-1;
		  k=j;
		  if(evenF) { /*Even Length Filter*/
			  if(flag) while(k--) *(tmp_ptr+=2) = 
				  ftmp* ((int)*(tmpf +=2 )-(int)*(tmpf1 +=2)) ;
			  else   while(k--) *(tmp_ptr+=2) += 
				  ftmp* ((int)*(tmpf +=2 )-(int)*(tmpf1 +=2)); }
		  else  {  /*Odd length Filter*/
			  if(flag) while(k--)  *(tmp_ptr+=2) = 
				  ftmp* ((int)*(tmpf +=2 )+(int)*(tmpf1 +=2)) ;
			  else  while(k--) *(tmp_ptr+=2) += 
				  ftmp* ((int)*(tmpf +=2 )+(int)*(tmpf1 +=2)); }
		  flag=0;
	  }
	  
	  if(!evenF)  {/*Odd Length filter*/
            ftmp=*(downH++);
            tmpf=SindxH++;
            tmp_ptr=self->BufFast-1;
            k=j;
	        if(flag) while(k--)*(tmp_ptr+=2) = 
				         ftmp* *(tmpf += 2 );
	        else  while(k--)    *(tmp_ptr+=2) += 
				         ftmp* *(tmpf += 2 );}

	   tmp_ptr=self->BufFast;
	   while(z--)
		   *(Output++)=(*(tmp_ptr++)+l1)>>l;
}
else
{  
  while(j--)
      { *(Output++) = (inner_prod_fixed(downL,g,SindxLI++,0)+l1)>>l;
        *(Output++) = (inner_prod_fixed(downH,g,SindxLI++-evenF,0)+l1)>>l;}
      if( ((int)(z) - (int)(_Strange)) &1)
        *(Output++) = (inner_prod_fixed(downL, g, SindxLI++,0)+l1)>>l;
}
}

/************************************************************************/
interpolator_ref
  create_interpolator(void)
{
  interpolator_ref result;
  
  result = (interpolator_ref)
    local_malloc(sizeof(interpolator));
  memset(result,0,sizeof(interpolator));
  result->initialize_fixed   = interpolator__initialize_fixed;
  result->initialize         = interpolator__initialize;
  result->interpolate_fixed  =  interpolator__interpolate_fixed;
  result->interpolate        =  interpolator__interpolate;
  result->set_size     =  interpolator__set_size;
  result->terminate    =  interpolator__terminate;
  return((interpolator_ref) result);
}