/**
* returns the spherical Bessel function of the second kind
* needed for continuum states
\param l = order of the function (orbital angular momentum)
\param rho = independent variable (rho = k * r)
*/
double sphericalB::y(int l, double rho)
{
switch (l)
{
case 0:
return y0(rho);
case 1:
return y1(rho);
case 2:
return y2(rho);
case 3:
return y3(rho);
case 4:
return y4(rho);
case 5:
return y5(rho);
case 6:
return y6(rho);
case 7:
return y7(rho);
default:
cout << "no l>6 programed in sphericalB" << endl;
return 0.;
}
}
void
fdct_mm32( short *blk )
{
static __int64 xt70[2]; // xt7xt6xt5xt4, xt3xt2xt1xt0
static int a0, a1, a2, a3, b0, b1, b2, b3;
static short *sptr, *optr, *tf; // tf = table_ptr
static short *xt = (short *) &xt70[0];
static int j;
const static short _tg_1_16 = 13036; //tg * (2<<16) + 0.5
const static short _tg_2_16 = 27146; //tg * (2<<16) + 0.5
const static short _tg_3_16 =-21746; //tg * (2<<16) + 0.5
const static short _cos_4_16 =-19195; //cos * (2<<16) + 0.5
const static short _ocos_4_16 = 23170; //cos * (2<<15) + 0.5
const static short _one_corr = 1; //rounding compensation
static short t0, t1, t2, t3, t4, t5, t6, t7;
static short tp03, tm03, tp12, tm12, tp65, tm65;
static short tp465, tm465, tp765, tm765;
__asm {
////////////////////////////////////////////////////////////////////////
//
// The high-level pseudocode for the fdct_mm32() routine :
//
// fdct_mm32()
// {
// forward_dct_col03(); // dct_column transform on cols 0-3
// forward_dct_col47(); // dct_column transform on cols 4-7
// for ( j = 0; j < 8; j=j+1 )
// forward_dct_row1(j); // dct_row transform on row #j
// }
mov INP, dword ptr [blk]; ;// input data is row 0 of blk[]
;// transform the left half of the matrix (4 columns)
lea TABLEF, dword ptr [tg_all_16];
mov OUT, INP;
// lea round_frw_col, dword ptr [r_frw_col]
// for ( i = 0; i < 2; i = i + 1)
// the for-loop is executed twice. We are better off unrolling the
// loop to avoid branch misprediction.
mmx32_fdct_col03: // begin processing columns 0-3
movq mm0, [x1] ; 0 ; x1
;//
movq mm1, [x6] ; 1 ; x6
movq mm2, mm0 ; 2 ; x1
movq mm3, [x2] ; 3 ; x2
paddsw mm0, mm1 ; t1 = x[1] + x[6]
movq mm4, [x5] ; 4 ; x5
psllw mm0, SHIFT_FRW_COL ; t1
movq mm5, [x0] ; 5 ; x0
paddsw mm4, mm3 ; t2 = x[2] + x[5]
paddsw mm5, [x7] ; t0 = x[0] + x[7]
psllw mm4, SHIFT_FRW_COL ; t2
movq mm6, mm0 ; 6 ; t1
psubsw mm2, mm1 ; 1 ; t6 = x[1] - x[6]
movq mm1, qword ptr [tg_2_16] ; 1 ; tg_2_16
psubsw mm0, mm4 ; tm12 = t1 - t2
movq mm7, [x3] ; 7 ; x3
pmulhw mm1, mm0 ; tm12*tg_2_16
paddsw mm7, [x4] ; t3 = x[3] + x[4]
psllw mm5, SHIFT_FRW_COL ; t0
paddsw mm6, mm4 ; 4 ; tp12 = t1 + t2
psllw mm7, SHIFT_FRW_COL ; t3
movq mm4, mm5 ; 4 ; t0
psubsw mm5, mm7 ; tm03 = t0 - t3
paddsw mm1, mm5 ; y2 = tm03 + tm12*tg_2_16
paddsw mm4, mm7 ; 7 ; tp03 = t0 + t3
por mm1, qword ptr one_corr ; correction y2 +0.5
psllw mm2, SHIFT_FRW_COL+1 ; t6
pmulhw mm5, qword ptr [tg_2_16] ; tm03*tg_2_16
movq mm7, mm4 ; 7 ; tp03
psubsw mm3, [x5] ; t5 = x[2] - x[5]
psubsw mm4, mm6 ; y4 = tp03 - tp12
movq [y2], mm1 ; 1 ; save y2
paddsw mm7, mm6 ; 6 ; y0 = tp03 + tp12
movq mm1, [x3] ; 1 ; x3
psllw mm3, SHIFT_FRW_COL+1 ; t5
psubsw mm1, [x4] ; t4 = x[3] - x[4]
movq mm6, mm2 ; 6 ; t6
movq [y4], mm4 ; 4 ; save y4
paddsw mm2, mm3 ; t6 + t5
pmulhw mm2, qword ptr [ocos_4_16] ; tp65 = (t6 + t5)*cos_4_16
psubsw mm6, mm3 ; 3 ; t6 - t5
pmulhw mm6, qword ptr [ocos_4_16] ; tm65 = (t6 - t5)*cos_4_16
psubsw mm5, mm0 ; 0 ; y6 = tm03*tg_2_16 - tm12
por mm5, qword ptr one_corr ; correction y6 +0.5
psllw mm1, SHIFT_FRW_COL ; t4
por mm2, qword ptr one_corr ; correction tp65 +0.5
movq mm4, mm1 ; 4 ; t4
movq mm3, [x0] ; 3 ; x0
paddsw mm1, mm6 ; tp465 = t4 + tm65
psubsw mm3, [x7] ; t7 = x[0] - x[7]
psubsw mm4, mm6 ; 6 ; tm465 = t4 - tm65
movq mm0, qword ptr [tg_1_16] ; 0 ; tg_1_16
psllw mm3, SHIFT_FRW_COL ; t7
movq mm6, qword ptr [tg_3_16] ; 6 ; tg_3_16
pmulhw mm0, mm1 ; tp465*tg_1_16
movq [y0], mm7 ; 7 ; save y0
pmulhw mm6, mm4 ; tm465*tg_3_16
movq [y6], mm5 ; 5 ; save y6
movq mm7, mm3 ; 7 ; t7
movq mm5, qword ptr [tg_3_16] ; 5 ; tg_3_16
psubsw mm7, mm2 ; tm765 = t7 - tp65
paddsw mm3, mm2 ; 2 ; tp765 = t7 + tp65
pmulhw mm5, mm7 ; tm765*tg_3_16
paddsw mm0, mm3 ; y1 = tp765 + tp465*tg_1_16
paddsw mm6, mm4 ; tm465*tg_3_16
pmulhw mm3, qword ptr [tg_1_16] ; tp765*tg_1_16
;//
por mm0, qword ptr one_corr ; correction y1 +0.5
paddsw mm5, mm7 ; tm765*tg_3_16
psubsw mm7, mm6 ; 6 ; y3 = tm765 - tm465*tg_3_16
add INP, 0x08 ; // increment pointer
movq [y1], mm0 ; 0 ; save y1
paddsw mm5, mm4 ; 4 ; y5 = tm765*tg_3_16 + tm465
movq [y3], mm7 ; 7 ; save y3
psubsw mm3, mm1 ; 1 ; y7 = tp765*tg_1_16 - tp465
movq [y5], mm5 ; 5 ; save y5
mmx32_fdct_col47: // begin processing columns 4-7
movq mm0, [x1] ; 0 ; x1
;//
movq [y7], mm3 ; 3 ; save y7 (columns 0-4)
;//
movq mm1, [x6] ; 1 ; x6
movq mm2, mm0 ; 2 ; x1
movq mm3, [x2] ; 3 ; x2
paddsw mm0, mm1 ; t1 = x[1] + x[6]
movq mm4, [x5] ; 4 ; x5
psllw mm0, SHIFT_FRW_COL ; t1
movq mm5, [x0] ; 5 ; x0
paddsw mm4, mm3 ; t2 = x[2] + x[5]
paddsw mm5, [x7] ; t0 = x[0] + x[7]
psllw mm4, SHIFT_FRW_COL ; t2
movq mm6, mm0 ; 6 ; t1
psubsw mm2, mm1 ; 1 ; t6 = x[1] - x[6]
movq mm1, qword ptr [tg_2_16] ; 1 ; tg_2_16
psubsw mm0, mm4 ; tm12 = t1 - t2
movq mm7, [x3] ; 7 ; x3
pmulhw mm1, mm0 ; tm12*tg_2_16
paddsw mm7, [x4] ; t3 = x[3] + x[4]
psllw mm5, SHIFT_FRW_COL ; t0
paddsw mm6, mm4 ; 4 ; tp12 = t1 + t2
psllw mm7, SHIFT_FRW_COL ; t3
movq mm4, mm5 ; 4 ; t0
psubsw mm5, mm7 ; tm03 = t0 - t3
paddsw mm1, mm5 ; y2 = tm03 + tm12*tg_2_16
paddsw mm4, mm7 ; 7 ; tp03 = t0 + t3
por mm1, qword ptr one_corr ; correction y2 +0.5
psllw mm2, SHIFT_FRW_COL+1 ; t6
pmulhw mm5, qword ptr [tg_2_16] ; tm03*tg_2_16
movq mm7, mm4 ; 7 ; tp03
psubsw mm3, [x5] ; t5 = x[2] - x[5]
psubsw mm4, mm6 ; y4 = tp03 - tp12
movq [y2+8], mm1 ; 1 ; save y2
paddsw mm7, mm6 ; 6 ; y0 = tp03 + tp12
movq mm1, [x3] ; 1 ; x3
psllw mm3, SHIFT_FRW_COL+1 ; t5
psubsw mm1, [x4] ; t4 = x[3] - x[4]
movq mm6, mm2 ; 6 ; t6
movq [y4+8], mm4 ; 4 ; save y4
paddsw mm2, mm3 ; t6 + t5
pmulhw mm2, qword ptr [ocos_4_16] ; tp65 = (t6 + t5)*cos_4_16
psubsw mm6, mm3 ; 3 ; t6 - t5
pmulhw mm6, qword ptr [ocos_4_16] ; tm65 = (t6 - t5)*cos_4_16
psubsw mm5, mm0 ; 0 ; y6 = tm03*tg_2_16 - tm12
por mm5, qword ptr one_corr ; correction y6 +0.5
psllw mm1, SHIFT_FRW_COL ; t4
por mm2, qword ptr one_corr ; correction tp65 +0.5
movq mm4, mm1 ; 4 ; t4
movq mm3, [x0] ; 3 ; x0
paddsw mm1, mm6 ; tp465 = t4 + tm65
psubsw mm3, [x7] ; t7 = x[0] - x[7]
psubsw mm4, mm6 ; 6 ; tm465 = t4 - tm65
movq mm0, qword ptr [tg_1_16] ; 0 ; tg_1_16
psllw mm3, SHIFT_FRW_COL ; t7
movq mm6, qword ptr [tg_3_16] ; 6 ; tg_3_16
pmulhw mm0, mm1 ; tp465*tg_1_16
movq [y0+8], mm7 ; 7 ; save y0
pmulhw mm6, mm4 ; tm465*tg_3_16
movq [y6+8], mm5 ; 5 ; save y6
movq mm7, mm3 ; 7 ; t7
movq mm5, qword ptr [tg_3_16] ; 5 ; tg_3_16
psubsw mm7, mm2 ; tm765 = t7 - tp65
paddsw mm3, mm2 ; 2 ; tp765 = t7 + tp65
pmulhw mm5, mm7 ; tm765*tg_3_16
paddsw mm0, mm3 ; y1 = tp765 + tp465*tg_1_16
paddsw mm6, mm4 ; tm465*tg_3_16
pmulhw mm3, qword ptr [tg_1_16] ; tp765*tg_1_16
;//
por mm0, qword ptr one_corr ; correction y1 +0.5
paddsw mm5, mm7 ; tm765*tg_3_16
psubsw mm7, mm6 ; 6 ; y3 = tm765 - tm465*tg_3_16
;//
movq [y1+8], mm0 ; 0 ; save y1
paddsw mm5, mm4 ; 4 ; y5 = tm765*tg_3_16 + tm465
movq [y3+8], mm7 ; 7 ; save y3
psubsw mm3, mm1 ; 1 ; y7 = tp765*tg_1_16 - tp465
movq [y5+8], mm5 ; 5 ; save y5
movq [y7+8], mm3 ; 3 ; save y7
// emms;
// } // end of forward_dct_col07()
// done with dct_col transform
////////////////////////////////////////////////////////////////////////
//
// fdct_mmx32_rows() --
// the following subroutine performs the row-transform operation,
//
// The output is stored into blk[], destroying the original
// source data.
// v1.01 - output is range-clipped to {-2048, +2047}
mov INP, dword ptr [blk]; ;// row 0
mov edi, 0x08; //x = 8
lea TABLE, dword ptr [tab_frw_01234567]; // row 0
mov OUT, INP;
lea round_frw_row, dword ptr [r_frw_row];
// for ( x = 8; x > 0; --x ) // transform 1 row per iteration
// ---------- loop begin
lp_mmx_fdct_row1:
movd mm5, dword ptr [INP+12]; // mm5 = 7 6
punpcklwd mm5, dword ptr [INP+8] // mm5 = 5 7 4 6
movq mm2, mm5; // mm2 = 5 7 4 6
psrlq mm5, 32; // mm5 = _ _ 5 7
movq mm0, qword ptr [INP]; // mm0 = 3 2 1 0
punpcklwd mm5, mm2;// mm5 = 4 5 6 7
movq mm1, mm0; // mm1 = 3 2 1 0
paddsw mm0, mm5; // mm0 = [3+4, 2+5, 1+6, 0+7] (xt3, xt2, xt1, xt0)
psubsw mm1, mm5; // mm1 = [3-4, 2-5, 1-6, 0-7] (xt7, xt6, xt5, xt4)
movq mm2, mm0; // mm2 = [ xt3 xt2 xt1 xt0 ]
//movq [ xt3xt2xt1xt0 ], mm0; // debugging
//movq [ xt7xt6xt5xt4 ], mm1; // debugging
punpcklwd mm0, mm1;// mm0 = [ xt5 xt1 xt4 xt0 ]
punpckhwd mm2, mm1;// mm2 = [ xt7 xt3 xt6 xt2 ]
movq mm1, mm2; // mm1
;// shuffle bytes around
// movq mm0, qword ptr [INP] ; 0 ; x3 x2 x1 x0
// movq mm1, qword ptr [INP+8] ; 1 ; x7 x6 x5 x4
movq mm2, mm0 ; 2 ; x3 x2 x1 x0
movq mm3, qword ptr [TABLE] ; 3 ; w06 w04 w02 w00
punpcklwd mm0, mm1 ; x5 x1 x4 x0
movq mm5, mm0 ; 5 ; x5 x1 x4 x0
punpckldq mm0, mm0 ; x4 x0 x4 x0 [ xt2 xt0 xt2 xt0 ]
movq mm4, qword ptr [TABLE+8] ; 4 ; w07 w05 w03 w01
punpckhwd mm2, mm1 ; 1 ; x7 x3 x6 x2
pmaddwd mm3, mm0 ; x4*w06+x0*w04 x4*w02+x0*w00
movq mm6, mm2 ; 6 ; x7 x3 x6 x2
movq mm1, qword ptr [TABLE+32] ; 1 ; w22 w20 w18 w16
punpckldq mm2, mm2 ; x6 x2 x6 x2 [ xt3 xt1 xt3 xt1 ]
pmaddwd mm4, mm2 ; x6*w07+x2*w05 x6*w03+x2*w01
punpckhdq mm5, mm5 ; x5 x1 x5 x1 [ xt6 xt4 xt6 xt4 ]
pmaddwd mm0, qword ptr [TABLE+16] ; x4*w14+x0*w12 x4*w10+x0*w08
punpckhdq mm6, mm6 ; x7 x3 x7 x3 [ xt7 xt5 xt7 xt5 ]
movq mm7, qword ptr [TABLE+40] ; 7 ; w23 w21 w19 w17
pmaddwd mm1, mm5 ; x5*w22+x1*w20 x5*w18+x1*w16
//mm3 = a1, a0 (y2,y0)
//mm1 = b1, b0 (y3,y1)
//mm0 = a3,a2 (y6,y4)
//mm5 = b3,b2 (y7,y5)
paddd mm3, qword ptr [round_frw_row] ; +rounder (y2,y0)
pmaddwd mm7, mm6 ; x7*w23+x3*w21 x7*w19+x3*w17
pmaddwd mm2, qword ptr [TABLE+24] ; x6*w15+x2*w13 x6*w11+x2*w09
paddd mm3, mm4 ; 4 ; a1=sum(even1) a0=sum(even0) // now ( y2, y0)
pmaddwd mm5, qword ptr [TABLE+48] ; x5*w30+x1*w28 x5*w26+x1*w24
;//
pmaddwd mm6, qword ptr [TABLE+56] ; x7*w31+x3*w29 x7*w27+x3*w25
paddd mm1, mm7 ; 7 ; b1=sum(odd1) b0=sum(odd0) // now ( y3, y1)
paddd mm0, qword ptr [round_frw_row] ; +rounder (y6,y4)
psrad mm3, SHIFT_FRW_ROW_CLIP1 ;// (y2, y0)
paddd mm1, qword ptr [round_frw_row] ; +rounder (y3,y1)
paddd mm0, mm2 ; 2 ; a3=sum(even3) a2=sum(even2) // now (y6, y4)
paddd mm5, qword ptr [round_frw_row] ; +rounder (y7,y5)
psrad mm1, SHIFT_FRW_ROW_CLIP1 ;// y1=a1+b1 y0=a0+b0
paddd mm5, mm6 ; 6 ; b3=sum(odd3) b2=sum(odd2) // now ( y7, y5)
psrad mm0, SHIFT_FRW_ROW_CLIP1 ;//y3=a3+b3 y2=a2+b2
add OUT, 16; // increment row-output address by 1 row
psrad mm5, SHIFT_FRW_ROW_CLIP1;// y4=a3-b3 y5=a2-b2
add INP, 16; // increment row-address by 1 row
packssdw mm3, mm0 ;// 0 ; y6 y4 y2 y0, saturate {-32768,+32767}
packssdw mm1, mm5 ;// 3 ; y7 y5 y3 y1, saturate {-32768,+32767}
movq mm6, mm3; // mm0 = y6 y4 y2 y0
punpcklwd mm3, mm1; // y3 y2 y1 y0
sub edi, 0x01; // i = i - 1
punpckhwd mm6, mm1; // y7 y6 y5 y4
add TABLE,64; // increment to next table
psraw mm3, SHIFT_FRW_ROW_CLIP2; // descale [y3 y2 y1 y0] to {-2048,+2047}
psraw mm6, SHIFT_FRW_ROW_CLIP2; // descale [y7 y6 y5 y4] to {-2048,+2047}
movq qword ptr [OUT-16], mm3 ; 1 ; save y3 y2 y1 y0
movq qword ptr [OUT-8], mm6 ; 7 ; save y7 y6 y5 y4
cmp edi, 0x00;
jg lp_mmx_fdct_row1; // begin fdct processing on next row
emms;
}
/*
////////////////////////////////////////////////////////////////////////
//
// DCT_8_FRW_COL(), equivalent c_code
//
// This C-code can be substituted for the same __asm block
//
// I found several *DISCREPANCIES* between the AP-922 C-listing
// and actual corrected code (shown below).
//
////////////////////////////////////////////////////////////////////////
sptr = (short *) blk;
optr = (short *) blk; // output will overwrite source data!
for ( j = 0; j < 8; j=j+1 ) // dct_frw_col1 loop
{
// read source-data column #j into xt[0..7]
xt[7] = sptr[7*8];
xt[6] = sptr[6*8];
xt[5] = sptr[5*8];
xt[4] = sptr[4*8];
xt[3] = sptr[3*8];
xt[2] = sptr[2*8];
xt[1] = sptr[1*8];
xt[0] = sptr[0*8];
#define LEFT_SHIFT( x ) ((x) << (SHIFT_FRW_COL) ) // left shift
#define LEFT_SHIFT1( x ) ((x) << (SHIFT_FRW_COL+1) ) // left shift+1
t0 = LEFT_SHIFT ( xt[0] + xt[7] );
t1 = LEFT_SHIFT ( xt[1] + xt[6] );
t2 = LEFT_SHIFT ( xt[2] + xt[5] );
t3 = LEFT_SHIFT ( xt[3] + xt[4] );
t4 = LEFT_SHIFT ( xt[3] - xt[4] );
t5 = LEFT_SHIFT1( xt[2] - xt[5] ); // *** DISCREPANCY
t6 = LEFT_SHIFT1( xt[1] - xt[6] ); // *** DISCREPANCY
t7 = LEFT_SHIFT ( xt[0] - xt[7] );
tp03 = t0 + t3;
tm03 = t0 - t3;
tp12 = t1 + t2;
tm12 = t1 - t2;
// pmulhw/pmulhrw emulation macros
#define X86_PMULHW( X ) ((short) ( ((int)X)>>16 )) //Intel MMX
//#define X86_PMULHRW( X ) ((short) ( ( (((int)X)>>15)+1) >>1) ) //3DNow-MMX
optr[0*8] = tp03 + tp12;
optr[4*8] = tp03 - tp12;
optr[2*8] = tm03 + X86_PMULHW( tm12 * _tg_2_16 );
optr[2*8] = optr[2*8] | _one_corr; // one_correction
optr[6*8] = X86_PMULHW( tm03 * _tg_2_16 ) - tm12;
optr[6*8] = optr[6*8] | _one_corr; // one_correction
tp65 = X86_PMULHW( (t6 +t5 )*_ocos_4_16 ); // *** DISCREPANCY
tp65 = tp65 | _one_corr; // one_correction
tm65 = X86_PMULHW( (t6 -t5 )*_ocos_4_16 ); // *** DISCREPANCY
tp765 = t7 + tp65;
tm765 = t7 - tp65;
tp465 = t4 + tm65;
tm465 = t4 - tm65;
optr[1*8] = tp765 + X86_PMULHW( tp465 * _tg_1_16 );
optr[1*8] = optr[1*8] | _one_corr; // one_correction
optr[7*8] = X86_PMULHW( tp765 * _tg_1_16 ) - tp465;
// optr[5*8] = X86_PMULHW( tm765 * _tg_3_16 ) + tm465; // *** DISCREPANCY
// from pg8 of AP-922, ICONST = [ const*(2^16) + 0.5 ]
// const * x = PMULHW( ICONST,x ) + x
// The constant "tg_3_16" > 0.5, thus _tg_3_16 is encoded as tg_3_16-1.0
// optr[5*8] = X86_PMULHW( tm765 * ( tg_3_16 - 1.0 ) ) + tm465
// = [tm765*tg_3_16 - tm765] + tm465
//
// optr[5*8] + tm765 = [ tm765*tg_3_16 ] + tm465 + tm765
// = [ tm765*tg_3_16 ] + tm465 <-- what we want
optr[5*8] = X86_PMULHW( tm765 * _tg_3_16 ) + tm465 + tm765;
// optr[3*8] = tm765 - X86_PMULHW( tm465 * _tg_3_16 ); // *** DISCREPANCY
// The following operations must be performed in the shown order!
// same trick (as shown for optr[5*8]) applies to optr[3*8]
optr[3*8] = X86_PMULHW( tm465 * _tg_3_16 ) + tm465;
optr[3*8] = tm765 - optr[3*8];
++sptr; // increment source pointer +1 column
++optr; // increment output pointer +1 column
} // end for ( j = 0 ..., end of C_equivalent code for forward_dct_col_1
////////////////////////////////////////////////////////////////////////
//
// DCT8_FRW_ROW1(), equivalent c_code
//
// This C-code can be substituted for the same __asm block
// For a derivation of this code, please read fdctmm32.doc
////////////////////////////////////////////////////////////////////////
sptr = (short *) blk;
optr = (short *) blk; // output will overwrite source data!
tf = &tab_frw_01234567[ 0 ]; // fdct_row load table_forward_w
for ( j = 0; j < 8; j=j+1 ) // dct_frw_row1 loop
{
// forward_dct_row input arithmetic + shuffle
xt[3] = sptr[3] + sptr[4];
xt[2] = sptr[2] + sptr[5];
xt[1] = sptr[1] + sptr[6];
xt[0] = sptr[0] + sptr[7];
xt[7] = sptr[3] - sptr[4];
xt[6] = sptr[2] - sptr[5];
xt[5] = sptr[1] - sptr[6];
xt[4] = sptr[0] - sptr[7];
a3 = ( xt[0]*tf[10]+ xt[2]*tf[11]) + ( xt[1]*tf[14]+ xt[3]*tf[15]);
a2 = ( xt[0]*tf[8] + xt[2]*tf[9] ) + ( xt[1]*tf[12]+ xt[3]*tf[13]);
a1 = ( xt[0]*tf[2] + xt[2]*tf[3] ) + ( xt[1]*tf[6] + xt[3]*tf[7] );
a0 = ( xt[0]*tf[0] + xt[2]*tf[1] ) + ( xt[1]*tf[4] + xt[3]*tf[5] );
tf += 16; // increment table pointer
b3 = ( xt[4]*tf[10]+ xt[6]*tf[11]) + ( xt[5]*tf[14]+ xt[7]*tf[15]);
b2 = ( xt[4]*tf[8] + xt[6]*tf[9] ) + ( xt[5]*tf[12]+ xt[7]*tf[13]);
b1 = ( xt[4]*tf[2] + xt[6]*tf[3] ) + ( xt[5]*tf[6] + xt[7]*tf[7] );
b0 = ( xt[4]*tf[0] + xt[6]*tf[1] ) + ( xt[5]*tf[4] + xt[7]*tf[5] );
tf += 16; // increment table pointer
// apply rounding constants to scaled elements
// note, in the MMX implementation, the shift&round is done *last.*
// Here, the C-code applies the shifts 1st, then the clipping.
#define SHIFT_AND_ROUND_FRW_ROW( x ) ( ((x)+RND_FRW_ROW) >> SHIFT_FRW_ROW )
a3 = SHIFT_AND_ROUND_FRW_ROW( a3 );
a2 = SHIFT_AND_ROUND_FRW_ROW( a2 );
a1 = SHIFT_AND_ROUND_FRW_ROW( a1 );
a0 = SHIFT_AND_ROUND_FRW_ROW( a0 );
b3 = SHIFT_AND_ROUND_FRW_ROW( b3 );
b2 = SHIFT_AND_ROUND_FRW_ROW( b2 );
b1 = SHIFT_AND_ROUND_FRW_ROW( b1 );
b0 = SHIFT_AND_ROUND_FRW_ROW( b0 );
// v1.01, clip output results to range {-2048, +2047}
// In the MMX implementation, the "clipper" is integrated into
// the shift&round operation (thanks to packssdw)
a3 = (a3 > 2047) ? 2047 : a3; // ceiling @ +2047
a2 = (a2 > 2047) ? 2047 : a2; // ceiling @ +2047
a1 = (a1 > 2047) ? 2047 : a1; // ceiling @ +2047
a0 = (a0 > 2047) ? 2047 : a0; // ceiling @ +2047
b3 = (b3 > 2047) ? 2047 : b3; // ceiling @ +2047
b2 = (b2 > 2047) ? 2047 : b2; // ceiling @ +2047
b1 = (b1 > 2047) ? 2047 : b1; // ceiling @ +2047
b0 = (b0 > 2047) ? 2047 : b0; // ceiling @ +2047
a3 = (a3 <-2048) ? -2048 : a3; // floor @ -2048
a2 = (a2 <-2048) ? -2048 : a2; // floor @ -2048
a1 = (a1 <-2048) ? -2048 : a1; // floor @ -2048
a0 = (a0 <-2048) ? -2048 : a0; // floor @ -2048
b3 = (b3 <-2048) ? -2048 : b3; // floor @ -2048
b2 = (b2 <-2048) ? -2048 : b2; // floor @ -2048
b1 = (b1 <-2048) ? -2048 : b1; // floor @ -2048
b0 = (b0 <-2048) ? -2048 : b0; // floor @ -2048
// forward_dct_row, assign outputs
optr[ 3 ] = b1;
optr[ 2 ] = a1;
optr[ 1 ] = b0;
optr[ 0 ] = a0;
optr[ 7 ] = b3;
optr[ 6 ] = a3;
optr[ 5 ] = b2;
optr[ 4 ] = a2;
sptr += 8; // increment source pointer +1 row
optr += 8; // increment output pointer +1 row
} // end for ( j = 0 ..., end of C_equivalent code for forward_dct_row_1
*/
} // fdct_mm32( short *blk )
