Mercurial > libavcodec.hg
changeset 1355:1c05f4290517 libavcodec
added the official VP3 IDCT (C implementation) as well as a grayscale
decoding mode
| author | tmmm |
|---|---|
| date | Thu, 10 Jul 2003 05:16:25 +0000 |
| parents | 1f89adb69349 |
| children | 9e31b6bfb1a2 |
| files | vp3.c |
| diffstat | 1 files changed, 322 insertions(+), 41 deletions(-) [+] |
line wrap: on
line diff
--- a/vp3.c Thu Jul 10 00:15:27 2003 +0000 +++ b/vp3.c Thu Jul 10 05:16:25 2003 +0000 @@ -17,6 +17,8 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * VP3 Video Decoder by Mike Melanson (melanson@pcisys.net) + * For more information about the VP3 coding process, visit: + * http://www.pcisys.net/~melanson/codecs/ * */ @@ -288,6 +290,307 @@ } Vp3DecodeContext; /************************************************************************ + * VP3 I/DCT + ************************************************************************/ + +#define IdctAdjustBeforeShift 8 +#define xC1S7 64277 +#define xC2S6 60547 +#define xC3S5 54491 +#define xC4S4 46341 +#define xC5S3 36410 +#define xC6S2 25080 +#define xC7S1 12785 + +void vp3_idct_c(int16_t *input_data, int16_t *dequant_matrix, + int16_t *output_data) +{ + int32_t intermediate_data[64]; + int32_t *ip = intermediate_data; + int16_t *op = output_data; + + int32_t _A, _B, _C, _D, _Ad, _Bd, _Cd, _Dd, _E, _F, _G, _H; + int32_t _Ed, _Gd, _Add, _Bdd, _Fd, _Hd; + int32_t t1, t2; + + int i, j; + + debug_idct("raw coefficient block:\n"); + for (i = 0; i < 8; i++) { + for (j = 0; j < 8; j++) { + debug_idct(" %5d", input_data[i * 8 + j]); + } + debug_idct("\n"); + } + debug_idct("\n"); + + for (i = 0; i < 64; i++) { + j = dezigzag_index[i]; + intermediate_data[j] = dequant_matrix[i] * input_data[i]; + } + + debug_idct("dequantized block:\n"); + for (i = 0; i < 8; i++) { + for (j = 0; j < 8; j++) { + debug_idct(" %5d", intermediate_data[i * 8 + j]); + } + debug_idct("\n"); + } + debug_idct("\n"); + + /* Inverse DCT on the rows now */ + for (i = 0; i < 8; i++) { + /* Check for non-zero values */ + if ( ip[0] | ip[1] | ip[2] | ip[3] | ip[4] | ip[5] | ip[6] | ip[7] ) { + t1 = (int32_t)(xC1S7 * ip[1]); + t2 = (int32_t)(xC7S1 * ip[7]); + t1 >>= 16; + t2 >>= 16; + _A = t1 + t2; + + t1 = (int32_t)(xC7S1 * ip[1]); + t2 = (int32_t)(xC1S7 * ip[7]); + t1 >>= 16; + t2 >>= 16; + _B = t1 - t2; + + t1 = (int32_t)(xC3S5 * ip[3]); + t2 = (int32_t)(xC5S3 * ip[5]); + t1 >>= 16; + t2 >>= 16; + _C = t1 + t2; + + t1 = (int32_t)(xC3S5 * ip[5]); + t2 = (int32_t)(xC5S3 * ip[3]); + t1 >>= 16; + t2 >>= 16; + _D = t1 - t2; + + + t1 = (int32_t)(xC4S4 * (_A - _C)); + t1 >>= 16; + _Ad = t1; + + t1 = (int32_t)(xC4S4 * (_B - _D)); + t1 >>= 16; + _Bd = t1; + + + _Cd = _A + _C; + _Dd = _B + _D; + + t1 = (int32_t)(xC4S4 * (ip[0] + ip[4])); + t1 >>= 16; + _E = t1; + + t1 = (int32_t)(xC4S4 * (ip[0] - ip[4])); + t1 >>= 16; + _F = t1; + + t1 = (int32_t)(xC2S6 * ip[2]); + t2 = (int32_t)(xC6S2 * ip[6]); + t1 >>= 16; + t2 >>= 16; + _G = t1 + t2; + + t1 = (int32_t)(xC6S2 * ip[2]); + t2 = (int32_t)(xC2S6 * ip[6]); + t1 >>= 16; + t2 >>= 16; + _H = t1 - t2; + + + _Ed = _E - _G; + _Gd = _E + _G; + + _Add = _F + _Ad; + _Bdd = _Bd - _H; + + _Fd = _F - _Ad; + _Hd = _Bd + _H; + + /* Final sequence of operations over-write original inputs. */ + ip[0] = (int16_t)((_Gd + _Cd ) >> 0); + ip[7] = (int16_t)((_Gd - _Cd ) >> 0); + + ip[1] = (int16_t)((_Add + _Hd ) >> 0); + ip[2] = (int16_t)((_Add - _Hd ) >> 0); + + ip[3] = (int16_t)((_Ed + _Dd ) >> 0); + ip[4] = (int16_t)((_Ed - _Dd ) >> 0); + + ip[5] = (int16_t)((_Fd + _Bdd ) >> 0); + ip[6] = (int16_t)((_Fd - _Bdd ) >> 0); + + } + + ip += 8; /* next row */ + } + + ip = intermediate_data; + + for ( i = 0; i < 8; i++) { + /* Check for non-zero values (bitwise or faster than ||) */ + if ( ip[0 * 8] | ip[1 * 8] | ip[2 * 8] | ip[3 * 8] | + ip[4 * 8] | ip[5 * 8] | ip[6 * 8] | ip[7 * 8] ) { + + t1 = (int32_t)(xC1S7 * ip[1*8]); + t2 = (int32_t)(xC7S1 * ip[7*8]); + t1 >>= 16; + t2 >>= 16; + _A = t1 + t2; + + t1 = (int32_t)(xC7S1 * ip[1*8]); + t2 = (int32_t)(xC1S7 * ip[7*8]); + t1 >>= 16; + t2 >>= 16; + _B = t1 - t2; + + t1 = (int32_t)(xC3S5 * ip[3*8]); + t2 = (int32_t)(xC5S3 * ip[5*8]); + t1 >>= 16; + t2 >>= 16; + _C = t1 + t2; + + t1 = (int32_t)(xC3S5 * ip[5*8]); + t2 = (int32_t)(xC5S3 * ip[3*8]); + t1 >>= 16; + t2 >>= 16; + _D = t1 - t2; + + + t1 = (int32_t)(xC4S4 * (_A - _C)); + t1 >>= 16; + _Ad = t1; + + t1 = (int32_t)(xC4S4 * (_B - _D)); + t1 >>= 16; + _Bd = t1; + + + _Cd = _A + _C; + _Dd = _B + _D; + + t1 = (int32_t)(xC4S4 * (ip[0*8] + ip[4*8])); + t1 >>= 16; + _E = t1; + + t1 = (int32_t)(xC4S4 * (ip[0*8] - ip[4*8])); + t1 >>= 16; + _F = t1; + + t1 = (int32_t)(xC2S6 * ip[2*8]); + t2 = (int32_t)(xC6S2 * ip[6*8]); + t1 >>= 16; + t2 >>= 16; + _G = t1 + t2; + + t1 = (int32_t)(xC6S2 * ip[2*8]); + t2 = (int32_t)(xC2S6 * ip[6*8]); + t1 >>= 16; + t2 >>= 16; + _H = t1 - t2; + + + _Ed = _E - _G; + _Gd = _E + _G; + + _Add = _F + _Ad; + _Bdd = _Bd - _H; + + _Fd = _F - _Ad; + _Hd = _Bd + _H; + + _Gd += IdctAdjustBeforeShift; + _Add += IdctAdjustBeforeShift; + _Ed += IdctAdjustBeforeShift; + _Fd += IdctAdjustBeforeShift; + + /* Final sequence of operations over-write original inputs. */ + op[0*8] = (int16_t)((_Gd + _Cd ) >> 4); + op[7*8] = (int16_t)((_Gd - _Cd ) >> 4); + + op[1*8] = (int16_t)((_Add + _Hd ) >> 4); + op[2*8] = (int16_t)((_Add - _Hd ) >> 4); + + op[3*8] = (int16_t)((_Ed + _Dd ) >> 4); + op[4*8] = (int16_t)((_Ed - _Dd ) >> 4); + + op[5*8] = (int16_t)((_Fd + _Bdd ) >> 4); + op[6*8] = (int16_t)((_Fd - _Bdd ) >> 4); + + } else { + + op[0*8] = 0; + op[7*8] = 0; + op[1*8] = 0; + op[2*8] = 0; + op[3*8] = 0; + op[4*8] = 0; + op[5*8] = 0; + op[6*8] = 0; + } + + ip++; /* next column */ + op++; + } +} + +void vp3_idct_put(int16_t *input_data, int16_t *dequant_matrix, + uint8_t *dest, int stride) +{ + int16_t transformed_data[64]; + int16_t *op; + int i, j; + + vp3_idct_c(input_data, dequant_matrix, transformed_data); + + /* place in final output */ + op = transformed_data; + for (i = 0; i < 8; i++) { + for (j = 0; j < 8; j++) { + if (*op < -128) + *dest = 0; + else if (*op > 127) + *dest = 255; + else + *dest = (uint8_t)(*op + 128); + op++; + dest++; + } + dest += (stride - 8); + } +} + +void vp3_idct_add(int16_t *input_data, int16_t *dequant_matrix, + uint8_t *dest, int stride) +{ + int16_t transformed_data[64]; + int16_t *op; + int i, j; + int16_t sample; + + vp3_idct_c(input_data, dequant_matrix, transformed_data); + + /* place in final output */ + op = transformed_data; + for (i = 0; i < 8; i++) { + for (j = 0; j < 8; j++) { + sample = *dest + *op; + if (sample < 0) + *dest = 0; + else if (sample > 255) + *dest = 255; + else + *dest = (uint8_t)(sample & 0xFF); + op++; + dest++; + } + dest += (stride - 8); + } +} + +/************************************************************************ * VP3 specific functions ************************************************************************/ @@ -843,7 +1146,7 @@ * * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL. */ -#define SCALER 1 +#define SCALER 4 /* scale DC quantizers */ s->intra_y_dequant[0] = vp31_intra_y_dequant[0] * dc_scale_factor / 100; @@ -1423,7 +1726,6 @@ int current_fragment; debug_vp3(" vp3: unpacking motion vectors\n"); - if (s->keyframe) { debug_vp3(" keyframe-- there are no motion vectors\n"); @@ -2030,10 +2332,7 @@ int x, y; int m, n; int i = first_fragment; - int j; int16_t *dequantizer; - DCTELEM dequant_block[64]; - DCTELEM dequant_block_permuted[64]; unsigned char *output_plane; unsigned char *last_plane; unsigned char *golden_plane; @@ -2122,8 +2421,8 @@ * to render the block */ if ((motion_source < upper_motion_limit) || (motion_source > lower_motion_limit)) { -// printf (" vp3: help! motion source (%d) out of range (%d..%d)\n", -// motion_source, upper_motion_limit, lower_motion_limit); + printf (" vp3: help! motion source (%d) out of range (%d..%d), fragment %d\n", + motion_source, upper_motion_limit, lower_motion_limit, i); continue; } } @@ -2151,34 +2450,16 @@ debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n", i, s->all_fragments[i].coding_method, s->all_fragments[i].coeffs[0], dequantizer[0]); - for (j = 0; j < 64; j++) - dequant_block[dezigzag_index[j]] = - s->all_fragments[i].coeffs[j] * - dequantizer[j]; - for (j = 0; j < 64; j++) - dequant_block_permuted[s->dsp.idct_permutation[j]] = - dequant_block[j]; - - debug_idct("dequantized block:\n"); - for (m = 0; m < 8; m++) { - for (n = 0; n < 8; n++) { - debug_idct(" %5d", dequant_block[m * 8 + n]); - } - debug_idct("\n"); - } - debug_idct("\n"); /* invert DCT and place (or add) in final output */ - if (s->all_fragments[i].coding_method == MODE_INTRA) { - dequant_block_permuted[0] += 1024; - s->dsp.idct_put( + vp3_idct_put(s->all_fragments[i].coeffs, dequantizer, output_plane + s->all_fragments[i].first_pixel, - stride, dequant_block_permuted); + stride); } else { - s->dsp.idct_add( + vp3_idct_add(s->all_fragments[i].coeffs, dequantizer, output_plane + s->all_fragments[i].first_pixel, - stride, dequant_block_permuted); + stride); } debug_idct("block after idct_%s():\n", @@ -2479,19 +2760,19 @@ } reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height); - reverse_dc_prediction(s, s->u_fragment_start, - s->fragment_width / 2, s->fragment_height / 2); - reverse_dc_prediction(s, s->v_fragment_start, - s->fragment_width / 2, s->fragment_height / 2); - render_fragments(s, 0, s->width, s->height, 0); -#if 1 - render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1); - render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2); -#else -memset(s->current_frame.data[1], 0x80, s->width * s->height / 4); -memset(s->current_frame.data[2], 0x80, s->width * s->height / 4); -#endif + + if ((avctx->flags & CODEC_FLAG_GRAY) == 0) { + reverse_dc_prediction(s, s->u_fragment_start, + s->fragment_width / 2, s->fragment_height / 2); + reverse_dc_prediction(s, s->v_fragment_start, + s->fragment_width / 2, s->fragment_height / 2); + render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1); + render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2); + } else { + memset(s->current_frame.data[1], 0x80, s->width * s->height / 4); + memset(s->current_frame.data[2], 0x80, s->width * s->height / 4); + } #if KEYFRAMES_ONLY }