From 7e618974c2436ebd2cb18176da8dd75e02c65756 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ga=C3=ABl=20Hendryckx?= Date: Wed, 19 Jan 2000 02:25:00 +0000 Subject: [PATCH] =?UTF-8?q?*=20Le=20bug=20des=20pixels=20invers=EF=BF=BDs?= =?UTF-8?q?=20de=20la=20dct=20mmx=20=EF=BF=BD=20=EF=BF=BDt=EF=BF=BD=20corr?= =?UTF-8?q?ig=EF=BF=BD=20(et=20non=20plus=20sau-=20=20=20vagement=20kludg?= =?UTF-8?q?=EF=BF=BD).?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * La sparse idct fonctionne. * Plusieurs versions de la dct ont �t� inclues dans vdec_idct pour pou- voir choisir la plus performante quand tout marchera. --- src/video_decoder/vdec_idct.c | 239 +++++++++++++++++++++++++++++++- src/video_parser/vpar_blocks.c | 2 +- src/video_parser/vpar_synchro.c | 4 +- 3 files changed, 240 insertions(+), 5 deletions(-) diff --git a/src/video_decoder/vdec_idct.c b/src/video_decoder/vdec_idct.c index fafb09649a..4d00bc6073 100644 --- a/src/video_decoder/vdec_idct.c +++ b/src/video_decoder/vdec_idct.c @@ -74,11 +74,13 @@ void vdec_InitIDCT (vdec_thread_t * p_vdec) p_pre[i*64+i] = 1 << SPARSE_SCALE_FACTOR; vdec_IDCT( p_vdec, &p_pre[i*64], 0) ; } + return; } void vdec_SparseIDCT (vdec_thread_t * p_vdec, dctelem_t * p_block, int i_sparse_pos) { + /*debug*/ short int val; int * dp; int v; @@ -90,7 +92,20 @@ void vdec_SparseIDCT (vdec_thread_t * p_vdec, dctelem_t * p_block, if ( i_sparse_pos == 0 ) { dp=(int *)p_block; - val= *p_block >> 6; +// v=*p_block; +/* cuisine a verifier */ +/* if (v < 0) + { + val=-v; + val+=4; + val/=8; + val=-val; + } + else + {*/ +/* val= (v + 4) /8; */ + val=RIGHT_SHIFT((*p_block + 4), 3); +// } /* Compute int to assign. This speeds things up a bit */ v = ((val & 0xffff) | (val << 16)); dp[0] = v; dp[1] = v; dp[2] = v; dp[3] = v; @@ -138,7 +153,227 @@ void vdec_SparseIDCT (vdec_thread_t * p_vdec, dctelem_t * p_block, void vdec_IDCT( vdec_thread_t * p_vdec, dctelem_t * p_block, int i_idontcare ) { //IDCT_mmx(p_block); -#if 1 +#if 0 + /* dct classique: pour tester la meilleure entre la classique et la */ + /* no classique */ + s32 tmp0, tmp1, tmp2, tmp3; + s32 tmp10, tmp11, tmp12, tmp13; + s32 z1, z2, z3, z4, z5; + dctelem_t * dataptr; + int rowctr; + SHIFT_TEMPS + + /* Pass 1: process rows. */ + /* Note results are scaled up by sqrt(8) compared to a true IDCT; */ + /* furthermore, we scale the results by 2**PASS1_BITS. */ + + dataptr = p_block; + for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) + { + /* Due to quantization, we will usually find that many of the input + * coefficients are zero, especially the AC terms. We can exploit this + * by short-circuiting the IDCT calculation for any row in which all + * the AC terms are zero. In that case each output is equal to the + * DC coefficient (with scale factor as needed). + * With typical images and quantization tables, half or more of the + * row DCT calculations can be simplified this way. + */ + + if ((dataptr[1] | dataptr[2] | dataptr[3] | dataptr[4] | + dataptr[5] | dataptr[6] | dataptr[7]) == 0) + { + /* AC terms all zero */ + dctelem_t dcval = (dctelem_t) (dataptr[0] << PASS1_BITS); + + dataptr[0] = dcval; + dataptr[1] = dcval; + dataptr[2] = dcval; + dataptr[3] = dcval; + dataptr[4] = dcval; + dataptr[5] = dcval; + dataptr[6] = dcval; + dataptr[7] = dcval; + + dataptr += DCTSIZE; /* advance pointer to next row */ + continue; + } + + /* Even part: reverse the even part of the forward DCT. */ + /* The rotator is sqrt(2)*c(-6). */ + + z2 = (s32) dataptr[2]; + z3 = (s32) dataptr[6]; + + z1 = MULTIPLY(z2 + z3, FIX(0.541196100)); + tmp2 = z1 + MULTIPLY(z3, - FIX(1.847759065)); + tmp3 = z1 + MULTIPLY(z2, FIX(0.765366865)); + + tmp0 = ((s32) dataptr[0] + (s32) dataptr[4]) << CONST_BITS; + tmp1 = ((s32) dataptr[0] - (s32) dataptr[4]) << CONST_BITS; + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + /* Odd part per figure 8; the matrix is unitary and hence its + * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. + */ + + tmp0 = (s32) dataptr[7]; + tmp1 = (s32) dataptr[5]; + tmp2 = (s32) dataptr[3]; + tmp3 = (s32) dataptr[1]; + + z1 = tmp0 + tmp3; + z2 = tmp1 + tmp2; + z3 = tmp0 + tmp2; + z4 = tmp1 + tmp3; + z5 = MULTIPLY(z3 + z4, FIX(1.175875602)); /* sqrt(2) * c3 */ + + tmp0 = MULTIPLY(tmp0, FIX(0.298631336)); /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp1 = MULTIPLY(tmp1, FIX(2.053119869)); /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp2 = MULTIPLY(tmp2, FIX(3.072711026)); /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp3 = MULTIPLY(tmp3, FIX(1.501321110)); /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 = MULTIPLY(z1, - FIX(0.899976223)); /* sqrt(2) * (c7-c3) */ + z2 = MULTIPLY(z2, - FIX(2.562915447)); /* sqrt(2) * (-c1-c3) */ + z3 = MULTIPLY(z3, - FIX(1.961570560)); /* sqrt(2) * (-c3-c5) */ + z4 = MULTIPLY(z4, - FIX(0.390180644)); /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + tmp0 += z1 + z3; + tmp1 += z2 + z4; + tmp2 += z2 + z3; + tmp3 += z1 + z4; + + /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */ + + dataptr[0] = (dctelem_t) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS); + dataptr[7] = (dctelem_t) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS); + dataptr[1] = (dctelem_t) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS); + dataptr[6] = (dctelem_t) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS); + dataptr[2] = (dctelem_t) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS); + dataptr[5] = (dctelem_t) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS); + dataptr[3] = (dctelem_t) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS); + dataptr[4] = (dctelem_t) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS); + + dataptr += DCTSIZE; /* advance pointer to next row */ + } + + /* Pass 2: process columns. */ + /* Note that we must descale the results by a factor of 8 == 2**3, */ + /* and also undo the PASS1_BITS scaling. */ + + dataptr = p_block; + for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) + { + /* Columns of zeroes can be exploited in the same way as we did with rows. + * However, the row calculation has created many nonzero AC terms, so the + * simplification applies less often (typically 5% to 10% of the time). + * On machines with very fast multiplication, it's possible that the + * test takes more time than it's worth. In that case this section + * may be commented out. + */ + +#ifndef NO_ZERO_COLUMN_TEST /*ajoute un test mais evite des calculs */ + if ((dataptr[DCTSIZE*1] | dataptr[DCTSIZE*2] | dataptr[DCTSIZE*3] | + dataptr[DCTSIZE*4] | dataptr[DCTSIZE*5] | dataptr[DCTSIZE*6] | + dataptr[DCTSIZE*7]) == 0) + { + /* AC terms all zero */ + dctelem_t dcval = (dctelem_t) DESCALE((s32) dataptr[0], PASS1_BITS+3); + + dataptr[DCTSIZE*0] = dcval; + dataptr[DCTSIZE*1] = dcval; + dataptr[DCTSIZE*2] = dcval; + dataptr[DCTSIZE*3] = dcval; + dataptr[DCTSIZE*4] = dcval; + dataptr[DCTSIZE*5] = dcval; + dataptr[DCTSIZE*6] = dcval; + dataptr[DCTSIZE*7] = dcval; + + dataptr++; /* advance pointer to next column */ + continue; + } +#endif + + /* Even part: reverse the even part of the forward DCT. */ + /* The rotator is sqrt(2)*c(-6). */ + + z2 = (s32) dataptr[DCTSIZE*2]; + z3 = (s32) dataptr[DCTSIZE*6]; + + z1 = MULTIPLY(z2 + z3, FIX(0.541196100)); + tmp2 = z1 + MULTIPLY(z3, - FIX(1.847759065)); + tmp3 = z1 + MULTIPLY(z2, FIX(0.765366865)); + + tmp0 = ((s32) dataptr[DCTSIZE*0] + (s32) dataptr[DCTSIZE*4]) << CONST_BITS; + tmp1 = ((s32) dataptr[DCTSIZE*0] - (s32) dataptr[DCTSIZE*4]) << CONST_BITS; + + tmp10 = tmp0 + tmp3; + tmp13 = tmp0 - tmp3; + tmp11 = tmp1 + tmp2; + tmp12 = tmp1 - tmp2; + + /* Odd part per figure 8; the matrix is unitary and hence its + * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively. + */ + + tmp0 = (s32) dataptr[DCTSIZE*7]; + tmp1 = (s32) dataptr[DCTSIZE*5]; + tmp2 = (s32) dataptr[DCTSIZE*3]; + tmp3 = (s32) dataptr[DCTSIZE*1]; + + z1 = tmp0 + tmp3; + z2 = tmp1 + tmp2; + z3 = tmp0 + tmp2; + z4 = tmp1 + tmp3; + z5 = MULTIPLY(z3 + z4, FIX(1.175875602)); /* sqrt(2) * c3 */ + + tmp0 = MULTIPLY(tmp0, FIX(0.298631336)); /* sqrt(2) * (-c1+c3+c5-c7) */ + tmp1 = MULTIPLY(tmp1, FIX(2.053119869)); /* sqrt(2) * ( c1+c3-c5+c7) */ + tmp2 = MULTIPLY(tmp2, FIX(3.072711026)); /* sqrt(2) * ( c1+c3+c5-c7) */ + tmp3 = MULTIPLY(tmp3, FIX(1.501321110)); /* sqrt(2) * ( c1+c3-c5-c7) */ + z1 = MULTIPLY(z1, - FIX(0.899976223)); /* sqrt(2) * (c7-c3) */ + z2 = MULTIPLY(z2, - FIX(2.562915447)); /* sqrt(2) * (-c1-c3) */ + z3 = MULTIPLY(z3, - FIX(1.961570560)); /* sqrt(2) * (-c3-c5) */ + z4 = MULTIPLY(z4, - FIX(0.390180644)); /* sqrt(2) * (c5-c3) */ + + z3 += z5; + z4 += z5; + + tmp0 += z1 + z3; + tmp1 += z2 + z4; + tmp2 += z2 + z3; + tmp3 += z1 + z4; + + /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */ + + dataptr[DCTSIZE*0] = (dctelem_t) DESCALE(tmp10 + tmp3, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*7] = (dctelem_t) DESCALE(tmp10 - tmp3, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*1] = (dctelem_t) DESCALE(tmp11 + tmp2, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*6] = (dctelem_t) DESCALE(tmp11 - tmp2, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*2] = (dctelem_t) DESCALE(tmp12 + tmp1, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*5] = (dctelem_t) DESCALE(tmp12 - tmp1, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*3] = (dctelem_t) DESCALE(tmp13 + tmp0, + CONST_BITS+PASS1_BITS+3); + dataptr[DCTSIZE*4] = (dctelem_t) DESCALE(tmp13 - tmp0, + CONST_BITS+PASS1_BITS+3); + + dataptr++; /* advance pointer to next column */ + } +#endif + +#if 1 /*dct avec no classique*/ + s32 tmp0, tmp1, tmp2, tmp3; s32 tmp10, tmp11, tmp12, tmp13; s32 z1, z2, z3, z4, z5; diff --git a/src/video_parser/vpar_blocks.c b/src/video_parser/vpar_blocks.c index b5f5e71486..def368bc37 100644 --- a/src/video_parser/vpar_blocks.c +++ b/src/video_parser/vpar_blocks.c @@ -1460,7 +1460,7 @@ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, : i_level; break; case DCT_EOB: - if( i_nc <= 0 ) + if( i_nc <= 1 ) { p_mb->pf_idct[i_b] = vdec_SparseIDCT; p_mb->pi_sparse_pos[i_b] = i_coef; diff --git a/src/video_parser/vpar_synchro.c b/src/video_parser/vpar_synchro.c index 7ad27e7cc6..e14e4707f8 100644 --- a/src/video_parser/vpar_synchro.c +++ b/src/video_parser/vpar_synchro.c @@ -149,8 +149,8 @@ boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type, int i_structure ) { // return( 1 ); - return( i_coding_type == I_CODING_TYPE || i_coding_type == P_CODING_TYPE ); - //return( i_coding_type == I_CODING_TYPE ); +// return( i_coding_type == I_CODING_TYPE || i_coding_type == P_CODING_TYPE ); + return( i_coding_type == I_CODING_TYPE ); } /*****************************************************************************