virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-24 13:56:33 +02:00
Code Issues Releases Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  4xm: fix invalid array indexing
  rv34dsp: factorize a multiplication in the noround inverse transform
  rv40: perform bitwise checks in loop filter
  rv34: remove inline keyword from rv34_decode_block().
  rv40: change a logical test into a bitwise one.
  rv34: remove constant parameter
  rv40: don't always do the full prev_type search
  dsputil x86: revert a test back to its previous value
  rv34dsp x86: implement MMX2 inverse transform

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2012-04-29 21:45:41 +02:00
commit dfa07e8928
7 changed files with 130 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
libavcodec/4xm.c
View File

@ -240,15 +240,18 @@ static void idct(DCTELEM block[64])
static av_cold void init_vlcs(FourXContext *f) static av_cold void init_vlcs(FourXContext *f)
{ {
static VLC_TYPE table[8][32][2]; static VLC_TYPE table[2][4][32][2];
int i; int i, j;
for (i = 0; i < 8; i++) { for (i = 0; i < 2; i++) {
block_type_vlc[0][i].table = table[i]; for (j = 0; j < 4; j++) {
block_type_vlc[0][i].table_allocated = 32; block_type_vlc[i][j].table = table[i][j];
init_vlc(&block_type_vlc[0][i], BLOCK_TYPE_VLC_BITS, 7, block_type_vlc[i][j].table_allocated = 32;
&block_type_tab[0][i][0][1], 2, 1, init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
&block_type_tab[0][i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); &block_type_tab[i][j][0][1], 2, 1,
&block_type_tab[i][j][0][0], 2, 1,
INIT_VLC_USE_NEW_STATIC);
}
} }
} }

21
libavcodec/rv34.c
View File

