Merge commit '2ade1cdafb96bf47e77f7ed74731d78a30aae950'
authorDerek Buitenhuis <derek.buitenhuis@gmail.com>
Sun, 17 Apr 2016 18:21:37 +0000 (19:21 +0100)
committerDerek Buitenhuis <derek.buitenhuis@gmail.com>
Sun, 17 Apr 2016 18:27:53 +0000 (19:27 +0100)
* commit '2ade1cdafb96bf47e77f7ed74731d78a30aae950':
  intrax8: K&R formatting cosmetics

Merged-by: Derek Buitenhuis <derek.buitenhuis@gmail.com>
1  2 
libavcodec/intrax8.c
libavcodec/intrax8.h
libavcodec/intrax8dsp.c
libavcodec/intrax8dsp.h
libavcodec/intrax8huf.h

@@@ -119,35 -118,41 +119,41 @@@ static av_cold void x8_vlc_init(void
          av_log(NULL, AV_LOG_ERROR, "table size %zd does not match needed %i\n",
                 sizeof(table) / sizeof(VLC_TYPE) / 2, offset);
  }
- #undef init_or_vlc
  
- static void x8_reset_vlc_tables(IntraX8Context * w){
-     memset(w->j_dc_vlc,0,sizeof(w->j_dc_vlc));
-     memset(w->j_ac_vlc,0,sizeof(w->j_ac_vlc));
-     w->j_orient_vlc=NULL;
+ static void x8_reset_vlc_tables(IntraX8Context *w)
+ {
+     memset(w->j_dc_vlc, 0, sizeof(w->j_dc_vlc));
+     memset(w->j_ac_vlc, 0, sizeof(w->j_ac_vlc));
+     w->j_orient_vlc = NULL;
  }
  
- static inline void x8_select_ac_table(IntraX8Context * const w , int mode){
-     MpegEncContext * const s= w->s;
+ static inline void x8_select_ac_table(IntraX8Context *const w, int mode)
+ {
+     MpegEncContext *const s = w->s;
      int table_index;
  
-     av_assert2(mode<4);
 -    assert(mode < 4);
++    av_assert2(mode < 4);
  
-     if( w->j_ac_vlc[mode] ) return;
+     if (w->j_ac_vlc[mode])
+         return;
+     table_index       = get_bits(&s->gb, 3);
+     // 2 modes use same tables
+     w->j_ac_vlc[mode] = &j_ac_vlc[w->quant < 13][mode >> 1][table_index];
  
 -    assert(w->j_ac_vlc[mode]);
 +    table_index = get_bits(&s->gb, 3);
 +    w->j_ac_vlc[mode] = &j_ac_vlc[w->quant<13][mode>>1][table_index];//2 modes use same tables
 +    av_assert2(w->j_ac_vlc[mode]);
  }
  
- static inline int x8_get_orient_vlc(IntraX8Context * w){
-     MpegEncContext * const s= w->s;
-     int table_index;
+ static inline int x8_get_orient_vlc(IntraX8Context *w)
+ {
+     MpegEncContext *const s = w->s;
  
-     if(!w->j_orient_vlc ){
-         table_index = get_bits(&s->gb, 1+(w->quant<13) );
-         w->j_orient_vlc = &j_orient_vlc[w->quant<13][table_index];
+     if (!w->j_orient_vlc) {
+         int table_index = get_bits(&s->gb, 1 + (w->quant < 13));
+         w->j_orient_vlc = &j_orient_vlc[w->quant < 13][table_index];
      }
 -    assert(w->j_orient_vlc);
 -    assert(w->j_orient_vlc->table);
  
      return get_vlc2(&s->gb, w->j_orient_vlc->table, OR_VLC_BITS, OR_VLC_MTD);
  }
@@@ -261,244 -278,275 +279,273 @@@ static void x8_get_ac_rlf(IntraX8Contex
      return;
  }
  
- //static const uint8_t dc_extra_sbits[]   ={0, 1,1, 1,1, 2,2, 3,3,   4,4,   5,5,   6,6,    7,7    };
- static const uint8_t dc_index_offset[]  ={ 0, 1,2, 3,4, 5,7, 9,13, 17,25, 33,49, 65,97, 129,193};
- static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const level, int * const final){
-     MpegEncContext * const s= w->s;
    int i,e,c;
+ /* static const uint8_t dc_extra_sbits[] = {
+  *     0, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7,
+  * }; */
+ static const uint8_t dc_index_offset[] = {
+     0, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
};
  
-     av_assert2(mode<3);
-     if( !w->j_dc_vlc[mode] ) {
-         int table_index;
-         table_index = get_bits(&s->gb, 3);
-         //4 modes, same table
-         w->j_dc_vlc[mode]= &j_dc_vlc[w->quant<13][table_index];
+ static int x8_get_dc_rlf(IntraX8Context *const w,
+                          int const mode, int *const level, int *const final)
+ {
+     MpegEncContext *const s = w->s;
+     int i, e, c;
 -    assert(mode < 3);
++    av_assert2(mode < 3);
+     if (!w->j_dc_vlc[mode]) {
+         int table_index = get_bits(&s->gb, 3);
+         // 4 modes, same table
+         w->j_dc_vlc[mode] = &j_dc_vlc[w->quant < 13][table_index];
      }
 -    assert(w->j_dc_vlc);
 -    assert(w->j_dc_vlc[mode]->table);
  
-     i=get_vlc2(&s->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
+     i = get_vlc2(&s->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
  
-     /*(i>=17) {i-=17;final=1;}*/
-     c= i>16;
-     (*final)=c;
-     i-=17*c;
+     /* (i >= 17) { i -= 17; final =1; } */
+     c        = i > 16;
+     (*final) = c;
+     i       -= 17 * c;
  
-     if(i<=0){
-         (*level)=0;
+     if (i <= 0) {
+         (*level) = 0;
          return -i;
      }
-     c=(i+1)>>1;//hackish way to calculate dc_extra_sbits[]
-     c-=c>1;
+     c  = (i + 1) >> 1; // hackish way to calculate dc_extra_sbits[]
+     c -= c > 1;
  
-     e=get_bits(&s->gb,c);//get the extra bits
-     i=dc_index_offset[i]+(e>>1);
+     e = get_bits(&s->gb, c); // get the extra bits
+     i = dc_index_offset[i] + (e >> 1);
  
-     e= -(e & 1);//0,0xffffff
-     (*level)= (i ^ e) - e;// (i^0)-0 , (i^0xff)-(-1)
+     e        = -(e & 1); // 0, 0xffffff
+     (*level) = (i ^ e) - e; // (i ^ 0) -0  , (i ^ 0xff) - (-1)
      return 0;
  }
- //end of huffman
  
- static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma){
-     MpegEncContext * const s= w->s;
+ // end of huffman
+ static int x8_setup_spatial_predictor(IntraX8Context *const w, const int chroma)
+ {
+     MpegEncContext *const s = w->s;
      int range;
      int sum;
      int quant;
  
      w->dsp.setup_spatial_compensation(s->dest[chroma], s->sc.edge_emu_buffer,
-                                       s->current_picture.f->linesize[chroma>0],
+                                       s->current_picture.f->linesize[chroma > 0],
                                        &range, &sum, w->edges);
-     if(chroma){
-         w->orient=w->chroma_orient;
-         quant=w->quant_dc_chroma;
-     }else{
-         quant=w->quant;
+     if (chroma) {
+         w->orient = w->chroma_orient;
+         quant     = w->quant_dc_chroma;
+     } else {
+         quant = w->quant;
      }
  
-     w->flat_dc=0;
-     if(range < quant || range < 3){
-         w->orient=0;
-         if(range < 3){//yep you read right, a +-1 idct error may break decoding!
-             w->flat_dc=1;
-             sum+=9;
-             w->predicted_dc = (sum*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899
+     w->flat_dc = 0;
+     if (range < quant || range < 3) {
+         w->orient = 0;
+         // yep you read right, a +-1 idct error may break decoding!
+         if (range < 3) {
+             w->flat_dc      = 1;
+             sum            += 9;
+             // ((1 << 17) + 9) / (8 + 8 + 1 + 2) = 6899
+             w->predicted_dc = (sum * 6899) >> 17;
          }
      }
-     if(chroma)
+     if (chroma)
          return 0;
  
 -    assert(w->orient < 3);
 +    av_assert2(w->orient < 3);
-     if(range < 2*w->quant){
-         if( (w->edges&3) == 0){
-             if(w->orient==1) w->orient=11;
-             if(w->orient==2) w->orient=10;
-         }else{
-             w->orient=0;
+     if (range < 2 * w->quant) {
+         if ((w->edges & 3) == 0) {
+             if (w->orient == 1)
+                 w->orient = 11;
+             if (w->orient == 2)
+                 w->orient = 10;
+         } else {
+             w->orient = 0;
          }
-         w->raw_orient=0;
-     }else{
-         static const uint8_t prediction_table[3][12]={
-             {0,8,4, 10,11, 2,6,9,1,3,5,7},
-             {4,0,8, 11,10, 3,5,2,6,9,1,7},
-             {8,0,4, 10,11, 1,7,2,6,9,3,5}
+         w->raw_orient = 0;
+     } else {
+         static const uint8_t prediction_table[3][12] = {
+             { 0, 8, 4, 10, 11, 2, 6, 9, 1, 3, 5, 7 },
+             { 4, 0, 8, 11, 10, 3, 5, 2, 6, 9, 1, 7 },
+             { 8, 0, 4, 10, 11, 1, 7, 2, 6, 9, 3, 5 },
          };
-         w->raw_orient=x8_get_orient_vlc(w);
-         if(w->raw_orient<0) return -1;
-         av_assert2(w->raw_orient < 12 );
-         av_assert2(w->orient<3);
+         w->raw_orient = x8_get_orient_vlc(w);
+         if (w->raw_orient < 0)
+             return -1;
 -        assert(w->raw_orient < 12);
 -        assert(w->orient < 3);
 -        w->orient = prediction_table[w->orient][w->raw_orient];
++        av_assert2(w->raw_orient < 12);
++        av_assert2(w->orient < 3);
 +        w->orient=prediction_table[w->orient][w->raw_orient];
      }
      return 0;
  }
  
- static void x8_update_predictions(IntraX8Context * const w, const int orient, const int est_run ){
-     MpegEncContext * const s= w->s;
+ static void x8_update_predictions(IntraX8Context *const w, const int orient,
+                                   const int est_run)
+ {
+     MpegEncContext *const s = w->s;
  
-     w->prediction_table[s->mb_x*2+(s->mb_y&1)] = (est_run<<2) + 1*(orient==4) + 2*(orient==8);
+     w->prediction_table[s->mb_x * 2 + (s->mb_y & 1)] = (est_run << 2) + 1 * (orient == 4) + 2 * (orient == 8);
  /*
-   y=2n+0 ->//0 2 4
-   y=2n+1 ->//1 3 5
- */
+  * y = 2n + 0 -> // 0 2 4
+  * y = 2n + 1 -> // 1 3 5
 */
  }
- static void x8_get_prediction_chroma(IntraX8Context * const w){
-     MpegEncContext * const s= w->s;
  
-     w->edges = 1*( !(s->mb_x>>1) );
-     w->edges|= 2*( !(s->mb_y>>1) );
-     w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );//mb_x for chroma would always be odd
+ static void x8_get_prediction_chroma(IntraX8Context *const w)
+ {
+     MpegEncContext *const s = w->s;
  
-     w->raw_orient=0;
-     if(w->edges&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC
-         w->chroma_orient=4<<((0xCC>>w->edges)&1);
+     w->edges  = 1 * (!(s->mb_x >> 1));
+     w->edges |= 2 * (!(s->mb_y >> 1));
+     w->edges |= 4 * (s->mb_x >= (2 * s->mb_width - 1)); // mb_x for chroma would always be odd
+     w->raw_orient = 0;
+     // lut_co[8] = {inv,4,8,8, inv,4,8,8} <- => {1,1,0,0;1,1,0,0} => 0xCC
+     if (w->edges & 3) {
+         w->chroma_orient = 4 << ((0xCC >> w->edges) & 1);
          return;
      }
-     w->chroma_orient = (w->prediction_table[2*s->mb_x-2] & 0x03)<<2;//block[x-1][y|1-1)]
+     // block[x - 1][y | 1 - 1)]
+     w->chroma_orient = (w->prediction_table[2 * s->mb_x - 2] & 0x03) << 2;
  }
  
- static void x8_get_prediction(IntraX8Context * const w){
-     MpegEncContext * const s= w->s;
-     int a,b,c,i;
-     w->edges = 1*( !s->mb_x );
-     w->edges|= 2*( !s->mb_y );
-     w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );
-     switch(w->edges&3){
-         case 0:
-             break;
-         case 1:
-             //take the one from the above block[0][y-1]
-             w->est_run = w->prediction_table[!(s->mb_y&1)]>>2;
-             w->orient  = 1;
-             return;
-         case 2:
-             //take the one from the previous block[x-1][0]
-             w->est_run = w->prediction_table[2*s->mb_x-2]>>2;
-             w->orient  = 2;
-             return;
-         case 3:
-             w->est_run = 16;
-             w->orient  = 0;
-             return;
+ static void x8_get_prediction(IntraX8Context *const w)
+ {
+     MpegEncContext *const s = w->s;
+     int a, b, c, i;
+     w->edges  = 1 * (!s->mb_x);
+     w->edges |= 2 * (!s->mb_y);
+     w->edges |= 4 * (s->mb_x >= (2 * s->mb_width - 1));
+     switch (w->edges & 3) {
+     case 0:
+         break;
+     case 1:
+         // take the one from the above block[0][y - 1]
+         w->est_run = w->prediction_table[!(s->mb_y & 1)] >> 2;
+         w->orient  = 1;
+         return;
+     case 2:
+         // take the one from the previous block[x - 1][0]
+         w->est_run = w->prediction_table[2 * s->mb_x - 2] >> 2;
+         w->orient  = 2;
+         return;
+     case 3:
+         w->est_run = 16;
+         w->orient  = 0;
+         return;
      }
-     //no edge cases
-     b= w->prediction_table[2*s->mb_x   + !(s->mb_y&1) ];//block[x  ][y-1]
-     a= w->prediction_table[2*s->mb_x-2 +  (s->mb_y&1) ];//block[x-1][y  ]
-     c= w->prediction_table[2*s->mb_x-2 + !(s->mb_y&1) ];//block[x-1][y-1]
+     // no edge cases
+     b = w->prediction_table[2 * s->mb_x     + !(s->mb_y & 1)]; // block[x    ][y - 1]
+     a = w->prediction_table[2 * s->mb_x - 2 +  (s->mb_y & 1)]; // block[x - 1][y    ]
+     c = w->prediction_table[2 * s->mb_x - 2 + !(s->mb_y & 1)]; // block[x - 1][y - 1]
  
-     w->est_run = FFMIN(b,a);
+     w->est_run = FFMIN(b, a);
      /* This condition has nothing to do with w->edges, even if it looks
-        similar it would trigger if e.g. x=3;y=2;
-        I guess somebody wrote something wrong and it became standard. */
-     if( (s->mb_x & s->mb_y) != 0 ) w->est_run=FFMIN(c,w->est_run);
-     w->est_run>>=2;
-     a&=3;
-     b&=3;
-     c&=3;
-     i=( 0xFFEAF4C4>>(2*b+8*a) )&3;
-     if(i!=3) w->orient=i;
-     else     w->orient=( 0xFFEAD8>>(2*c+8*(w->quant>12)) )&3;
+      * similar it would trigger if e.g. x = 3; y = 2;
+      * I guess somebody wrote something wrong and it became standard. */
+     if ((s->mb_x & s->mb_y) != 0)
+         w->est_run = FFMIN(c, w->est_run);
+     w->est_run >>= 2;
+     a &= 3;
+     b &= 3;
+     c &= 3;
+     i = (0xFFEAF4C4 >> (2 * b + 8 * a)) & 3;
+     if (i != 3)
+         w->orient = i;
+     else
+         w->orient = (0xFFEAD8 >> (2 * c + 8 * (w->quant > 12))) & 3;
  /*
- lut1[b][a]={
- ->{0, 1, 0, pad},
-   {0, 1, X, pad},
-   {2, 2, 2, pad}}
-    pad 2   2  2; pad X  1  0; pad 0  1  0 <-
- -> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4
- lut2[q>12][c]={
-   ->{0,2,1,pad},
-     {2,2,2,pad}}
-    pad 2  2  2; pad 1  2  0 <-
- -> 11 10'10 10 '11 01'10 00=>0xEAD8
- */
+  * lut1[b][a] = {
+  * ->{ 0, 1, 0, pad },
+  *   { 0, 1, X, pad },
+  *   { 2, 2, 2, pad }
+  * }
+  * pad 2  2  2;
+  * pad X  1  0;
+  * pad 0  1  0 <-
+  * -> 11 10 '10 10 '11 11'01 00 '11 00'01 00 => 0xEAF4C4
+  *
+  * lut2[q>12][c] = {
+  * ->{ 0, 2, 1, pad},
+  *   { 2, 2, 2, pad}
+  * }
+  * pad 2  2  2;
+  * pad 1  2  0 <-
+  * -> 11 10'10 10 '11 01'10 00 => 0xEAD8
+  */
  }
  
- static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){
-     MpegEncContext * const s= w->s;
+ static void x8_ac_compensation(IntraX8Context *const w, int const direction,
+                                int const dc_level)
+ {
+     MpegEncContext *const s = w->s;
      int t;
 -#define B(x, y) s->block[0][s->idsp.idct_permutation[(x) + (y) * 8]]
 +#define B(x,y)  s->block[0][w->idct_permutation[(x)+(y)*8]]
  #define T(x)  ((x) * dc_level + 0x8000) >> 16;
-     switch(direction){
+     switch (direction) {
      case 0:
-         t = T(3811);//h
-         B(1,0) -= t;
-         B(0,1) -= t;
-         t = T(487);//e
-         B(2,0) -= t;
-         B(0,2) -= t;
-         t = T(506);//f
-         B(3,0) -= t;
-         B(0,3) -= t;
-         t = T(135);//c
-         B(4,0) -= t;
-         B(0,4) -= t;
-         B(2,1) += t;
-         B(1,2) += t;
-         B(3,1) += t;
-         B(1,3) += t;
-         t = T(173);//d
-         B(5,0) -= t;
-         B(0,5) -= t;
-         t = T(61);//b
-         B(6,0) -= t;
-         B(0,6) -= t;
-         B(5,1) += t;
-         B(1,5) += t;
-         t = T(42); //a
-         B(7,0) -= t;
-         B(0,7) -= t;
-         B(4,1) += t;
-         B(1,4) += t;
-         B(4,4) += t;
-         t = T(1084);//g
-         B(1,1) += t;
-         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
+         t        = T(3811); // h
+         B(1, 0) -= t;
+         B(0, 1) -= t;
+         t        = T(487); // e
+         B(2, 0) -= t;
+         B(0, 2) -= t;
+         t        = T(506); // f
+         B(3, 0) -= t;
+         B(0, 3) -= t;
+         t        = T(135); // c
+         B(4, 0) -= t;
+         B(0, 4) -= t;
+         B(2, 1) += t;
+         B(1, 2) += t;
+         B(3, 1) += t;
+         B(1, 3) += t;
+         t        = T(173); // d
+         B(5, 0) -= t;
+         B(0, 5) -= t;
+         t        = T(61); // b
+         B(6, 0) -= t;
+         B(0, 6) -= t;
+         B(5, 1) += t;
+         B(1, 5) += t;
+         t        = T(42); // a
+         B(7, 0) -= t;
+         B(0, 7) -= t;
+         B(4, 1) += t;
+         B(1, 4) += t;
+         B(4, 4) += t;
+         t        = T(1084); // g
+         B(1, 1) += t;
+         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7 * 8);
          break;
      case 1:
-         B(0,1) -= T(6269);
-         B(0,3) -= T( 708);
-         B(0,5) -= T( 172);
-         B(0,7) -= T(  73);
+         B(0, 1) -= T(6269);
+         B(0, 3) -= T(708);
+         B(0, 5) -= T(172);
+         B(0, 7) -= T(73);
  
-         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
+         s->block_last_index[0] = FFMAX(s->block_last_index[0], 7 * 8);
          break;
      case 2:
-         B(1,0) -= T(6269);
-         B(3,0) -= T( 708);
-         B(5,0) -= T( 172);
-         B(7,0) -= T(  73);
+         B(1, 0) -= T(6269);
+         B(3, 0) -= T(708);
+         B(5, 0) -= T(172);
+         B(7, 0) -= T(73);
  
          s->block_last_index[0] = FFMAX(s->block_last_index[0], 7);
          break;
@@@ -537,35 -588,35 +587,35 @@@ static int x8_decode_intra_mb(IntraX8Co
      int use_quant_matrix;
      int sign;
  
-     av_assert2(w->orient<12);
 -    assert(w->orient < 12);
++    av_assert2(w->orient < 12);
      s->bdsp.clear_block(s->block[0]);
  
-     if(chroma){
-         dc_mode=2;
-     }else{
-         dc_mode=!!w->est_run;//0,1
-     }
-     if(x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) return -1;
-     n=0;
-     zeros_only=0;
-     if(!final){//decode ac
-         use_quant_matrix=w->use_quant_matrix;
-         if(chroma){
+     if (chroma)
+         dc_mode = 2;
+     else
+         dc_mode = !!w->est_run; // 0, 1
+     if (x8_get_dc_rlf(w, dc_mode, &dc_level, &final))
+         return -1;
+     n          = 0;
+     zeros_only = 0;
+     if (!final) { // decode ac
+         use_quant_matrix = w->use_quant_matrix;
+         if (chroma) {
              ac_mode = 1;
-             est_run = 64;//not used
-         }else{
-             if (w->raw_orient < 3){
+             est_run = 64; // not used
+         } else {
+             if (w->raw_orient < 3)
                  use_quant_matrix = 0;
-             }
-             if(w->raw_orient > 4){
+             if (w->raw_orient > 4) {
                  ac_mode = 0;
                  est_run = 64;
-             }else{
-                 if(w->est_run > 1){
+             } else {
+                 if (w->est_run > 1) {
                      ac_mode = 2;
-                     est_run=w->est_run;
-                 }else{
+                     est_run = w->est_run;
+                 } else {
                      ac_mode = 3;
                      est_run = 64;
                  }
          }
      }
  
-     if(w->flat_dc){
-         dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
-     }else{
-         w->dsp.spatial_compensation[w->orient]( s->sc.edge_emu_buffer,
-                                             s->dest[chroma],
-                                             s->current_picture.f->linesize[!!chroma] );
+     if (w->flat_dc) {
+         dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma],
+                               s->current_picture.f->linesize[!!chroma]);
+     } else {
+         w->dsp.spatial_compensation[w->orient](s->sc.edge_emu_buffer,
+                                                s->dest[chroma],
+                                                s->current_picture.f->linesize[!!chroma]);
      }
-     if(!zeros_only)
+     if (!zeros_only)
 -        s->idsp.idct_add(s->dest[chroma],
 +        w->wdsp.idct_add(s->dest[chroma],
                           s->current_picture.f->linesize[!!chroma],
                           s->block[0]);
  
@@@ -691,20 -745,21 +744,26 @@@ static void x8_init_block_index(MpegEnc
   * @param w pointer to IntraX8Context
   * @param s pointer to MpegEncContext of the parent codec
   */
- av_cold void ff_intrax8_common_init(IntraX8Context * w, MpegEncContext * const s){
-     w->s=s;
+ av_cold void ff_intrax8_common_init(IntraX8Context *w, MpegEncContext *const s)
+ {
+     w->s = s;
      x8_vlc_init();
-     av_assert0(s->mb_width>0);
-     w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
 -    assert(s->mb_width > 0);
++    av_assert0(s->mb_width > 0);
 -    // two rows, 2 blocks per cannon mb
++    //two rows, 2 blocks per cannon mb
+     w->prediction_table = av_mallocz(s->mb_width * 2 * 2);
  
 -    ff_init_scantable(s->idsp.idct_permutation, &w->scantable[0],
 +    ff_wmv2dsp_init(&w->wdsp);
++
 +    ff_init_scantable_permutation(w->idct_permutation,
 +                                  w->wdsp.idct_perm);
 +
-     ff_init_scantable(w->idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
-     ff_init_scantable(w->idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
-     ff_init_scantable(w->idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
++    ff_init_scantable(w->idct_permutation, &w->scantable[0],
+                       ff_wmv1_scantable[0]);
 -    ff_init_scantable(s->idsp.idct_permutation, &w->scantable[1],
++    ff_init_scantable(w->idct_permutation, &w->scantable[1],
+                       ff_wmv1_scantable[2]);
 -    ff_init_scantable(s->idsp.idct_permutation, &w->scantable[2],
++    ff_init_scantable(w->idct_permutation, &w->scantable[2],
+                       ff_wmv1_scantable[3]);
  
      ff_intrax8dsp_init(&w->dsp);
  }
@@@ -729,9 -783,12 +788,11 @@@ av_cold void ff_intrax8_common_end(Intr
   * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
   * @param quant_offset offset away from zero
   */
- int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_offset){
-     MpegEncContext * const s= w->s;
+ int ff_intrax8_decode_picture(IntraX8Context *const w, int dquant,
+                               int quant_offset)
+ {
+     MpegEncContext *const s = w->s;
      int mb_xy;
 -    assert(s);
      w->use_quant_matrix = get_bits1(&s->gb);
  
      w->dquant = dquant;
  #include "get_bits.h"
  #include "mpegvideo.h"
  #include "intrax8dsp.h"
 +#include "wmv2dsp.h"
  
  typedef struct IntraX8Context {
-     VLC * j_ac_vlc[4];//they point to the static j_mb_vlc
-     VLC * j_orient_vlc;
-     VLC * j_dc_vlc[3];
+     VLC *j_ac_vlc[4]; // they point to the static j_mb_vlc
+     VLC *j_orient_vlc;
+     VLC *j_dc_vlc[3];
  
      int use_quant_matrix;
- //set by ff_intrax8_common_init
-     uint8_t * prediction_table;//2*(mb_w*2)
+     // set by ff_intrax8_common_init
+     uint8_t *prediction_table; // 2 * (mb_w * 2)
      ScanTable scantable[3];
- //set by the caller codec
 +    WMV2DSPContext wdsp;
 +    uint8_t idct_permutation[64];
 -    // set by the caller codec
 -    MpegEncContext *s;
++    //set by the caller codec
 +    MpegEncContext * s;
      IntraX8DSPContext dsp;
      int quant;
      int dquant;
Simple merge
Simple merge
Simple merge