git.sesse.net Git - ffmpeg/blob - libavcodec/intrax8dsp.c

   1 /*
   2  * This file is part of Libav.
   3  *
   4  * Libav is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * Libav is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with Libav; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 /**
  20 * @file
  21  *@brief IntraX8 frame subdecoder image manipulation routines
  22  */
  23
  24 #include "intrax8dsp.h"
  25 #include "libavutil/common.h"
  26
  27 /*
  28 area positions, #3 is 1 pixel only, other are 8 pixels
  29    |66666666|
  30   3|44444444|55555555|
  31 - -+--------+--------+
  32 1 2|XXXXXXXX|
  33 1 2|XXXXXXXX|
  34 1 2|XXXXXXXX|
  35 1 2|XXXXXXXX|
  36 1 2|XXXXXXXX|
  37 1 2|XXXXXXXX|
  38 1 2|XXXXXXXX|
  39 1 2|XXXXXXXX|
  40 ^-start
  41 */
  42
  43 #define area1 (0)
  44 #define area2 (8)
  45 #define area3 (8+8)
  46 #define area4 (8+8+1)
  47 #define area5 (8+8+1+8)
  48 #define area6 (8+8+1+16)
  49
  50 /**
  51  Collect statistics and prepare the edge pixels required by the other spatial compensation functions.
  52
  53  * @param src pointer to the beginning of the processed block
  54  * @param dst pointer to emu_edge, edge pixels are stored the way other compensation routines do.
  55  * @param linesize byte offset between 2 vertical pixels in the source image
  56  * @param range pointer to the variable where the edge pixel range is to be stored (max-min values)
  57  * @param psum  pointer to the variable where the edge pixel sum is to be stored
  58  * @param edges Informs this routine that the block is on an image border, so it has to interpolate the missing edge pixels.
  59                 and some of the edge pixels should be interpolated, the flag has the following meaning:
  60                 1   - mb_x==0 - first block in the row, interpolate area #1,#2,#3;
  61                 2   - mb_y==0 - first row, interpolate area #3,#4,#5,#6;
  62         note:   1|2 - mb_x==mb_y==0 - first block, use 0x80 value for all areas;
  63                 4   - mb_x>= (mb_width-1) last block in the row, interpolate area #5;
  64 */
  65 static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, int linesize,
  66            int * range, int * psum,  int edges){
  67     uint8_t * ptr;
  68     int sum;
  69     int i;
  70     int min_pix,max_pix;
  71     uint8_t c;
  72
  73     if((edges&3)==3){
  74         *psum=0x80*(8+1+8+2);
  75         *range=0;
  76         memset(dst,0x80,16+1+16+8);
  77         //this triggers flat_dc for sure.
  78         //flat_dc avoids all (other) prediction modes, but requires dc_level decoding.
  79         return;
  80     }
  81
  82     min_pix=256;
  83     max_pix=-1;
  84
  85     sum=0;
  86
  87     if(!(edges&1)){//(mb_x!=0)//there is previous block on this row
  88         ptr=src-1;//left column, area 2
  89         for(i=7;i>=0;i--){
  90             c=*(ptr-1);//area1, same mb as area2, no need to check
  91             dst[area1+i]=c;
  92             c=*(ptr);
  93
  94             sum+=c;
  95             min_pix=FFMIN(min_pix,c);
  96             max_pix=FFMAX(max_pix,c);
  97             dst[area2+i]=c;
  98
  99             ptr+=linesize;
 100         }
 101     }
 102
 103     if(!(edges&2)){  //(mb_y!=0)//there is row above
 104         ptr=src-linesize;//top line
 105         for(i=0;i<8;i++){
 106             c=*(ptr+i);
 107             sum+=c;
 108             min_pix=FFMIN(min_pix, c);
 109             max_pix=FFMAX(max_pix, c);
 110         }
 111         if(edges&4){//last block on the row?
 112             memset(dst+area5,c,8);//set with last pixel fr
 113             memcpy(dst+area4, ptr, 8);
 114         }else{
 115             memcpy(dst+area4, ptr, 16);//both area4 and 5
 116         }
 117         memcpy(dst+area6, ptr-linesize, 8);//area6 always present in the above block
 118     }
 119     //now calculate the stuff we need
 120     if(edges&3){//mb_x==0 || mb_y==0){
 121         int avg=(sum+4)>>3;
 122         if(edges&1){ //(mb_x==0) {//implies mb_y!=0
 123             memset(dst+area1,avg,8+8+1);//areas 1,2 and 3 are averaged
 124         }else{//implies y==0 x!=0
 125             memset(dst+area3,avg, 1+16+8);//areas 3, 4,5,6
 126         }
 127         sum+=avg*9;
 128     }else{
 129         uint8_t c=*(src-1-linesize);//the edge pixel, in the top line and left column
 130         dst[area3]=c;
 131         sum+=c;
 132         //edge pixel is not part of min/max
 133     }
 134     (*range) = max_pix - min_pix;
 135     sum += *(dst+area5) + *(dst+area5+1);
 136     *psum = sum;
 137 }
 138
 139
 140 static const uint16_t zero_prediction_weights[64*2] = {
 141     640,  640,  669,  480,  708,  354,  748, 257,  792, 198,  760, 143,  808, 101,  772,  72,
 142     480,  669,  537,  537,  598,  416,  661, 316,  719, 250,  707, 185,  768, 134,  745,  97,
 143     354,  708,  416,  598,  488,  488,  564, 388,  634, 317,  642, 241,  716, 179,  706, 132,
 144     257,  748,  316,  661,  388,  564,  469, 469,  543, 395,  571, 311,  655, 238,  660, 180,
 145     198,  792,  250,  719,  317,  634,  395, 543,  469, 469,  507, 380,  597, 299,  616, 231,
 146     161,  855,  206,  788,  266,  710,  340, 623,  411, 548,  455, 455,  548, 366,  576, 288,
 147     122,  972,  159,  914,  211,  842,  276, 758,  341, 682,  389, 584,  483, 483,  520, 390,
 148     110, 1172,  144, 1107,  193, 1028,  254, 932,  317, 846,  366, 731,  458, 611,  499, 499
 149 };
 150
 151 static void spatial_compensation_0(uint8_t *src , uint8_t *dst, int linesize){
 152     int i,j;
 153     int x,y;
 154     unsigned int p;//power divided by 2
 155     int a;
 156     uint16_t left_sum[2][8] = { { 0 } };
 157     uint16_t  top_sum[2][8] = { { 0 } };
 158
 159     for(i=0;i<8;i++){
 160         a=src[area2+7-i]<<4;
 161         for(j=0;j<8;j++){
 162             p=abs(i-j);
 163             left_sum[p&1][j]+= a>>(p>>1);
 164         }
 165     }
 166
 167     for(i=0;i<8;i++){
 168         a=src[area4+i]<<4;
 169         for(j=0;j<8;j++){
 170             p=abs(i-j);
 171             top_sum[p&1][j]+=   a>>(p>>1);
 172         }
 173     }
 174     for(;i<10;i++){
 175         a=src[area4+i]<<4;
 176         for(j=5;j<8;j++){
 177             p=abs(i-j);
 178             top_sum[p&1][j]+=   a>>(p>>1);
 179         }
 180     }
 181     for(;i<12;i++){
 182         a=src[area4+i]<<4;
 183         for(j=7;j<8;j++){
 184             p=abs(i-j);
 185             top_sum[p&1][j]+=   a>>(p>>1);
 186         }
 187     }
 188
 189     for(i=0;i<8;i++){
 190         top_sum [0][i]+=(top_sum [1][i]*181 + 128 )>>8;//181 is sqrt(2)/2
 191         left_sum[0][i]+=(left_sum[1][i]*181 + 128 )>>8;
 192     }
 193     for(y=0;y<8;y++){
 194         for(x=0;x<8;x++){
 195             dst[x] = (
 196                       (uint32_t)top_sum [0][x]*zero_prediction_weights[y*16+x*2+0] +
 197                       (uint32_t)left_sum[0][y]*zero_prediction_weights[y*16+x*2+1] +
 198                        0x8000
 199                       )>>16;
 200         }
 201         dst+=linesize;
 202     }
 203 }
 204 static void spatial_compensation_1(uint8_t *src , uint8_t *dst, int linesize){
 205     int x,y;
 206
 207     for(y=0;y<8;y++){
 208         for(x=0;x<8;x++){
 209             dst[x]=src[area4 + FFMIN(2*y+x+2, 15) ];
 210         }
 211         dst+=linesize;
 212     }
 213 }
 214 static void spatial_compensation_2(uint8_t *src , uint8_t *dst, int linesize){
 215     int x,y;
 216
 217     for(y=0;y<8;y++){
 218         for(x=0;x<8;x++){
 219             dst[x]=src[area4 +1+y+x];
 220         }
 221         dst+=linesize;
 222     }
 223 }
 224 static void spatial_compensation_3(uint8_t *src , uint8_t *dst, int linesize){
 225     int x,y;
 226
 227     for(y=0;y<8;y++){
 228         for(x=0;x<8;x++){
 229             dst[x]=src[area4 +((y+1)>>1)+x];
 230         }
 231         dst+=linesize;
 232     }
 233 }
 234 static void spatial_compensation_4(uint8_t *src , uint8_t *dst, int linesize){
 235     int x,y;
 236
 237     for(y=0;y<8;y++){
 238         for(x=0;x<8;x++){
 239             dst[x]=( src[area4+x] + src[area6+x] + 1 )>>1;
 240         }
 241         dst+=linesize;
 242     }
 243 }
 244 static void spatial_compensation_5(uint8_t *src , uint8_t *dst, int linesize){
 245     int x,y;
 246
 247     for(y=0;y<8;y++){
 248         for(x=0;x<8;x++){
 249             if(2*x-y<0){
 250                 dst[x]=src[area2+9+2*x-y];
 251             }else{
 252                 dst[x]=src[area4 +x-((y+1)>>1)];
 253             }
 254         }
 255         dst+=linesize;
 256     }
 257 }
 258 static void spatial_compensation_6(uint8_t *src , uint8_t *dst, int linesize){
 259     int x,y;
 260
 261     for(y=0;y<8;y++){
 262         for(x=0;x<8;x++){
 263             dst[x]=src[area3+x-y];
 264         }
 265         dst+=linesize;
 266     }
 267 }
 268 static void spatial_compensation_7(uint8_t *src , uint8_t *dst, int linesize){
 269     int x,y;
 270
 271     for(y=0;y<8;y++){
 272         for(x=0;x<8;x++){
 273             if(x-2*y>0){
 274                 dst[x]=( src[area3-1+x-2*y] + src[area3+x-2*y] + 1)>>1;
 275             }else{
 276                 dst[x]=src[area2+8-y +(x>>1)];
 277             }
 278         }
 279         dst+=linesize;
 280     }
 281 }
 282 static void spatial_compensation_8(uint8_t *src , uint8_t *dst, int linesize){
 283     int x,y;
 284
 285     for(y=0;y<8;y++){
 286         for(x=0;x<8;x++){
 287             dst[x]=( src[area1+7-y] + src[area2+7-y] + 1 )>>1;
 288         }
 289         dst+=linesize;
 290     }
 291 }
 292 static void spatial_compensation_9(uint8_t *src , uint8_t *dst, int linesize){
 293     int x,y;
 294
 295     for(y=0;y<8;y++){
 296         for(x=0;x<8;x++){
 297             dst[x]=src[area2+6-FFMIN(x+y,6)];
 298         }
 299         dst+=linesize;
 300     }
 301 }
 302 static void spatial_compensation_10(uint8_t *src , uint8_t *dst, int linesize){
 303     int x,y;
 304
 305     for(y=0;y<8;y++){
 306         for(x=0;x<8;x++){
 307             dst[x]=(src[area2+7-y]*(8-x)+src[area4+x]*x+4)>>3;
 308         }
 309         dst+=linesize;
 310     }
 311 }
 312 static void spatial_compensation_11(uint8_t *src , uint8_t *dst, int linesize){
 313     int x,y;
 314
 315     for(y=0;y<8;y++){
 316         for(x=0;x<8;x++){
 317             dst[x]=(src[area2+7-y]*y+src[area4+x]*(8-y)+4)>>3;
 318         }
 319         dst+=linesize;
 320     }
 321 }
 322
 323 static void x8_loop_filter(uint8_t * ptr, const int a_stride, const int b_stride, int quant){
 324     int i,t;
 325     int p0,p1,p2,p3,p4,p5,p6,p7,p8,p9;
 326     int ql=(quant+10)>>3;
 327
 328     for(i=0; i<8; i++,ptr+=b_stride){
 329         p0=ptr[-5*a_stride];
 330         p1=ptr[-4*a_stride];
 331         p2=ptr[-3*a_stride];
 332         p3=ptr[-2*a_stride];
 333         p4=ptr[-1*a_stride];
 334         p5=ptr[ 0         ];
 335         p6=ptr[ 1*a_stride];
 336         p7=ptr[ 2*a_stride];
 337         p8=ptr[ 3*a_stride];
 338         p9=ptr[ 4*a_stride];
 339
 340         t=
 341             (FFABS(p1-p2) <= ql) +
 342             (FFABS(p2-p3) <= ql) +
 343             (FFABS(p3-p4) <= ql) +
 344             (FFABS(p4-p5) <= ql);
 345         if(t>0){//You need at least 1 to be able to reach a total score of 6.
 346             t+=
 347                 (FFABS(p5-p6) <= ql) +
 348                 (FFABS(p6-p7) <= ql) +
 349                 (FFABS(p7-p8) <= ql) +
 350                 (FFABS(p8-p9) <= ql) +
 351                 (FFABS(p0-p1) <= ql);
 352             if(t>=6){
 353                 int min,max;
 354
 355                 min=max=p1;
 356                 min=FFMIN(min,p3); max=FFMAX(max,p3);
 357                 min=FFMIN(min,p5); max=FFMAX(max,p5);
 358                 min=FFMIN(min,p8); max=FFMAX(max,p8);
 359                 if(max-min<2*quant){//early stop
 360                     min=FFMIN(min,p2); max=FFMAX(max,p2);
 361                     min=FFMIN(min,p4); max=FFMAX(max,p4);
 362                     min=FFMIN(min,p6); max=FFMAX(max,p6);
 363                     min=FFMIN(min,p7); max=FFMAX(max,p7);
 364                     if(max-min<2*quant){
 365                         ptr[-2*a_stride]=(4*p2 + 3*p3 + 1*p7 + 4)>>3;
 366                         ptr[-1*a_stride]=(3*p2 + 3*p4 + 2*p7 + 4)>>3;
 367                         ptr[ 0         ]=(2*p2 + 3*p5 + 3*p7 + 4)>>3;
 368                         ptr[ 1*a_stride]=(1*p2 + 3*p6 + 4*p7 + 4)>>3;
 369                         continue;
 370                     };
 371                 }
 372             }
 373         }
 374         {
 375             int x,x0,x1,x2;
 376             int m;
 377
 378             x0 =   (2*p3 - 5*p4 + 5*p5 - 2*p6 + 4)>>3;
 379             if(FFABS(x0) < quant){
 380                 x1=(2*p1 - 5*p2 + 5*p3 - 2*p4 + 4)>>3;
 381                 x2=(2*p5 - 5*p6 + 5*p7 - 2*p8 + 4)>>3;
 382
 383                 x=FFABS(x0) - FFMIN( FFABS(x1), FFABS(x2) );
 384                 m=p4-p5;
 385
 386                 if( x > 0 && (m^x0) <0){
 387                     int32_t sign;
 388
 389                     sign=m>>31;
 390                     m=(m^sign)-sign;//abs(m)
 391                     m>>=1;
 392
 393                     x=(5*x)>>3;
 394
 395                     if(x>m) x=m;
 396
 397                     x=(x^sign)-sign;
 398
 399                     ptr[-1*a_stride] -= x;
 400                     ptr[ 0]          += x;
 401                 }
 402             }
 403         }
 404     }
 405 }
 406
 407 static void x8_h_loop_filter(uint8_t *src, int stride, int qscale){
 408     x8_loop_filter(src, stride, 1, qscale);
 409 }
 410
 411 static void x8_v_loop_filter(uint8_t *src, int stride, int qscale){
 412     x8_loop_filter(src, 1, stride, qscale);
 413 }
 414
 415 av_cold void ff_intrax8dsp_init(IntraX8DSPContext *dsp)
 416 {
 417     dsp->h_loop_filter=x8_h_loop_filter;
 418     dsp->v_loop_filter=x8_v_loop_filter;
 419     dsp->setup_spatial_compensation=x8_setup_spatial_compensation;
 420     dsp->spatial_compensation[0]=spatial_compensation_0;
 421     dsp->spatial_compensation[1]=spatial_compensation_1;
 422     dsp->spatial_compensation[2]=spatial_compensation_2;
 423     dsp->spatial_compensation[3]=spatial_compensation_3;
 424     dsp->spatial_compensation[4]=spatial_compensation_4;
 425     dsp->spatial_compensation[5]=spatial_compensation_5;
 426     dsp->spatial_compensation[6]=spatial_compensation_6;
 427     dsp->spatial_compensation[7]=spatial_compensation_7;
 428     dsp->spatial_compensation[8]=spatial_compensation_8;
 429     dsp->spatial_compensation[9]=spatial_compensation_9;
 430     dsp->spatial_compensation[10]=spatial_compensation_10;
 431     dsp->spatial_compensation[11]=spatial_compensation_11;
 432 }