yading@10: /*
yading@10:  * This file is part of FFmpeg.
yading@10:  *
yading@10:  * FFmpeg is free software; you can redistribute it and/or
yading@10:  * modify it under the terms of the GNU Lesser General Public
yading@10:  * License as published by the Free Software Foundation; either
yading@10:  * version 2.1 of the License, or (at your option) any later version.
yading@10:  *
yading@10:  * FFmpeg is distributed in the hope that it will be useful,
yading@10:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
yading@10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
yading@10:  * Lesser General Public License for more details.
yading@10:  *
yading@10:  * You should have received a copy of the GNU Lesser General Public
yading@10:  * License along with FFmpeg; if not, write to the Free Software
yading@10:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
yading@10:  */
yading@10: 
yading@10: /**
yading@10: * @file
yading@10:  *@brief IntraX8 frame subdecoder image manipulation routines
yading@10:  */
yading@10: 
yading@10: #include "intrax8dsp.h"
yading@10: #include "libavutil/common.h"
yading@10: 
yading@10: /*
yading@10: area positions, #3 is 1 pixel only, other are 8 pixels
yading@10:    |66666666|
yading@10:   3|44444444|55555555|
yading@10: - -+--------+--------+
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: 1 2|XXXXXXXX|
yading@10: ^-start
yading@10: */
yading@10: 
yading@10: #define area1 (0)
yading@10: #define area2 (8)
yading@10: #define area3 (8+8)
yading@10: #define area4 (8+8+1)
yading@10: #define area5 (8+8+1+8)
yading@10: #define area6 (8+8+1+16)
yading@10: 
yading@10: /**
yading@10:  Collect statistics and prepare the edge pixels required by the other spatial compensation functions.
yading@10: 
yading@10:  * @param src pointer to the beginning of the processed block
yading@10:  * @param dst pointer to emu_edge, edge pixels are stored the way other compensation routines do.
yading@10:  * @param linesize byte offset between 2 vertical pixels in the source image
yading@10:  * @param range pointer to the variable where the edge pixel range is to be stored (max-min values)
yading@10:  * @param psum  pointer to the variable where the edge pixel sum is to be stored
yading@10:  * @param edges Informs this routine that the block is on an image border, so it has to interpolate the missing edge pixels.
yading@10:                 and some of the edge pixels should be interpolated, the flag has the following meaning:
yading@10:                 1   - mb_x==0 - first block in the row, interpolate area #1,#2,#3;
yading@10:                 2   - mb_y==0 - first row, interpolate area #3,#4,#5,#6;
yading@10:         note:   1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas;
yading@10:                 4   - mb_x>= (mb_width-1) last block in the row, interpolate area #5;
yading@10: */
yading@10: static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesize,
yading@10:            int * range, int * psum,  int edges){
yading@10:     uint8_t * ptr;
yading@10:     int sum;
yading@10:     int i;
yading@10:     int min_pix,max_pix;
yading@10:     uint8_t c;
yading@10: 
yading@10:     if((edges&3)==3){
yading@10:         *psum=0x80*(8+1+8+2);
yading@10:         *range=0;
yading@10:         memset(dst,0x80,16+1+16+8);
yading@10:         //this triggers flat_dc for sure.
yading@10:         //flat_dc avoids all (other) prediction modes, but requires dc_level decoding.
yading@10:         return;
yading@10:     }
yading@10: 
yading@10:     min_pix=256;
yading@10:     max_pix=-1;
yading@10: 
yading@10:     sum=0;
yading@10: 
yading@10:     if(!(edges&1)){//(mb_x!=0)//there is previous block on this row
yading@10:         ptr=src-1;//left column, area 2
yading@10:         for(i=7;i>=0;i--){
yading@10:             c=*(ptr-1);//area1, same mb as area2, no need to check
yading@10:             dst[area1+i]=c;
yading@10:             c=*(ptr);
yading@10: 
yading@10:             sum+=c;
yading@10:             min_pix=FFMIN(min_pix,c);
yading@10:             max_pix=FFMAX(max_pix,c);
yading@10:             dst[area2+i]=c;
yading@10: 
yading@10:             ptr+=linesize;
yading@10:         }
yading@10:     }
yading@10: 
yading@10:     if(!(edges&2)){  //(mb_y!=0)//there is row above
yading@10:         ptr=src-linesize;//top line
yading@10:         for(i=0;i<8;i++){
yading@10:             c=*(ptr+i);
yading@10:             sum+=c;
yading@10:             min_pix=FFMIN(min_pix, c);
yading@10:             max_pix=FFMAX(max_pix, c);
yading@10:         }
yading@10:         if(edges&4){//last block on the row?
yading@10:             memset(dst+area5,c,8);//set with last pixel fr
yading@10:             memcpy(dst+area4, ptr, 8);
yading@10:         }else{
yading@10:             memcpy(dst+area4, ptr, 16);//both area4 and 5
yading@10:         }
yading@10:         memcpy(dst+area6, ptr-linesize, 8);//area6 always present in the above block
yading@10:     }
yading@10:     //now calculate the stuff we need
yading@10:     if(edges&3){//mb_x==0 || mb_y==0){
yading@10:         int avg=(sum+4)>>3;
yading@10:         if(edges&1){ //(mb_x==0) {//implies mb_y!=0
yading@10:             memset(dst+area1,avg,8+8+1);//areas 1,2 and 3 are averaged
yading@10:         }else{//implies y==0 x!=0
yading@10:             memset(dst+area3,avg, 1+16+8);//areas 3, 4,5,6
yading@10:         }
yading@10:         sum+=avg*9;
yading@10:     }else{
yading@10:         uint8_t c=*(src-1-linesize);//the edge pixel, in the top line and left column
yading@10:         dst[area3]=c;
yading@10:         sum+=c;
yading@10:         //edge pixel is not part of min/max
yading@10:     }
yading@10:     (*range) = max_pix - min_pix;
yading@10:     sum += *(dst+area5) + *(dst+area5+1);
yading@10:     *psum = sum;
yading@10: }
yading@10: 
yading@10: 
yading@10: static const uint16_t zero_prediction_weights[64*2] = {
yading@10:     640,  640,  669,  480,  708,  354,  748, 257,  792, 198,  760, 143,  808, 101,  772,  72,
yading@10:     480,  669,  537,  537,  598,  416,  661, 316,  719, 250,  707, 185,  768, 134,  745,  97,
yading@10:     354,  708,  416,  598,  488,  488,  564, 388,  634, 317,  642, 241,  716, 179,  706, 132,
yading@10:     257,  748,  316,  661,  388,  564,  469, 469,  543, 395,  571, 311,  655, 238,  660, 180,
yading@10:     198,  792,  250,  719,  317,  634,  395, 543,  469, 469,  507, 380,  597, 299,  616, 231,
yading@10:     161,  855,  206,  788,  266,  710,  340, 623,  411, 548,  455, 455,  548, 366,  576, 288,
yading@10:     122,  972,  159,  914,  211,  842,  276, 758,  341, 682,  389, 584,  483, 483,  520, 390,
yading@10:     110, 1172,  144, 1107,  193, 1028,  254, 932,  317, 846,  366, 731,  458, 611,  499, 499
yading@10: };
yading@10: 
yading@10: static void spatial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int i,j;
yading@10:     int x,y;
yading@10:     unsigned int p;//power divided by 2
yading@10:     int a;
yading@10:     uint16_t left_sum[2][8] = { { 0 } };
yading@10:     uint16_t  top_sum[2][8] = { { 0 } };
yading@10: 
yading@10:     for(i=0;i<8;i++){
yading@10:         a=src[area2+7-i]<<4;
yading@10:         for(j=0;j<8;j++){
yading@10:             p=abs(i-j);
yading@10:             left_sum[p&1][j]+= a>>(p>>1);
yading@10:         }
yading@10:     }
yading@10: 
yading@10:     for(i=0;i<8;i++){
yading@10:         a=src[area4+i]<<4;
yading@10:         for(j=0;j<8;j++){
yading@10:             p=abs(i-j);
yading@10:             top_sum[p&1][j]+=   a>>(p>>1);
yading@10:         }
yading@10:     }
yading@10:     for(;i<10;i++){
yading@10:         a=src[area4+i]<<4;
yading@10:         for(j=5;j<8;j++){
yading@10:             p=abs(i-j);
yading@10:             top_sum[p&1][j]+=   a>>(p>>1);
yading@10:         }
yading@10:     }
yading@10:     for(;i<12;i++){
yading@10:         a=src[area4+i]<<4;
yading@10:         for(j=7;j<8;j++){
yading@10:             p=abs(i-j);
yading@10:             top_sum[p&1][j]+=   a>>(p>>1);
yading@10:         }
yading@10:     }
yading@10: 
yading@10:     for(i=0;i<8;i++){
yading@10:         top_sum [0][i]+=(top_sum [1][i]*181 + 128 )>>8;//181 is sqrt(2)/2
yading@10:         left_sum[0][i]+=(left_sum[1][i]*181 + 128 )>>8;
yading@10:     }
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x] = (
yading@10:                       (uint32_t)top_sum [0][x]*zero_prediction_weights[y*16+x*2+0] +
yading@10:                       (uint32_t)left_sum[0][y]*zero_prediction_weights[y*16+x*2+1] +
yading@10:                        0x8000
yading@10:                       )>>16;
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_1(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=src[area4 + FFMIN(2*y+x+2, 15) ];
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_2(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=src[area4 +1+y+x];
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_3(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=src[area4 +((y+1)>>1)+x];
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_4(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=( src[area4+x] + src[area6+x] + 1 )>>1;
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_5(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             if(2*x-y<0){
yading@10:                 dst[x]=src[area2+9+2*x-y];
yading@10:             }else{
yading@10:                 dst[x]=src[area4 +x-((y+1)>>1)];
yading@10:             }
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_6(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=src[area3+x-y];
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_7(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             if(x-2*y>0){
yading@10:                 dst[x]=( src[area3-1+x-2*y] + src[area3+x-2*y] + 1)>>1;
yading@10:             }else{
yading@10:                 dst[x]=src[area2+8-y +(x>>1)];
yading@10:             }
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_8(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=( src[area1+7-y] + src[area2+7-y] + 1 )>>1;
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_9(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=src[area2+6-FFMIN(x+y,6)];
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_10(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=(src[area2+7-y]*(8-x)+src[area4+x]*x+4)>>3;
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: static void spatial_compensation_11(uint8_t *src , uint8_t *dst, int linesize){
yading@10:     int x,y;
yading@10: 
yading@10:     for(y=0;y<8;y++){
yading@10:         for(x=0;x<8;x++){
yading@10:             dst[x]=(src[area2+7-y]*y+src[area4+x]*(8-y)+4)>>3;
yading@10:         }
yading@10:         dst+=linesize;
yading@10:     }
yading@10: }
yading@10: 
yading@10: static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride, int quant){
yading@10:     int i,t;
yading@10:     int p0,p1,p2,p3,p4,p5,p6,p7,p8,p9;
yading@10:     int ql=(quant+10)>>3;
yading@10: 
yading@10:     for(i=0; i<8; i++,ptr+=b_stride){
yading@10:         p0=ptr[-5*a_stride];
yading@10:         p1=ptr[-4*a_stride];
yading@10:         p2=ptr[-3*a_stride];
yading@10:         p3=ptr[-2*a_stride];
yading@10:         p4=ptr[-1*a_stride];
yading@10:         p5=ptr[ 0         ];
yading@10:         p6=ptr[ 1*a_stride];
yading@10:         p7=ptr[ 2*a_stride];
yading@10:         p8=ptr[ 3*a_stride];
yading@10:         p9=ptr[ 4*a_stride];
yading@10: 
yading@10:         t=
yading@10:             (FFABS(p1-p2) <= ql) +
yading@10:             (FFABS(p2-p3) <= ql) +
yading@10:             (FFABS(p3-p4) <= ql) +
yading@10:             (FFABS(p4-p5) <= ql);
yading@10:         if(t>0){//You need at least 1 to be able to reach a total score of 6.
yading@10:             t+=
yading@10:                 (FFABS(p5-p6) <= ql) +
yading@10:                 (FFABS(p6-p7) <= ql) +
yading@10:                 (FFABS(p7-p8) <= ql) +
yading@10:                 (FFABS(p8-p9) <= ql) +
yading@10:                 (FFABS(p0-p1) <= ql);
yading@10:             if(t>=6){
yading@10:                 int min,max;
yading@10: 
yading@10:                 min=max=p1;
yading@10:                 min=FFMIN(min,p3); max=FFMAX(max,p3);
yading@10:                 min=FFMIN(min,p5); max=FFMAX(max,p5);
yading@10:                 min=FFMIN(min,p8); max=FFMAX(max,p8);
yading@10:                 if(max-min<2*quant){//early stop
yading@10:                     min=FFMIN(min,p2); max=FFMAX(max,p2);
yading@10:                     min=FFMIN(min,p4); max=FFMAX(max,p4);
yading@10:                     min=FFMIN(min,p6); max=FFMAX(max,p6);
yading@10:                     min=FFMIN(min,p7); max=FFMAX(max,p7);
yading@10:                     if(max-min<2*quant){
yading@10:                         ptr[-2*a_stride]=(4*p2 + 3*p3 + 1*p7 + 4)>>3;
yading@10:                         ptr[-1*a_stride]=(3*p2 + 3*p4 + 2*p7 + 4)>>3;
yading@10:                         ptr[ 0         ]=(2*p2 + 3*p5 + 3*p7 + 4)>>3;
yading@10:                         ptr[ 1*a_stride]=(1*p2 + 3*p6 + 4*p7 + 4)>>3;
yading@10:                         continue;
yading@10:                     };
yading@10:                 }
yading@10:             }
yading@10:         }
yading@10:         {
yading@10:             int x,x0,x1,x2;
yading@10:             int m;
yading@10: 
yading@10:             x0 =   (2*p3 - 5*p4 + 5*p5 - 2*p6 + 4)>>3;
yading@10:             if(FFABS(x0) < quant){
yading@10:                 x1=(2*p1 - 5*p2 + 5*p3 - 2*p4 + 4)>>3;
yading@10:                 x2=(2*p5 - 5*p6 + 5*p7 - 2*p8 + 4)>>3;
yading@10: 
yading@10:                 x=FFABS(x0) - FFMIN( FFABS(x1), FFABS(x2) );
yading@10:                 m=p4-p5;
yading@10: 
yading@10:                 if( x > 0 && (m^x0) <0){
yading@10:                     int32_t sign;
yading@10: 
yading@10:                     sign=m>>31;
yading@10:                     m=(m^sign)-sign;//abs(m)
yading@10:                     m>>=1;
yading@10: 
yading@10:                     x=(5*x)>>3;
yading@10: 
yading@10:                     if(x>m) x=m;
yading@10: 
yading@10:                     x=(x^sign)-sign;
yading@10: 
yading@10:                     ptr[-1*a_stride] -= x;
yading@10:                     ptr[ 0]          += x;
yading@10:                 }
yading@10:             }
yading@10:         }
yading@10:     }
yading@10: }
yading@10: 
yading@10: static void x8_h_loop_filter(uint8_t *src, int stride, int qscale){
yading@10:     x8_loop_filter(src, stride, 1, qscale);
yading@10: }
yading@10: 
yading@10: static void x8_v_loop_filter(uint8_t *src, int stride, int qscale){
yading@10:     x8_loop_filter(src, 1, stride, qscale);
yading@10: }
yading@10: 
yading@10: av_cold void ff_intrax8dsp_init(IntraX8DSPContext *dsp)
yading@10: {
yading@10:     dsp->h_loop_filter=x8_h_loop_filter;
yading@10:     dsp->v_loop_filter=x8_v_loop_filter;
yading@10:     dsp->setup_spatial_compensation=x8_setup_spatial_compensation;
yading@10:     dsp->spatial_compensation[0]=spatial_compensation_0;
yading@10:     dsp->spatial_compensation[1]=spatial_compensation_1;
yading@10:     dsp->spatial_compensation[2]=spatial_compensation_2;
yading@10:     dsp->spatial_compensation[3]=spatial_compensation_3;
yading@10:     dsp->spatial_compensation[4]=spatial_compensation_4;
yading@10:     dsp->spatial_compensation[5]=spatial_compensation_5;
yading@10:     dsp->spatial_compensation[6]=spatial_compensation_6;
yading@10:     dsp->spatial_compensation[7]=spatial_compensation_7;
yading@10:     dsp->spatial_compensation[8]=spatial_compensation_8;
yading@10:     dsp->spatial_compensation[9]=spatial_compensation_9;
yading@10:     dsp->spatial_compensation[10]=spatial_compensation_10;
yading@10:     dsp->spatial_compensation[11]=spatial_compensation_11;
yading@10: }