From 9abc7e0fdc5b99e4503e22c9084195867e312222 Mon Sep 17 00:00:00 2001 From: Michael Niedermayer Date: Fri, 9 Nov 2007 21:37:48 +0000 Subject: intrax8 decoder patch by "someone" Originally committed as revision 10971 to svn://svn.ffmpeg.org/ffmpeg/trunk --- libavcodec/intrax8dsp.c | 485 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 485 insertions(+) create mode 100644 libavcodec/intrax8dsp.c (limited to 'libavcodec/intrax8dsp.c') diff --git a/libavcodec/intrax8dsp.c b/libavcodec/intrax8dsp.c new file mode 100644 index 0000000000..876bd398cd --- /dev/null +++ b/libavcodec/intrax8dsp.c @@ -0,0 +1,485 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** +* @file intrax8dsp.c + *@brief IntraX8 frame sub-decoder image manipulation routines + * + */ + +#include "dsputil.h" + +/* +area positions, #3 is 1 pixel only, other are 8 pixels + |66666666| + 3|44444444|55555555| +- -+--------+--------+ +1 2|XXXXXXXX| +1 2|XXXXXXXX| +1 2|XXXXXXXX| +1 2|XXXXXXXX| +1 2|XXXXXXXX| +1 2|XXXXXXXX| +1 2|XXXXXXXX| +1 2|XXXXXXXX| +^-start +*/ + +#define area1 (0) +#define area2 (8) +#define area3 (8+8) +#define area4 (8+8+1) +#define area5 (8+8+1+8) +#define area6 (8+8+1+16) + +/** + Collect statistics and prepare the edge pixels required by the other spacial compensation functions. + + * @param src pointer to the beginning of the processed block + * @param dst pointer to emu_edge, edge pixels are stored in way other compensation routines use. + * @param linesize byte offset between 2 vertical pixels in the source image + * @param range pointer to the variable where the range of edge pixels is to be stored (max-min values) + * @param psum pointer to the variable where the sum of edge pixels is to be stored + * @param edges informs this routine that the block is on image border, so it have to interpolate the missing edge pixels. + and some of the edge pixels should be interpolated, flag have following meaning: + 1 - mb_x==0 - first block in the row, interpolate area #1,#2,#3; + 2 - mb_y==0 - first row, interpolate area #3,#4,#5,#6; + note: 1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas; + 4 - mb_x>= (mb_width-1) last block on the row, interpolate area #5; +*/ +static void x8_setup_spacial_compensation(uint8_t *src, uint8_t *dst, int linesize, + int * range, int * psum, int edges){ + uint8_t * ptr; + int sum; + int i; + int min_pix,max_pix; + uint8_t c; + + if((edges&3)==3){ + *psum=0x80*(8+1+8+2); + *range=0; + memset(dst,0x80,16+1+16+8); + //this triggers flat_dc for sure. + //flat_dc avoids all (other) prediction modes, but requires dc_level decoding. + return; + } + + min_pix=256; + max_pix=-1; + + sum=0; + + if(!(edges&1)){//(mb_x!=0)//there is previous block on this row + ptr=src-1;//left column, area 2 + for(i=7;i>=0;i--){ + c=*(ptr-1);//area1, same mb as area2, no need to check + dst[area1+i]=c; + c=*(ptr); + + sum+=c; + min_pix=FFMIN(min_pix,c); + max_pix=FFMAX(max_pix,c); + dst[area2+i]=c; + + ptr+=linesize; + } + } + + if(!(edges&2)){ //(mb_y!=0)//there is row above + ptr=src-linesize;//top line + for(i=0;i<8;i++){ + c=*(ptr+i); + sum+=c; + min_pix=FFMIN(min_pix, c); + max_pix=FFMAX(max_pix, c); + } + if(edges&4){//last block on the row? + memset(dst+area5,c,8);//set with last pixel fr + memcpy(dst+area4, ptr, 8); + }else{ + memcpy(dst+area4, ptr, 16);//both area4 and 5 + } + memcpy(dst+area6, ptr-linesize, 8);//area6 always present in the above block + } +//now calc the stuff we need + if(edges&3){//mb_x==0 || mb_y==0){ + if(edges&1){ //(mb_x==0) {//implies mb_y!=0 + int avg=(sum+4)>>3; + memset(dst+area1,avg,8+8+1);//areas 1,2 and 3 are averaged + sum+=avg*9;//8+1(egde pixel) + }else{//implies y==0 x!=0 + int avg=(sum+4)>>3; + memset(dst+area3,avg, 1+16+8);//areas 3, 4,5,6 + sum+=avg*9; + } + }else{ + uint8_t c; + c=*(src-1-linesize);//the edge pixel,in the top line and left column + dst[area3]=c; + sum+=c; + //edge pixel is not part of min/max + } + (*range) = max_pix - min_pix; + sum += *(dst+area5) + *(dst+area5+1); + *psum = sum; +} + + +static const uint16_t zero_prediction_weights[64*2] = { + 640, 640, 669, 480, 708, 354, 748, 257, 792, 198, 760, 143, 808, 101, 772, 72, + 480, 669, 537, 537, 598, 416, 661, 316, 719, 250, 707, 185, 768, 134, 745, 97, + 354, 708, 416, 598, 488, 488, 564, 388, 634, 317, 642, 241, 716, 179, 706, 132, + 257, 748, 316, 661, 388, 564, 469, 469, 543, 395, 571, 311, 655, 238, 660, 180, + 198, 792, 250, 719, 317, 634, 395, 543, 469, 469, 507, 380, 597, 299, 616, 231, + 161, 855, 206, 788, 266, 710, 340, 623, 411, 548, 455, 455, 548, 366, 576, 288, + 122, 972, 159, 914, 211, 842, 276, 758, 341, 682, 389, 584, 483, 483, 520, 390, + 110, 1172, 144, 1107, 193, 1028, 254, 932, 317, 846, 366, 731, 458, 611, 499, 499 +}; + +static void spacial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){ + int i,j; + int x,y; + unsigned int p;//power divided by 2 + int a; + uint16_t left_sum[2][8]; + uint16_t top_sum[2][8]; + memset(left_sum,0,2*8*sizeof(uint16_t)); + memset( top_sum,0,2*8*sizeof(uint16_t)); + + for(i=0;i<8;i++){ + a=src[area2+7-i]<<4; + for(j=0;j<8;j++){ + p=abs(i-j); + left_sum[p&1][j]+= a>>(p>>1); + } + } + + for(i=0;i<8;i++){ + a=src[area4+i]<<4; + for(j=0;j<8;j++){ + p=abs(i-j); + top_sum[p&1][j]+= a>>(p>>1); + } + } + for(;i<10;i++){ + a=src[area4+i]<<4; + for(j=5;j<8;j++){ + p=abs(i-j); + top_sum[p&1][j]+= a>>(p>>1); + } + } + for(;i<12;i++){ + a=src[area4+i]<<4; + for(j=7;j<8;j++){ + p=abs(i-j); + top_sum[p&1][j]+= a>>(p>>1); + } + } + + for(i=0;i<8;i++){ + top_sum [0][i]+=(top_sum [1][i]*181 + 128 )>>8;//181 is sqrt(2)/2 + left_sum[0][i]+=(left_sum[1][i]*181 + 128 )>>8; + } + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x] = ( + (uint32_t)top_sum [0][x]*zero_prediction_weights[y*16+x*2+0] + + (uint32_t)left_sum[0][y]*zero_prediction_weights[y*16+x*2+1] + + 0x8000 + )>>16; + } + dst+=linesize; + } +} +static void spacial_compensation_1(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=src[area4 + FFMIN(2*y+x+2, 15) ]; + } + dst+=linesize; + } +} +static void spacial_compensation_2(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=src[area4 +1+y+x]; + } + dst+=linesize; + } +} +static void spacial_compensation_3(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=src[area4 +((y+1)>>1)+x]; + } + dst+=linesize; + } +} +static void spacial_compensation_4(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=( src[area4+x] + src[area6+x] + 1 )>>1; + } + dst+=linesize; + } +} +static void spacial_compensation_5(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + if(2*x-y<0){ + dst[x]=src[area2+9+2*x-y]; + }else{ + dst[x]=src[area4 +x-((y+1)>>1)]; + } + } + dst+=linesize; + } +} +static void spacial_compensation_6(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=src[area3+x-y]; + } + dst+=linesize; + } +} +static void spacial_compensation_7(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + if(x-2*y>0){ + dst[x]=( src[area3-1+x-2*y] + src[area3+x-2*y] + 1)>>1; + }else{ + dst[x]=src[area2+8-y +(x>>1)]; + } + } + dst+=linesize; + } +} +static void spacial_compensation_8(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=( src[area1+7-y] + src[area2+7-y] + 1 )>>1; + } + dst+=linesize; + } +} +static void spacial_compensation_9(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=src[area2+6-FFMIN(x+y,6)]; + } + dst+=linesize; + } +} +static void spacial_compensation_10(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=(src[area2+7-y]*(8-x)+src[area4+x]*x+4)>>3; + } + dst+=linesize; + } +} +static void spacial_compensation_11(uint8_t *src , uint8_t *dst, int linesize){ + int x,y; + + for(y=0;y<8;y++){ + for(x=0;x<8;x++){ + dst[x]=(src[area2+7-y]*y+src[area4+x]*(8-y)+4)>>3; + } + dst+=linesize; + } +} + +static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride, int quant){ + int i,t; + int p0,p1,p2,p3,p4,p5,p6,p7,p8,p9; + int ql=(quant+10)>>3; + + for(i=0; i<8; i++,ptr+=b_stride){ + p0=ptr[-5*a_stride]; + p1=ptr[-4*a_stride]; + p2=ptr[-3*a_stride]; + p3=ptr[-2*a_stride]; + p4=ptr[-1*a_stride]; + p5=ptr[ 0 ]; + p6=ptr[ 1*a_stride]; + p7=ptr[ 2*a_stride]; + p8=ptr[ 3*a_stride]; + p9=ptr[ 4*a_stride]; + + t= + (FFABS(p1-p2) <= ql) + + (FFABS(p2-p3) <= ql) + + (FFABS(p3-p4) <= ql) + + (FFABS(p4-p5) <= ql); + if(t>0){//you need at least 1 to be able to reach total score of 6. + t+= + (FFABS(p5-p6) <= ql) + + (FFABS(p6-p7) <= ql) + + (FFABS(p7-p8) <= ql) + + (FFABS(p8-p9) <= ql) + + (FFABS(p0-p1) <= ql); + if(t>=6){ + int min,max; + + min=max=p1; + min=FFMIN(min,p3); max=FFMAX(max,p3); + min=FFMIN(min,p5); max=FFMAX(max,p5); + min=FFMIN(min,p8); max=FFMAX(max,p8); + if(max-min<2*quant){//early stop + min=FFMIN(min,p2); max=FFMAX(max,p2); + min=FFMIN(min,p4); max=FFMAX(max,p4); + min=FFMIN(min,p6); max=FFMAX(max,p6); + min=FFMIN(min,p7); max=FFMAX(max,p7); + if(max-min<2*quant){ + ptr[-2*a_stride]=(4*p2 + 3*p3 + 1*p7 + 4)>>3; + ptr[-1*a_stride]=(3*p2 + 3*p4 + 2*p7 + 4)>>3; + ptr[ 0 ]=(2*p2 + 3*p5 + 3*p7 + 4)>>3; + ptr[ 1*a_stride]=(1*p2 + 3*p6 + 4*p7 + 4)>>3; + continue; + }; + } + } + } + { + int x,x0,x1,x2; + int m; + + x0 = (2*p3 - 5*p4 + 5*p5 - 2*p6 + 4)>>3; + if(FFABS(x0) < quant){ + x1=(2*p1 - 5*p2 + 5*p3 - 2*p4 + 4)>>3; + x2=(2*p5 - 5*p6 + 5*p7 - 2*p8 + 4)>>3; + + x=FFABS(x0) - FFMIN( FFABS(x1), FFABS(x2) ); + m=p4-p5; + + if( x > 0 && (m^x0) <0){ + int32_t sign; + + sign=m>>31; + m=(m^sign)-sign;//abs(m) + m>>=1; + + x=(5*x)>>3; + + if(x>m) x=m; + + x=(x^sign)-sign; + + ptr[-1*a_stride] -= x; + ptr[ 0] += x; + } + } + } + } +} + +static void x8_h_loop_filter(uint8_t *src, int stride, int qscale){ + x8_loop_filter(src, stride, 1, qscale); +} + +static void x8_v_loop_filter(uint8_t *src, int stride, int qscale){ + x8_loop_filter(src, 1, stride, qscale); +} + +void ff_intrax8dsp_init(DSPContext* dsp, AVCodecContext *avctx) { + dsp->x8_h_loop_filter=x8_h_loop_filter; + dsp->x8_v_loop_filter=x8_v_loop_filter; + dsp->x8_setup_spacial_compensation=x8_setup_spacial_compensation; + dsp->x8_spacial_compensation[0]=spacial_compensation_0; + dsp->x8_spacial_compensation[1]=spacial_compensation_1; + dsp->x8_spacial_compensation[2]=spacial_compensation_2; + dsp->x8_spacial_compensation[3]=spacial_compensation_3; + dsp->x8_spacial_compensation[4]=spacial_compensation_4; + dsp->x8_spacial_compensation[5]=spacial_compensation_5; + dsp->x8_spacial_compensation[6]=spacial_compensation_6; + dsp->x8_spacial_compensation[7]=spacial_compensation_7; + dsp->x8_spacial_compensation[8]=spacial_compensation_8; + dsp->x8_spacial_compensation[9]=spacial_compensation_9; + dsp->x8_spacial_compensation[10]=spacial_compensation_10; + dsp->x8_spacial_compensation[11]=spacial_compensation_11; +} + +#if 0 +static void wmv2_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride, int quant){ + int i,t; + int p0,p1,p2,p3,p4,p5,p6,p7,p8,p9; + + for(i=0; i<8; i++,ptr+=b_stride){ + p1=ptr[-4*a_stride]; + p2=ptr[-3*a_stride]; + p3=ptr[-2*a_stride]; + p4=ptr[-1*a_stride]; + p5=ptr[ 0 ]; + p6=ptr[ 1*a_stride]; + p7=ptr[ 2*a_stride]; + p8=ptr[ 3*a_stride]; + + { + int x,x0,x1,x2; + int m; + + x0 = (2*p3 - 5*p4 + 5*p5 - 2*p6 + 4)>>3; + if(abs(x0) < quant){ + x1=(2*p1 - 5*p2 + 5*p3 - 2*p4 + 4)>>3; + x2=(2*p5 - 5*p6 + 5*p7 - 2*p8 + 4)>>3; + + x=abs(x0) - FFMIN( abs(x1), abs(x2) ); + m=p4-p5; + + if( x > 0 && (m^x0) < 0){ + int32_t sign; + + sign=m>>31; + m=(m^sign)-sign;//abs(m) + m>>=1; + + x=(5*x)>>3; + + if(x>m) x=m; + + x=(x^sign)-sign; + + ptr[-1*a_stride] -= x; + ptr[ 0] += x; + } + } + } + } +} +#endif -- cgit v1.2.3