idct_8x8.c

TI DSP标准测试程序集benchmark

            R1 = F2;                R0 = F6;                               
                                                                           
            Q1 = (F1*C7 - F7*C1 + 0x4000) >> 15;                           
            Q0 = (F5*C3 - F3*C5 + 0x4000) >> 15;                           
           S0 = (F5*C5 + F3*C3 + 0x4000) >> 15;                           
            S1 = (F1*C1 + F7*C7 + 0x4000) >> 15;                           
                                                                           
            /* ----------------------------------------------------- */    
            /*  Stage 2 of signal flow graph.                        */    
            /* ----------------------------------------------------- */    
            p0 = (P0*C4 + P1*C4 + 0x4000) >> 15;                           
            p1 = (P0*C4 - P1*C4 + 0x4000) >> 15;                           
            r1 = (R1*C6 - R0*C2 + 0x4000) >> 15;                           
            r0 = (R1*C2 + R0*C6 + 0x4000) >> 15;                           
                                                                           
            s1 = (S1 + S0);         q1 = (Q1 + Q0);                        
            s0 = (S1 - S0);         q0 = (Q1 - Q0);                        
                                                                           
            /* ----------------------------------------------------- */    
            /*  Stage 3 of signal flow graph.                        */    
            /* ----------------------------------------------------- */    
            g0 = (p0 + r0);         g1 = (p1 + r1);                        
            h0 = (p0 - r0);         h1 = (p1 - r1);                        
                                                                           
            h2 = s1;                g2 = q1;                               
            g3 = (s0*C0 - q0*C0 + 0x4000) >> 15;                           
            h3 = (s0*C0 + q0*C0 + 0x4000) >> 15;                           
                                                                           
            /* ----------------------------------------------------- */    
            /*  Stage 4 of signal flow graph.                        */    
            /* ----------------------------------------------------- */    
            f0 = (g0 + h2);         f7 = (g0 - h2);                        
            f1 = (g1 + h3);         f6 = (g1 - h3);                        
            f2 = (h1 + g3);         f5 = (h1 - g3);                        
            f3 = (h0 + g2);         f4 = (h0 - g2);                        
                                                                           
            /* ----------------------------------------------------- */    
            /*  Stage 4.1:  Q-point adjust and rounding              */    
            /* ----------------------------------------------------- */    
        #ifdef NO_IEEE_1180_OME_CONTROL                                    
            f0r = f0 + f0 + 0x1f;                                          
            f1r = f1 + f1 + 0x1f;                                          
            f2r = f2 + f2 + 0x1f;                                          
            f3r = f3 + f3 + 0x1f;                                          
            f4r = f4 + f4 + 0x1f;                                          
            f5r = f5 + f5 + 0x1f;                                          
            f6r = f6 + f6 + 0x1f;                                          
            f7r = f7 + f7 + 0x1f;                                          
        #else                                                              
            {                                                              
            int f10, f23, f54, f67;             /* Q adjust and rounding */ 
            f10 = (f1<<16) | (f0&0xffff);                                  
            f23 = (f2<<16) | (f3&0xffff);                                  
            f54 = (f5<<16) | (f4&0xffff);                                  
            f67 = (f6<<16) | (f7&0xffff);                                  
            f10 += f10 + 0x001f001f;                                       
            f23 += f23 + 0x001f001f;                                       
            f54 += f54 + 0x001f001f;                                       
            f67 += f67 + 0x001f001f;                                       
            f0r = f10 & 0xffff;     f1r = f10 >> 16;                       
            f2r = f23 >> 16;        f3r = f23 & 0xffff;                    
            f4r = f54 & 0xffff;     f5r = f54 >> 16;                       
            f6r = f67 >> 16;        f7r = f67 & 0xffff;                    
            }                                                              
        #endif                                                             
                                                                           
            /* ----------------------------------------------------- */    
            /*  Stage 4.2:  Saturate results to 9Q6.                 */    
            /* ----------------------------------------------------- */    
            f0s = f0r > 0x3FFF ? 0x3FFF :                                  
                  f0r < -0x4000 ? -0x4000 : f0r;                           
            f1s = f1r > 0x3FFF ? 0x3FFF :                                  
                  f1r < -0x4000 ? -0x4000 : f1r;                           
            f2s = f2r > 0x3FFF ? 0x3FFF :                                  
                  f2r < -0x4000 ? -0x4000 : f2r;                           
            f3s = f3r > 0x3FFF ? 0x3FFF :                                  
                  f3r < -0x4000 ? -0x4000 : f3r;                           
            f4s = f4r > 0x3FFF ? 0x3FFF :                                  
                  f4r < -0x4000 ? -0x4000 : f4r;                           
            f5s = f5r > 0x3FFF ? 0x3FFF :                                  
                  f5r < -0x4000 ? -0x4000 : f5r;                           
            f6s = f6r > 0x3FFF ? 0x3FFF :                                  
                  f6r < -0x4000 ? -0x4000 : f6r;                           
            f7s = f7r > 0x3FFF ? 0x3FFF :                                  
                  f7r < -0x4000 ? -0x4000 : f7r;                           
                                                                           
            /* ----------------------------------------------------- */    
            /*  Stage 4.3:  Truncate results to 9Q0.                 */    
            /* ----------------------------------------------------- */    
            f0t = f0s >> 6;         f7t = f7s >> 6;                        
            f1t = f1s >> 6;         f6t = f6s >> 6;                        
            f2t = f2s >> 6;         f5t = f5s >> 6;                        
           f3t = f3s >> 6;         f4t = f4s >> 6;                                                                                                   *
            /* ----------------------------------------------------- */    
            /*  Stage 5:  Store sample-domain results.               */    
            /* ----------------------------------------------------- */    
            idct[i][0][j] = f0t;                                           
            idct[i][1][j] = f1t;                                           
            idct[i][2][j] = f2t;                                           
            idct[i][3][j] = f3t;                                           
            idct[i][4][j] = f4t;                                           
            idct[i][5][j] = f5t;                                           
            idct[i][6][j] = f6t;                                           
            idct[i][7][j] = f7t;                                           
          }                                                                
        }                                                                  
                                                                           
       return;                                                            
     }           
	 
	 int main(){
		idct_data[N][8][8];
		int i,j,k;
		for (i=0;i<N;i++)
			for(j=0;j<8;j++)
				for(k=0;k<8;k++)
					idct_data[i][j][k]=i*k-j;

		idct_8x8(idct_data,N);
	 return 0;
	 }