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

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 (J-Frame) subdecoder, used by WMV2 and VC-1
  22  */
  23
  24 #include "libavutil/avassert.h"
  25 #include "avcodec.h"
  26 #include "get_bits.h"
  27 #include "idctdsp.h"
  28 #include "mpegvideo.h"
  29 #include "msmpeg4data.h"
  30 #include "intrax8huf.h"
  31 #include "intrax8.h"
  32 #include "intrax8dsp.h"
  33
  34 #define MAX_TABLE_DEPTH(table_bits, max_bits) ((max_bits+table_bits-1)/table_bits)
  35
  36 #define DC_VLC_BITS 9
  37 #define AC_VLC_BITS 9
  38 #define OR_VLC_BITS 7
  39
  40 #define DC_VLC_MTD MAX_TABLE_DEPTH(DC_VLC_BITS, MAX_DC_VLC_BITS)
  41 #define AC_VLC_MTD MAX_TABLE_DEPTH(AC_VLC_BITS, MAX_AC_VLC_BITS)
  42 #define OR_VLC_MTD MAX_TABLE_DEPTH(OR_VLC_BITS, MAX_OR_VLC_BITS)
  43
  44 static VLC j_ac_vlc[2][2][8];  //[quant<13],[intra/inter],[select]
  45 static VLC j_dc_vlc[2][8];     //[quant], [select]
  46 static VLC j_orient_vlc[2][4]; //[quant], [select]
  47
  48 static av_cold void x8_vlc_init(void){
  49     int i;
  50     int offset = 0;
  51     int sizeidx = 0;
  52     static const uint16_t sizes[8*4 + 8*2 + 2 + 4] = {
  53         576, 548, 582, 618, 546, 616, 560, 642,
  54         584, 582, 704, 664, 512, 544, 656, 640,
  55         512, 648, 582, 566, 532, 614, 596, 648,
  56         586, 552, 584, 590, 544, 578, 584, 624,
  57
  58         528, 528, 526, 528, 536, 528, 526, 544,
  59         544, 512, 512, 528, 528, 544, 512, 544,
  60
  61         128, 128, 128, 128, 128, 128};
  62
  63     static VLC_TYPE table[28150][2];
  64
  65 #define  init_ac_vlc(dst,src) do { \
  66     dst.table = &table[offset]; \
  67     dst.table_allocated = sizes[sizeidx]; \
  68     offset += sizes[sizeidx++]; \
  69        init_vlc(&dst, \
  70               AC_VLC_BITS,77, \
  71               &src[1],4,2, \
  72               &src[0],4,2, \
  73               INIT_VLC_USE_NEW_STATIC); \
  74     } while(0)
  75 //set ac tables
  76     for(i=0;i<8;i++){
  77         init_ac_vlc( j_ac_vlc[0][0][i], x8_ac0_highquant_table[i][0] );
  78         init_ac_vlc( j_ac_vlc[0][1][i], x8_ac1_highquant_table[i][0] );
  79         init_ac_vlc( j_ac_vlc[1][0][i], x8_ac0_lowquant_table [i][0] );
  80         init_ac_vlc( j_ac_vlc[1][1][i], x8_ac1_lowquant_table [i][0] );
  81     }
  82 #undef init_ac_vlc
  83
  84 //set dc tables
  85 #define init_dc_vlc(dst,src) do { \
  86     dst.table = &table[offset]; \
  87     dst.table_allocated = sizes[sizeidx]; \
  88     offset += sizes[sizeidx++]; \
  89         init_vlc(&dst, \
  90         DC_VLC_BITS,34, \
  91         &src[1],4,2, \
  92         &src[0],4,2, \
  93         INIT_VLC_USE_NEW_STATIC); \
  94     } while(0)
  95     for(i=0;i<8;i++){
  96         init_dc_vlc( j_dc_vlc[0][i], x8_dc_highquant_table[i][0]);
  97         init_dc_vlc( j_dc_vlc[1][i], x8_dc_lowquant_table [i][0]);
  98     }
  99 #undef init_dc_vlc
 100
 101 //set orient tables
 102 #define init_or_vlc(dst,src) do { \
 103     dst.table = &table[offset]; \
 104     dst.table_allocated = sizes[sizeidx]; \
 105     offset += sizes[sizeidx++]; \
 106     init_vlc(&dst, \
 107     OR_VLC_BITS,12, \
 108     &src[1],4,2, \
 109     &src[0],4,2, \
 110     INIT_VLC_USE_NEW_STATIC); \
 111     } while(0)
 112     for(i=0;i<2;i++){
 113         init_or_vlc( j_orient_vlc[0][i], x8_orient_highquant_table[i][0]);
 114     }
 115     for(i=0;i<4;i++){
 116         init_or_vlc( j_orient_vlc[1][i], x8_orient_lowquant_table [i][0]);
 117     }
 118     if (offset != sizeof(table)/sizeof(VLC_TYPE)/2)
 119         av_log(NULL, AV_LOG_ERROR, "table size %i does not match needed %i\n", (int)(sizeof(table)/sizeof(VLC_TYPE)/2), offset);
 120 }
 121 #undef init_or_vlc
 122
 123 static void x8_reset_vlc_tables(IntraX8Context * w){
 124     memset(w->j_dc_vlc,0,sizeof(w->j_dc_vlc));
 125     memset(w->j_ac_vlc,0,sizeof(w->j_ac_vlc));
 126     w->j_orient_vlc=NULL;
 127 }
 128
 129 static inline void x8_select_ac_table(IntraX8Context * const w , int mode){
 130     MpegEncContext * const s= w->s;
 131     int table_index;
 132
 133     av_assert2(mode<4);
 134
 135     if( w->j_ac_vlc[mode] ) return;
 136
 137     table_index = get_bits(&s->gb, 3);
 138     w->j_ac_vlc[mode] = &j_ac_vlc[w->quant<13][mode>>1][table_index];//2 modes use same tables
 139     av_assert2(w->j_ac_vlc[mode]);
 140 }
 141
 142 static inline int x8_get_orient_vlc(IntraX8Context * w){
 143     MpegEncContext * const s= w->s;
 144     int table_index;
 145
 146     if(!w->j_orient_vlc ){
 147         table_index = get_bits(&s->gb, 1+(w->quant<13) );
 148         w->j_orient_vlc = &j_orient_vlc[w->quant<13][table_index];
 149     }
 150
 151     return get_vlc2(&s->gb, w->j_orient_vlc->table, OR_VLC_BITS, OR_VLC_MTD);
 152 }
 153
 154 #define extra_bits(eb) (eb)
 155 #define extra_run   (0xFF<<8)
 156 #define extra_level (0x00<<8)
 157 #define   run_offset(r)    ((r)<<16)
 158 #define level_offset(l)    ((l)<<24)
 159 static const uint32_t ac_decode_table[]={
 160     /*46*/ extra_bits(3) |  extra_run  | run_offset(16) | level_offset( 0),
 161     /*47*/ extra_bits(3) |  extra_run  | run_offset(24) | level_offset( 0),
 162     /*48*/ extra_bits(2) |  extra_run  | run_offset( 4) | level_offset( 1),
 163     /*49*/ extra_bits(3) |  extra_run  | run_offset( 8) | level_offset( 1),
 164
 165     /*50*/ extra_bits(5) |  extra_run  | run_offset(32) | level_offset( 0),
 166     /*51*/ extra_bits(4) |  extra_run  | run_offset(16) | level_offset( 1),
 167
 168     /*52*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
 169     /*53*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 8),
 170     /*54*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset(12),
 171     /*55*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(16),
 172     /*56*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(24),
 173
 174     /*57*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
 175     /*58*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
 176
 177     /*59*/ extra_bits(2) |  extra_run  | run_offset(16) | level_offset( 0),
 178     /*60*/ extra_bits(2) |  extra_run  | run_offset(20) | level_offset( 0),
 179     /*61*/ extra_bits(2) |  extra_run  | run_offset(24) | level_offset( 0),
 180     /*62*/ extra_bits(2) |  extra_run  | run_offset(28) | level_offset( 0),
 181     /*63*/ extra_bits(4) |  extra_run  | run_offset(32) | level_offset( 0),
 182     /*64*/ extra_bits(4) |  extra_run  | run_offset(48) | level_offset( 0),
 183
 184     /*65*/ extra_bits(2) |  extra_run  | run_offset( 4) | level_offset( 1),
 185     /*66*/ extra_bits(3) |  extra_run  | run_offset( 8) | level_offset( 1),
 186     /*67*/ extra_bits(4) |  extra_run  | run_offset(16) | level_offset( 1),
 187
 188     /*68*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
 189     /*69*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset( 8),
 190     /*70*/ extra_bits(4) | extra_level | run_offset( 0) | level_offset(16),
 191
 192     /*71*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
 193     /*72*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
 194 };
 195 //extra_bits = 3bits; extra_run/level = 1 bit; run_offset = 6bits; level_offset = 5 bits;
 196 #undef extra_bits
 197 #undef extra_run
 198 #undef extra_level
 199 #undef run_offset
 200 #undef level_offset
 201
 202 static void x8_get_ac_rlf(IntraX8Context * const w, const int mode,
 203                      int * const run, int * const level, int * const final){
 204     MpegEncContext *  const s= w->s;
 205     int i,e;
 206
 207 //    x8_select_ac_table(w,mode);
 208     i = get_vlc2(&s->gb, w->j_ac_vlc[mode]->table, AC_VLC_BITS, AC_VLC_MTD);
 209
 210     if(i<46){ //[0-45]
 211         int t,l;
 212         if(i<0){
 213             (*level)=(*final)=//prevent 'may be used unilitialized'
 214             (*run)=64;//this would cause error exit in the ac loop
 215             return;
 216         }
 217
 218         (*final) = t = (i>22);
 219         i-=23*t;
 220 /*
 221   i== 0-15 r=0-15 l=0 ;r=i& %01111
 222   i==16-19 r=0-3  l=1 ;r=i& %00011
 223   i==20-21 r=0-1  l=2 ;r=i& %00001
 224   i==22    r=0    l=3 ;r=i& %00000
 225 l=lut_l[i/2]={0,0,0,0,0,0,0,0,1,1,2,3}[i>>1];// 11 10'01 01'00 00'00 00'00 00'00 00 => 0xE50000
 226 t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter */
 227         l=(0xE50000>>(i&(0x1E)))&3;/*0x1E or (~1) or ((i>>1)<<1)*/
 228         t=(0x01030F>>(l<<3));
 229
 230         (*run)   = i&t;
 231         (*level) = l;
 232     }else if(i<73){//[46-72]
 233         uint32_t sm;
 234         uint32_t mask;
 235
 236         i-=46;
 237         sm=ac_decode_table[i];
 238
 239         e=get_bits(&s->gb,sm&0xF);sm>>=8;//3bits
 240         mask=sm&0xff;sm>>=8;             //1bit
 241
 242         (*run)  =(sm&0xff) + (e&( mask));//6bits
 243         (*level)=(sm>>8)   + (e&(~mask));//5bits
 244         (*final)=i>(58-46);
 245     }else if(i<75){//[73-74]
 246         static const uint8_t crazy_mix_runlevel[32]={
 247         0x22,0x32,0x33,0x53,0x23,0x42,0x43,0x63,
 248         0x24,0x52,0x34,0x73,0x25,0x62,0x44,0x83,
 249         0x26,0x72,0x35,0x54,0x27,0x82,0x45,0x64,
 250         0x28,0x92,0x36,0x74,0x29,0xa2,0x46,0x84};
 251
 252         (*final)=!(i&1);
 253         e=get_bits(&s->gb,5);//get the extra bits
 254         (*run)  =crazy_mix_runlevel[e]>>4;
 255         (*level)=crazy_mix_runlevel[e]&0x0F;
 256     }else{
 257         (*level)=get_bits( &s->gb, 7-3*(i&1));
 258         (*run)  =get_bits( &s->gb, 6);
 259         (*final)=get_bits1(&s->gb);
 260     }
 261     return;
 262 }
 263
 264 //static const uint8_t dc_extra_sbits[]   ={0, 1,1, 1,1, 2,2, 3,3,   4,4,   5,5,   6,6,    7,7    };
 265 static const uint8_t dc_index_offset[]  ={ 0, 1,2, 3,4, 5,7, 9,13, 17,25, 33,49, 65,97, 129,193};
 266
 267 static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const level, int * const final){
 268     MpegEncContext * const s= w->s;
 269     int i,e,c;
 270
 271     av_assert2(mode<3);
 272     if( !w->j_dc_vlc[mode] ) {
 273         int table_index;
 274         table_index = get_bits(&s->gb, 3);
 275         //4 modes, same table
 276         w->j_dc_vlc[mode]= &j_dc_vlc[w->quant<13][table_index];
 277     }
 278
 279     i=get_vlc2(&s->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
 280
 281     /*(i>=17) {i-=17;final=1;}*/
 282     c= i>16;
 283     (*final)=c;
 284     i-=17*c;
 285
 286     if(i<=0){
 287         (*level)=0;
 288         return -i;
 289     }
 290     c=(i+1)>>1;//hackish way to calculate dc_extra_sbits[]
 291     c-=c>1;
 292
 293     e=get_bits(&s->gb,c);//get the extra bits
 294     i=dc_index_offset[i]+(e>>1);
 295
 296     e= -(e & 1);//0,0xffffff
 297     (*level)= (i ^ e) - e;// (i^0)-0 , (i^0xff)-(-1)
 298     return 0;
 299 }
 300 //end of huffman
 301
 302 static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma){
 303     MpegEncContext * const s= w->s;
 304     int range;
 305     int sum;
 306     int quant;
 307
 308     w->dsp.setup_spatial_compensation(s->dest[chroma], s->sc.edge_emu_buffer,
 309                                       s->current_picture.f->linesize[chroma>0],
 310                                       &range, &sum, w->edges);
 311     if(chroma){
 312         w->orient=w->chroma_orient;
 313         quant=w->quant_dc_chroma;
 314     }else{
 315         quant=w->quant;
 316     }
 317
 318     w->flat_dc=0;
 319     if(range < quant || range < 3){
 320         w->orient=0;
 321         if(range < 3){//yep you read right, a +-1 idct error may break decoding!
 322             w->flat_dc=1;
 323             sum+=9;
 324             w->predicted_dc = (sum*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899
 325         }
 326     }
 327     if(chroma)
 328         return 0;
 329
 330     av_assert2(w->orient < 3);
 331     if(range < 2*w->quant){
 332         if( (w->edges&3) == 0){
 333             if(w->orient==1) w->orient=11;
 334             if(w->orient==2) w->orient=10;
 335         }else{
 336             w->orient=0;
 337         }
 338         w->raw_orient=0;
 339     }else{
 340         static const uint8_t prediction_table[3][12]={
 341             {0,8,4, 10,11, 2,6,9,1,3,5,7},
 342             {4,0,8, 11,10, 3,5,2,6,9,1,7},
 343             {8,0,4, 10,11, 1,7,2,6,9,3,5}
 344         };
 345         w->raw_orient=x8_get_orient_vlc(w);
 346         if(w->raw_orient<0) return -1;
 347         av_assert2(w->raw_orient < 12 );
 348         av_assert2(w->orient<3);
 349         w->orient=prediction_table[w->orient][w->raw_orient];
 350     }
 351     return 0;
 352 }
 353
 354 static void x8_update_predictions(IntraX8Context * const w, const int orient, const int est_run ){
 355     MpegEncContext * const s= w->s;
 356
 357     w->prediction_table[s->mb_x*2+(s->mb_y&1)] = (est_run<<2) + 1*(orient==4) + 2*(orient==8);
 358 /*
 359   y=2n+0 ->//0 2 4
 360   y=2n+1 ->//1 3 5
 361 */
 362 }
 363 static void x8_get_prediction_chroma(IntraX8Context * const w){
 364     MpegEncContext * const s= w->s;
 365
 366     w->edges = 1*( !(s->mb_x>>1) );
 367     w->edges|= 2*( !(s->mb_y>>1) );
 368     w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );//mb_x for chroma would always be odd
 369
 370     w->raw_orient=0;
 371     if(w->edges&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC
 372         w->chroma_orient=4<<((0xCC>>w->edges)&1);
 373         return;
 374     }
 375     w->chroma_orient = (w->prediction_table[2*s->mb_x-2] & 0x03)<<2;//block[x-1][y|1-1)]
 376 }
 377
 378 static void x8_get_prediction(IntraX8Context * const w){
 379     MpegEncContext * const s= w->s;
 380     int a,b,c,i;
 381
 382     w->edges = 1*( !s->mb_x );
 383     w->edges|= 2*( !s->mb_y );
 384     w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );
 385
 386     switch(w->edges&3){
 387         case 0:
 388             break;
 389         case 1:
 390             //take the one from the above block[0][y-1]
 391             w->est_run = w->prediction_table[!(s->mb_y&1)]>>2;
 392             w->orient  = 1;
 393             return;
 394         case 2:
 395             //take the one from the previous block[x-1][0]
 396             w->est_run = w->prediction_table[2*s->mb_x-2]>>2;
 397             w->orient  = 2;
 398             return;
 399         case 3:
 400             w->est_run = 16;
 401             w->orient  = 0;
 402             return;
 403     }
 404     //no edge cases
 405     b= w->prediction_table[2*s->mb_x   + !(s->mb_y&1) ];//block[x  ][y-1]
 406     a= w->prediction_table[2*s->mb_x-2 +  (s->mb_y&1) ];//block[x-1][y  ]
 407     c= w->prediction_table[2*s->mb_x-2 + !(s->mb_y&1) ];//block[x-1][y-1]
 408
 409     w->est_run = FFMIN(b,a);
 410     /* This condition has nothing to do with w->edges, even if it looks
 411        similar it would trigger if e.g. x=3;y=2;
 412        I guess somebody wrote something wrong and it became standard. */
 413     if( (s->mb_x & s->mb_y) != 0 ) w->est_run=FFMIN(c,w->est_run);
 414     w->est_run>>=2;
 415
 416     a&=3;
 417     b&=3;
 418     c&=3;
 419
 420     i=( 0xFFEAF4C4>>(2*b+8*a) )&3;
 421     if(i!=3) w->orient=i;
 422     else     w->orient=( 0xFFEAD8>>(2*c+8*(w->quant>12)) )&3;
 423 /*
 424 lut1[b][a]={
 425 ->{0, 1, 0, pad},
 426   {0, 1, X, pad},
 427   {2, 2, 2, pad}}
 428    pad 2   2  2; pad X  1  0; pad 0  1  0 <-
 429 -> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4
 430
 431 lut2[q>12][c]={
 432   ->{0,2,1,pad},
 433     {2,2,2,pad}}
 434    pad 2  2  2; pad 1  2  0 <-
 435 -> 11 10'10 10 '11 01'10 00=>0xEAD8
 436 */
 437 }
 438
 439
 440 static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){
 441     MpegEncContext * const s= w->s;
 442     int t;
 443 #define B(x,y)  s->block[0][w->idct_permutation[(x)+(y)*8]]
 444 #define T(x)  ((x) * dc_level + 0x8000) >> 16;
 445     switch(direction){
 446     case 0:
 447         t = T(3811);//h
 448         B(1,0) -= t;
 449         B(0,1) -= t;
 450
 451         t = T(487);//e
 452         B(2,0) -= t;
 453         B(0,2) -= t;
 454
 455         t = T(506);//f
 456         B(3,0) -= t;
 457         B(0,3) -= t;
 458
 459         t = T(135);//c
 460         B(4,0) -= t;
 461         B(0,4) -= t;
 462         B(2,1) += t;
 463         B(1,2) += t;
 464         B(3,1) += t;
 465         B(1,3) += t;
 466
 467         t = T(173);//d
 468         B(5,0) -= t;
 469         B(0,5) -= t;
 470
 471         t = T(61);//b
 472         B(6,0) -= t;
 473         B(0,6) -= t;
 474         B(5,1) += t;
 475         B(1,5) += t;
 476
 477         t = T(42); //a
 478         B(7,0) -= t;
 479         B(0,7) -= t;
 480         B(4,1) += t;
 481         B(1,4) += t;
 482         B(4,4) += t;
 483
 484         t = T(1084);//g
 485         B(1,1) += t;
 486
 487         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
 488         break;
 489     case 1:
 490         B(0,1) -= T(6269);
 491         B(0,3) -= T( 708);
 492         B(0,5) -= T( 172);
 493         B(0,7) -= T(  73);
 494
 495         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
 496         break;
 497     case 2:
 498         B(1,0) -= T(6269);
 499         B(3,0) -= T( 708);
 500         B(5,0) -= T( 172);
 501         B(7,0) -= T(  73);
 502
 503         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7);
 504         break;
 505     }
 506 #undef B
 507 #undef T
 508 }
 509
 510 static void dsp_x8_put_solidcolor(uint8_t const pix, uint8_t * dst, int const linesize){
 511     int k;
 512     for(k=0;k<8;k++){
 513         memset(dst,pix,8);
 514         dst+=linesize;
 515     }
 516 }
 517
 518 static const int16_t quant_table[64] = {
 519     256, 256, 256, 256,  256, 256, 259, 262,
 520     265, 269, 272, 275,  278, 282, 285, 288,
 521     292, 295, 299, 303,  306, 310, 314, 317,
 522     321, 325, 329, 333,  337, 341, 345, 349,
 523     353, 358, 362, 366,  371, 375, 379, 384,
 524     389, 393, 398, 403,  408, 413, 417, 422,
 525     428, 433, 438, 443,  448, 454, 459, 465,
 526     470, 476, 482, 488,  493, 499, 505, 511
 527 };
 528
 529 static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
 530     MpegEncContext * const s= w->s;
 531
 532     uint8_t * scantable;
 533     int final,run,level;
 534     int ac_mode,dc_mode,est_run,dc_level;
 535     int pos,n;
 536     int zeros_only;
 537     int use_quant_matrix;
 538     int sign;
 539
 540     av_assert2(w->orient<12);
 541     s->bdsp.clear_block(s->block[0]);
 542
 543     if(chroma){
 544         dc_mode=2;
 545     }else{
 546         dc_mode=!!w->est_run;//0,1
 547     }
 548
 549     if(x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) return -1;
 550     n=0;
 551     zeros_only=0;
 552     if(!final){//decode ac
 553         use_quant_matrix=w->use_quant_matrix;
 554         if(chroma){
 555             ac_mode = 1;
 556             est_run = 64;//not used
 557         }else{
 558             if (w->raw_orient < 3){
 559                 use_quant_matrix = 0;
 560             }
 561             if(w->raw_orient > 4){
 562                 ac_mode = 0;
 563                 est_run = 64;
 564             }else{
 565                 if(w->est_run > 1){
 566                     ac_mode = 2;
 567                     est_run=w->est_run;
 568                 }else{
 569                     ac_mode = 3;
 570                     est_run = 64;
 571                 }
 572             }
 573         }
 574         x8_select_ac_table(w,ac_mode);
 575         /*scantable_selector[12]={0,2,0,1,1,1,0,2,2,0,1,2};<-
 576         -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 =>0x928548 */
 577         scantable = w->scantable[ (0x928548>>(2*w->orient))&3 ].permutated;
 578         pos=0;
 579         do {
 580             n++;
 581             if( n >= est_run ){
 582                 ac_mode=3;
 583                 x8_select_ac_table(w,3);
 584             }
 585
 586             x8_get_ac_rlf(w,ac_mode,&run,&level,&final);
 587
 588             pos+=run+1;
 589             if(pos>63){
 590                 //this also handles vlc error in x8_get_ac_rlf
 591                 return -1;
 592             }
 593             level= (level+1) * w->dquant;
 594             level+= w->qsum;
 595
 596             sign = - get_bits1(&s->gb);
 597             level = (level ^ sign) - sign;
 598
 599             if(use_quant_matrix){
 600                 level = (level*quant_table[pos])>>8;
 601             }
 602             s->block[0][ scantable[pos] ]=level;
 603         }while(!final);
 604
 605         s->block_last_index[0]=pos;
 606     }else{//DC only
 607         s->block_last_index[0]=0;
 608         if(w->flat_dc && ((unsigned)(dc_level+1)) < 3){//[-1;1]
 609             int32_t divide_quant= !chroma ? w->divide_quant_dc_luma:
 610                                             w->divide_quant_dc_chroma;
 611             int32_t dc_quant    = !chroma ? w->quant:
 612                                             w->quant_dc_chroma;
 613
 614             //original intent dc_level+=predicted_dc/quant; but it got lost somewhere in the rounding
 615             dc_level+= (w->predicted_dc*divide_quant + (1<<12) )>>13;
 616
 617             dsp_x8_put_solidcolor( av_clip_uint8((dc_level*dc_quant+4)>>3),
 618                                    s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
 619
 620             goto block_placed;
 621         }
 622         zeros_only = (dc_level == 0);
 623     }
 624     if(!chroma){
 625         s->block[0][0] = dc_level*w->quant;
 626     }else{
 627         s->block[0][0] = dc_level*w->quant_dc_chroma;
 628     }
 629
 630     //there is !zero_only check in the original, but dc_level check is enough
 631     if( (unsigned int)(dc_level+1) >= 3 && (w->edges&3) != 3 ){
 632         int direction;
 633         /*ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 };<-
 634         -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 =>0x6A017C */
 635         direction= (0x6A017C>>(w->orient*2))&3;
 636         if (direction != 3){
 637             x8_ac_compensation(w, direction, s->block[0][0]);//modify block_last[]
 638         }
 639     }
 640
 641     if(w->flat_dc){
 642         dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
 643     }else{
 644         w->dsp.spatial_compensation[w->orient]( s->sc.edge_emu_buffer,
 645                                             s->dest[chroma],
 646                                             s->current_picture.f->linesize[!!chroma] );
 647     }
 648     if(!zeros_only)
 649         w->wdsp.idct_add(s->dest[chroma],
 650                          s->current_picture.f->linesize[!!chroma],
 651                          s->block[0]);
 652
 653 block_placed:
 654
 655     if(!chroma){
 656         x8_update_predictions(w,w->orient,n);
 657     }
 658
 659     if(s->loop_filter){
 660         uint8_t* ptr = s->dest[chroma];
 661         int linesize = s->current_picture.f->linesize[!!chroma];
 662
 663         if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){
 664             w->dsp.h_loop_filter(ptr, linesize, w->quant);
 665         }
 666         if(!( (w->edges&1) || ( zeros_only && (w->orient|8)==8 ) )){
 667             w->dsp.v_loop_filter(ptr, linesize, w->quant);
 668         }
 669     }
 670     return 0;
 671 }
 672
 673 static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_*
 674 //not s->linesize as this would be wrong for field pics
 675 //not that IntraX8 has interlacing support ;)
 676     const int linesize   = s->current_picture.f->linesize[0];
 677     const int uvlinesize = s->current_picture.f->linesize[1];
 678
 679     s->dest[0] = s->current_picture.f->data[0];
 680     s->dest[1] = s->current_picture.f->data[1];
 681     s->dest[2] = s->current_picture.f->data[2];
 682
 683     s->dest[0] +=   s->mb_y        *   linesize << 3;
 684     s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows
 685     s->dest[2] += ( s->mb_y&(~1) ) * uvlinesize << 2;
 686 }
 687
 688 /**
 689  * Initialize IntraX8 frame decoder.
 690  * Requires valid MpegEncContext with valid s->mb_width before calling.
 691  * @param w pointer to IntraX8Context
 692  * @param s pointer to MpegEncContext of the parent codec
 693  */
 694 av_cold void ff_intrax8_common_init(IntraX8Context * w, MpegEncContext * const s){
 695
 696     w->s=s;
 697     x8_vlc_init();
 698     av_assert0(s->mb_width>0);
 699     w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
 700
 701     ff_wmv2dsp_init(&w->wdsp);
 702     ff_init_scantable_permutation(w->idct_permutation,
 703                                   w->wdsp.idct_perm);
 704
 705     ff_init_scantable(w->idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
 706     ff_init_scantable(w->idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
 707     ff_init_scantable(w->idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
 708
 709     ff_intrax8dsp_init(&w->dsp);
 710 }
 711
 712 /**
 713  * Destroy IntraX8 frame structure.
 714  * @param w pointer to IntraX8Context
 715  */
 716 av_cold void ff_intrax8_common_end(IntraX8Context * w)
 717 {
 718     av_freep(&w->prediction_table);
 719 }
 720
 721 /**
 722  * Decode single IntraX8 frame.
 723  * The parent codec must fill s->loopfilter and s->gb (bitstream).
 724  * The parent codec must call ff_mpv_frame_start() before calling this function.
 725  * The parent codec must call ff_mpv_frame_end() after calling this function.
 726  * This function does not use ff_mpv_decode_mb().
 727  * lowres decoding is theoretically impossible.
 728  * @param w pointer to IntraX8Context
 729  * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
 730  * @param quant_offset offset away from zero
 731  */
 732 int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_offset){
 733     MpegEncContext * const s= w->s;
 734     int mb_xy;
 735     w->use_quant_matrix = get_bits1(&s->gb);
 736
 737     w->dquant = dquant;
 738     w->quant  = dquant >> 1;
 739     w->qsum   = quant_offset;
 740
 741     w->divide_quant_dc_luma = ((1<<16) + (w->quant>>1)) / w->quant;
 742     if(w->quant < 5){
 743         w->quant_dc_chroma =  w->quant;
 744         w->divide_quant_dc_chroma = w->divide_quant_dc_luma;
 745     }else{
 746         w->quant_dc_chroma =  w->quant+((w->quant+3)>>3);
 747         w->divide_quant_dc_chroma = ((1<<16) + (w->quant_dc_chroma>>1)) / w->quant_dc_chroma;
 748     }
 749     x8_reset_vlc_tables(w);
 750
 751
 752     for(s->mb_y=0; s->mb_y < s->mb_height*2; s->mb_y++){
 753         x8_init_block_index(s);
 754         mb_xy=(s->mb_y>>1)*s->mb_stride;
 755
 756         for(s->mb_x=0; s->mb_x < s->mb_width*2; s->mb_x++){
 757             x8_get_prediction(w);
 758             if(x8_setup_spatial_predictor(w,0)) goto error;
 759             if(x8_decode_intra_mb(w,0)) goto error;
 760
 761             if( s->mb_x & s->mb_y & 1 ){
 762                 x8_get_prediction_chroma(w);
 763
 764                 /*when setting up chroma, no vlc is read,
 765                 so no error condition can be reached*/
 766                 x8_setup_spatial_predictor(w,1);
 767                 if(x8_decode_intra_mb(w,1)) goto error;
 768
 769                 x8_setup_spatial_predictor(w,2);
 770                 if(x8_decode_intra_mb(w,2)) goto error;
 771
 772                 s->dest[1]+= 8;
 773                 s->dest[2]+= 8;
 774
 775                 /*emulate MB info in the relevant tables*/
 776                 s->mbskip_table [mb_xy]=0;
 777                 s->mbintra_table[mb_xy]=1;
 778                 s->current_picture.qscale_table[mb_xy] = w->quant;
 779                 mb_xy++;
 780             }
 781             s->dest[0]+= 8;
 782         }
 783         if(s->mb_y&1){
 784             ff_mpeg_draw_horiz_band(s, (s->mb_y-1)*8, 16);
 785         }
 786     }
 787
 788 error:
 789     return 0;
 790 }