@ -260,20 +260,15 @@ static inline void decode_subblock1(DCTELEM *dst, int code, GetBitContext *gb, V
decode_coeff(dst, coeff, 3, gb, vlc, q); decode_coeff(dst, coeff, 3, gb, vlc, q);
} }
static inline void decode_subblock3(DCTELEM *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, static inline void decode_subblock3(DCTELEM *dst, int code, GetBitContext *gb, VLC *vlc,
int q_dc, int q_ac1, int q_ac2) int q_dc, int q_ac1, int q_ac2)
{ {
int flags = modulo_three_table[code]; int flags = modulo_three_table[code];
decode_coeff( dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc); decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
if(is_block2){ decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q_ac1); decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q_ac1); decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
}else{
decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
}
decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
} }
/** /**
@ -287,7 +282,7 @@ static inline void decode_subblock3(DCTELEM *dst, int code, const int is_block2,
* o--o * o--o
*/ */
static inline int rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2) static int rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
{ {
int code, pattern, has_ac = 1; int code, pattern, has_ac = 1;
@ -298,7 +293,7 @@ static inline int rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rv
code >>= 3; code >>= 3;
if (modulo_three_table[code] & 0x3F) { if (modulo_three_table[code] & 0x3F) {
decode_subblock3(dst, code, 0, gb, &rvlc->coefficient, q_dc, q_ac1, q_ac2); decode_subblock3(dst, code, gb, &rvlc->coefficient, q_dc, q_ac1, q_ac2);
} else { } else {
decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc); decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc);
if (!pattern) if (!pattern)
@ -318,7 +313,7 @@ static inline int rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rv
code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2); code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2);
decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2); decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2);
} }
return has_ac || pattern; return has_ac | pattern;
} }
/** /**

16
libavcodec/rv34dsp.c
View File

@ -88,15 +88,15 @@ static void rv34_inv_transform_noround_c(DCTELEM *block){
rv34_row_transform(temp, block); rv34_row_transform(temp, block);
for(i = 0; i < 4; i++){ for(i = 0; i < 4; i++){
const int z0 = 13*(temp[4*0+i] + temp[4*2+i]); const int z0 = 39*(temp[4*0+i] + temp[4*2+i]);
const int z1 = 13*(temp[4*0+i] - temp[4*2+i]); const int z1 = 39*(temp[4*0+i] - temp[4*2+i]);
const int z2 = 7* temp[4*1+i] - 17*temp[4*3+i]; const int z2 = 21* temp[4*1+i] - 51*temp[4*3+i];
const int z3 = 17* temp[4*1+i] + 7*temp[4*3+i]; const int z3 = 51* temp[4*1+i] + 21*temp[4*3+i];
block[i*4+0] = ((z0 + z3) * 3) >> 11; block[i*4+0] = (z0 + z3) >> 11;
block[i*4+1] = ((z1 + z2) * 3) >> 11; block[i*4+1] = (z1 + z2) >> 11;
block[i*4+2] = ((z1 - z2) * 3) >> 11; block[i*4+2] = (z1 - z2) >> 11;
block[i*4+3] = ((z0 - z3) * 3) >> 11; block[i*4+3] = (z0 - z3) >> 11;
} }
} }

41
libavcodec/rv40.c
View File

@ -228,8 +228,6 @@ static int rv40_decode_mb_info(RV34DecContext *r)
int q, i; int q, i;
int prev_type = 0; int prev_type = 0;
int mb_pos = s->mb_x + s->mb_y * s->mb_stride; int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
int blocks[RV34_MB_TYPES] = {0};
int count = 0;
if(!r->s.mb_skip_run) { if(!r->s.mb_skip_run) {
r->s.mb_skip_run = svq3_get_ue_golomb(gb) + 1; r->s.mb_skip_run = svq3_get_ue_golomb(gb) + 1;
@ -240,22 +238,27 @@ static int rv40_decode_mb_info(RV34DecContext *r)
if(--r->s.mb_skip_run) if(--r->s.mb_skip_run)
return RV34_MB_SKIP; return RV34_MB_SKIP;
if(r->avail_cache[6-1])
blocks[r->mb_type[mb_pos - 1]]++;
if(r->avail_cache[6-4]){ if(r->avail_cache[6-4]){
int blocks[RV34_MB_TYPES] = {0};
int count = 0;
if(r->avail_cache[6-1])
blocks[r->mb_type[mb_pos - 1]]++;
blocks[r->mb_type[mb_pos - s->mb_stride]]++; blocks[r->mb_type[mb_pos - s->mb_stride]]++;
if(r->avail_cache[6-2]) if(r->avail_cache[6-2])
blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++; blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++;
if(r->avail_cache[6-5]) if(r->avail_cache[6-5])
blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++; blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++;
} for(i = 0; i < RV34_MB_TYPES; i++){
if(blocks[i] > count){
for(i = 0; i < RV34_MB_TYPES; i++){ count = blocks[i];
if(blocks[i] > count){ prev_type = i;
count = blocks[i]; if(count>1)
prev_type = i; break;
}
} }
} } else if (r->avail_cache[6-1])
prev_type = r->mb_type[mb_pos - 1];
if(s->pict_type == AV_PICTURE_TYPE_P){ if(s->pict_type == AV_PICTURE_TYPE_P){
prev_type = block_num_to_ptype_vlc_num[prev_type]; prev_type = block_num_to_ptype_vlc_num[prev_type];
q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1); q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1);
@ -431,7 +434,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
y_v_deblock &= ~MASK_Y_LEFT_COL; y_v_deblock &= ~MASK_Y_LEFT_COL;
if(!row) if(!row)
y_h_deblock &= ~MASK_Y_TOP_ROW; y_h_deblock &= ~MASK_Y_TOP_ROW;
if(row == s->mb_height - 1 || (mb_strong[POS_CUR] || mb_strong[POS_BOTTOM])) if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
y_h_deblock &= ~(MASK_Y_TOP_ROW << 16); y_h_deblock &= ~(MASK_Y_TOP_ROW << 16);
/* Calculating chroma patterns is similar and easier since there is /* Calculating chroma patterns is similar and easier since there is
* no motion vector pattern for them. * no motion vector pattern for them.
@ -448,7 +451,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
c_v_deblock[i] &= ~MASK_C_LEFT_COL; c_v_deblock[i] &= ~MASK_C_LEFT_COL;
if(!row) if(!row)
c_h_deblock[i] &= ~MASK_C_TOP_ROW; c_h_deblock[i] &= ~MASK_C_TOP_ROW;
if(row == s->mb_height - 1 || mb_strong[POS_CUR] || mb_strong[POS_BOTTOM]) if(row == s->mb_height - 1 || (mb_strong[POS_CUR] | mb_strong[POS_BOTTOM]))
c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4); c_h_deblock[i] &= ~(MASK_C_TOP_ROW << 4);
} }
@ -469,7 +472,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
0, 0, 0); 0, 0, 0);
} }
// filter left block edge in ordinary mode (with low filtering strength) // filter left block edge in ordinary mode (with low filtering strength)
if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] || mb_strong[POS_LEFT]))){ if(y_v_deblock & (MASK_CUR << ij) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
if(!i) if(!i)
clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0; clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
else else
@ -480,14 +483,14 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
alpha, beta, betaY, 0, 0, 1); alpha, beta, betaY, 0, 0, 1);
} }
// filter top edge of the current macroblock when filtering strength is high // filter top edge of the current macroblock when filtering strength is high
if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] || mb_strong[POS_TOP])){ if(!j && y_h_deblock & (MASK_CUR << i) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither, rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur, clip_cur,
mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0, mvmasks[POS_TOP] & (MASK_TOP << i) ? clip[POS_TOP] : 0,
alpha, beta, betaY, 0, 1, 0); alpha, beta, betaY, 0, 1, 0);
} }
// filter left block edge in edge mode (with high filtering strength) // filter left block edge in edge mode (with high filtering strength)
if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] || mb_strong[POS_LEFT])){ if(y_v_deblock & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0; clip_left = mvmasks[POS_LEFT] & (MASK_RIGHT << j) ? clip[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither, rv40_adaptive_loop_filter(&r->rdsp, Y, s->linesize, dither,
clip_cur, clip_cur,
@ -509,7 +512,7 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
clip_cur, clip_cur,
alpha, beta, betaC, 1, 0, 0); alpha, beta, betaC, 1, 0, 0);
} }
if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] || mb_strong[POS_LEFT]))){ if((c_v_deblock[k] & (MASK_CUR << ij)) && (i || !(mb_strong[POS_CUR] | mb_strong[POS_LEFT]))){
if(!i) if(!i)
clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0; clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
else else
@ -519,14 +522,14 @@ static void rv40_loop_filter(RV34DecContext *r, int row)
clip_left, clip_left,
alpha, beta, betaC, 1, 0, 1); alpha, beta, betaC, 1, 0, 1);
} }
if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] || mb_strong[POS_TOP])){ if(!j && c_h_deblock[k] & (MASK_CUR << ij) && (mb_strong[POS_CUR] | mb_strong[POS_TOP])){
int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0; int clip_top = uvcbp[POS_TOP][k] & (MASK_CUR << (ij+2)) ? clip[POS_TOP] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8, rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, i*8,
clip_cur, clip_cur,
clip_top, clip_top,
alpha, beta, betaC, 1, 1, 0); alpha, beta, betaC, 1, 1, 0);
} }
if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] || mb_strong[POS_LEFT])){ if(c_v_deblock[k] & (MASK_CUR << ij) && !i && (mb_strong[POS_CUR] | mb_strong[POS_LEFT])){
clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0; clip_left = uvcbp[POS_LEFT][k] & (MASK_CUR << (2*j+1)) ? clip[POS_LEFT] : 0;
rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8, rv40_adaptive_loop_filter(&r->rdsp, C, s->uvlinesize, j*8,
clip_cur, clip_cur,

2
libavcodec/x86/dsputil_mmx.c
View File

@ -3043,7 +3043,7 @@ static void dsputil_init_sse2(DSPContext *c, AVCodecContext *avctx,
const int bit_depth = avctx->bits_per_raw_sample; const int bit_depth = avctx->bits_per_raw_sample;
const int high_bit_depth = bit_depth > 8; const int high_bit_depth = bit_depth > 8;
if (mm_flags & AV_CPU_FLAG_3DNOW) { if (!(mm_flags & AV_CPU_FLAG_SSE2SLOW)) {
// these functions are slower than mmx on AMD, but faster on Intel // these functions are slower than mmx on AMD, but faster on Intel
if (!high_bit_depth) { if (!high_bit_depth) {
c->put_pixels_tab[0][0] = put_pixels16_sse2; c->put_pixels_tab[0][0] = put_pixels16_sse2;

78
libavcodec/x86/rv34dsp.asm
View File

@ -22,6 +22,16 @@
%include "x86inc.asm" %include "x86inc.asm"
%include "x86util.asm" %include "x86util.asm"
SECTION_RODATA
pw_row_coeffs: times 4 dw 13
times 4 dw 17
times 4 dw 7
pd_512: times 2 dd 0x200
pw_col_coeffs: dw 13, 13, 13, -13
dw 17, 7, 7, -17
dw 13, -13, 13, 13
dw -7, 17, -17, -7
SECTION .text SECTION .text
%macro IDCT_DC_NOROUND 1 %macro IDCT_DC_NOROUND 1
@ -88,6 +98,74 @@ cglobal rv34_idct_dc_add_mmx, 3, 3
movh [r2+r1], m5 movh [r2+r1], m5
RET RET
; Load coeffs and perform row transform
; Output: coeffs in mm[0467], rounder in mm5
%macro ROW_TRANSFORM 1
pxor mm7, mm7
mova mm0, [%1+ 0*8]
mova mm1, [%1+ 1*8]
mova mm2, [%1+ 2*8]
mova mm3, [%1+ 3*8]
mova [%1+ 0*8], mm7
mova [%1+ 1*8], mm7
mova [%1+ 2*8], mm7
mova [%1+ 3*8], mm7
mova mm4, mm0
mova mm6, [pw_row_coeffs+ 0]
paddsw mm0, mm2 ; b0 + b2
psubsw mm4, mm2 ; b0 - b2
pmullw mm0, mm6 ; *13 = z0
pmullw mm4, mm6 ; *13 = z1
mova mm5, mm1
pmullw mm1, [pw_row_coeffs+ 8] ; b1*17
pmullw mm5, [pw_row_coeffs+16] ; b1* 7
mova mm7, mm3
pmullw mm3, [pw_row_coeffs+ 8] ; b3*17
pmullw mm7, [pw_row_coeffs+16] ; b3* 7
paddsw mm1, mm7 ; z3 = b1*17 + b3* 7
psubsw mm5, mm3 ; z2 = b1* 7 - b3*17
mova mm7, mm0
mova mm6, mm4
paddsw mm0, mm1 ; z0 + z3
psubsw mm7, mm1 ; z0 - z3
paddsw mm4, mm5 ; z1 + z2
psubsw mm6, mm5 ; z1 - z2
mova mm5, [pd_512] ; 0x200
%endmacro
; ff_rv34_idct_add_mmx2(uint8_t *dst, ptrdiff_t stride, DCTELEM *block);
%macro COL_TRANSFORM 4
pshufw mm3, %2, 0xDD ; col. 1,3,1,3
pshufw %2, %2, 0x88 ; col. 0,2,0,2
pmaddwd %2, %3 ; 13*c0+13*c2 | 13*c0-13*c2 = z0 | z1
pmaddwd mm3, %4 ; 17*c1+ 7*c3 | 7*c1-17*c3 = z3 | z2
paddd %2, mm5
pshufw mm1, %2, 01001110b ; z1 | z0
pshufw mm2, mm3, 01001110b ; z2 | z3
paddd %2, mm3 ; z0+z3 | z1+z2
psubd mm1, mm2 ; z1-z2 | z0-z3
movd mm3, %1
psrad %2, 10
pxor mm2, mm2
psrad mm1, 10
punpcklbw mm3, mm2
packssdw %2, mm1
paddw %2, mm3
packuswb %2, %2
movd %1, %2
%endmacro
INIT_MMX mmx2
cglobal rv34_idct_add, 3,3,0, d, s, b
ROW_TRANSFORM bq
COL_TRANSFORM [dq], mm0, [pw_col_coeffs+ 0], [pw_col_coeffs+ 8]
mova mm0, [pw_col_coeffs+ 0]
COL_TRANSFORM [dq+sq], mm4, mm0, [pw_col_coeffs+ 8]
mova mm4, [pw_col_coeffs+ 8]
lea dq, [dq + 2*sq]
COL_TRANSFORM [dq], mm6, mm0, mm4
COL_TRANSFORM [dq+sq], mm7, mm0, mm4
ret
; ff_rv34_idct_dc_add_sse4(uint8_t *dst, int stride, int dc); ; ff_rv34_idct_dc_add_sse4(uint8_t *dst, int stride, int dc);
INIT_XMM INIT_XMM
cglobal rv34_idct_dc_add_sse4, 3, 3, 6 cglobal rv34_idct_dc_add_sse4, 3, 3, 6

2
libavcodec/x86/rv34dsp_init.c
View File

@ -28,6 +28,7 @@ void ff_rv34_idct_dc_mmx2(DCTELEM *block);
void ff_rv34_idct_dc_noround_mmx2(DCTELEM *block); void ff_rv34_idct_dc_noround_mmx2(DCTELEM *block);
void ff_rv34_idct_dc_add_mmx(uint8_t *dst, ptrdiff_t stride, int dc); void ff_rv34_idct_dc_add_mmx(uint8_t *dst, ptrdiff_t stride, int dc);
void ff_rv34_idct_dc_add_sse4(uint8_t *dst, ptrdiff_t stride, int dc); void ff_rv34_idct_dc_add_sse4(uint8_t *dst, ptrdiff_t stride, int dc);
void ff_rv34_idct_add_mmx2(uint8_t *dst, ptrdiff_t stride, DCTELEM *block);
av_cold void ff_rv34dsp_init_x86(RV34DSPContext* c, DSPContext *dsp) av_cold void ff_rv34dsp_init_x86(RV34DSPContext* c, DSPContext *dsp)
{ {
@ -38,6 +39,7 @@ av_cold void ff_rv34dsp_init_x86(RV34DSPContext* c, DSPContext *dsp)
c->rv34_idct_dc_add = ff_rv34_idct_dc_add_mmx; c->rv34_idct_dc_add = ff_rv34_idct_dc_add_mmx;
if (mm_flags & AV_CPU_FLAG_MMX2) { if (mm_flags & AV_CPU_FLAG_MMX2) {
c->rv34_inv_transform_dc = ff_rv34_idct_dc_noround_mmx2; c->rv34_inv_transform_dc = ff_rv34_idct_dc_noround_mmx2;
c->rv34_idct_add = ff_rv34_idct_add_mmx2;
} }
if (mm_flags & AV_CPU_FLAG_SSE4) if (mm_flags & AV_CPU_FLAG_SSE4)
c->rv34_idct_dc_add = ff_rv34_idct_dc_add_sse4; c->rv34_idct_dc_add = ff_rv34_idct_dc_add_sse4;