2 * This file is part of Libav.
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.
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.
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
21 * @brief IntraX8 (J-Frame) subdecoder, used by WMV2 and VC-1
26 #include "mpegvideo.h"
27 #include "msmpeg4data.h"
28 #include "intrax8huf.h"
30 #include "intrax8dsp.h"
32 #define MAX_TABLE_DEPTH(table_bits, max_bits) ((max_bits+table_bits-1)/table_bits)
38 #define DC_VLC_MTD MAX_TABLE_DEPTH(DC_VLC_BITS, MAX_DC_VLC_BITS)
39 #define AC_VLC_MTD MAX_TABLE_DEPTH(AC_VLC_BITS, MAX_AC_VLC_BITS)
40 #define OR_VLC_MTD MAX_TABLE_DEPTH(OR_VLC_BITS, MAX_OR_VLC_BITS)
42 static VLC j_ac_vlc
[2][2][8]; //[quant<13],[intra/inter],[select]
43 static VLC j_dc_vlc
[2][8]; //[quant], [select]
44 static VLC j_orient_vlc
[2][4]; //[quant], [select]
46 static av_cold
void x8_vlc_init(void){
50 static const uint16_t sizes
[8*4 + 8*2 + 2 + 4] = {
51 576, 548, 582, 618, 546, 616, 560, 642,
52 584, 582, 704, 664, 512, 544, 656, 640,
53 512, 648, 582, 566, 532, 614, 596, 648,
54 586, 552, 584, 590, 544, 578, 584, 624,
56 528, 528, 526, 528, 536, 528, 526, 544,
57 544, 512, 512, 528, 528, 544, 512, 544,
59 128, 128, 128, 128, 128, 128};
61 static VLC_TYPE table
[28150][2];
63 #define init_ac_vlc(dst,src) \
64 dst.table = &table[offset]; \
65 dst.table_allocated = sizes[sizeidx]; \
66 offset += sizes[sizeidx++]; \
71 INIT_VLC_USE_NEW_STATIC)
74 init_ac_vlc( j_ac_vlc
[0][0][i
], x8_ac0_highquant_table
[i
][0] );
75 init_ac_vlc( j_ac_vlc
[0][1][i
], x8_ac1_highquant_table
[i
][0] );
76 init_ac_vlc( j_ac_vlc
[1][0][i
], x8_ac0_lowquant_table
[i
][0] );
77 init_ac_vlc( j_ac_vlc
[1][1][i
], x8_ac1_lowquant_table
[i
][0] );
82 #define init_dc_vlc(dst,src) \
83 dst.table = &table[offset]; \
84 dst.table_allocated = sizes[sizeidx]; \
85 offset += sizes[sizeidx++]; \
90 INIT_VLC_USE_NEW_STATIC);
92 init_dc_vlc( j_dc_vlc
[0][i
], x8_dc_highquant_table
[i
][0]);
93 init_dc_vlc( j_dc_vlc
[1][i
], x8_dc_lowquant_table
[i
][0]);
98 #define init_or_vlc(dst,src) \
99 dst.table = &table[offset]; \
100 dst.table_allocated = sizes[sizeidx]; \
101 offset += sizes[sizeidx++]; \
106 INIT_VLC_USE_NEW_STATIC);
108 init_or_vlc( j_orient_vlc
[0][i
], x8_orient_highquant_table
[i
][0]);
111 init_or_vlc( j_orient_vlc
[1][i
], x8_orient_lowquant_table
[i
][0])
113 if (offset
!= sizeof(table
)/sizeof(VLC_TYPE
)/2)
114 av_log(NULL
, AV_LOG_ERROR
, "table size %i does not match needed %i\n", (int)(sizeof(table
)/sizeof(VLC_TYPE
)/2), offset
);
118 static void x8_reset_vlc_tables(IntraX8Context
* w
){
119 memset(w
->j_dc_vlc
,0,sizeof(w
->j_dc_vlc
));
120 memset(w
->j_ac_vlc
,0,sizeof(w
->j_ac_vlc
));
121 w
->j_orient_vlc
=NULL
;
124 static inline void x8_select_ac_table(IntraX8Context
* const w
, int mode
){
125 MpegEncContext
* const s
= w
->s
;
130 if( w
->j_ac_vlc
[mode
] ) return;
132 table_index
= get_bits(&s
->gb
, 3);
133 w
->j_ac_vlc
[mode
] = &j_ac_vlc
[w
->quant
<13][mode
>>1][table_index
];//2 modes use same tables
134 assert(w
->j_ac_vlc
[mode
]);
137 static inline int x8_get_orient_vlc(IntraX8Context
* w
){
138 MpegEncContext
* const s
= w
->s
;
141 if(!w
->j_orient_vlc
){
142 table_index
= get_bits(&s
->gb
, 1+(w
->quant
<13) );
143 w
->j_orient_vlc
= &j_orient_vlc
[w
->quant
<13][table_index
];
145 assert(w
->j_orient_vlc
);
146 assert(w
->j_orient_vlc
->table
);
148 return get_vlc2(&s
->gb
, w
->j_orient_vlc
->table
, OR_VLC_BITS
, OR_VLC_MTD
);
151 #define extra_bits(eb) (eb)
152 #define extra_run (0xFF<<8)
153 #define extra_level (0x00<<8)
154 #define run_offset(r) ((r)<<16)
155 #define level_offset(l) ((l)<<24)
156 static const uint32_t ac_decode_table
[]={
157 /*46*/ extra_bits(3) | extra_run
| run_offset(16) | level_offset( 0),
158 /*47*/ extra_bits(3) | extra_run
| run_offset(24) | level_offset( 0),
159 /*48*/ extra_bits(2) | extra_run
| run_offset( 4) | level_offset( 1),
160 /*49*/ extra_bits(3) | extra_run
| run_offset( 8) | level_offset( 1),
162 /*50*/ extra_bits(5) | extra_run
| run_offset(32) | level_offset( 0),
163 /*51*/ extra_bits(4) | extra_run
| run_offset(16) | level_offset( 1),
165 /*52*/ extra_bits(2) | extra_level
| run_offset( 0) | level_offset( 4),
166 /*53*/ extra_bits(2) | extra_level
| run_offset( 0) | level_offset( 8),
167 /*54*/ extra_bits(2) | extra_level
| run_offset( 0) | level_offset(12),
168 /*55*/ extra_bits(3) | extra_level
| run_offset( 0) | level_offset(16),
169 /*56*/ extra_bits(3) | extra_level
| run_offset( 0) | level_offset(24),
171 /*57*/ extra_bits(2) | extra_level
| run_offset( 1) | level_offset( 3),
172 /*58*/ extra_bits(3) | extra_level
| run_offset( 1) | level_offset( 7),
174 /*59*/ extra_bits(2) | extra_run
| run_offset(16) | level_offset( 0),
175 /*60*/ extra_bits(2) | extra_run
| run_offset(20) | level_offset( 0),
176 /*61*/ extra_bits(2) | extra_run
| run_offset(24) | level_offset( 0),
177 /*62*/ extra_bits(2) | extra_run
| run_offset(28) | level_offset( 0),
178 /*63*/ extra_bits(4) | extra_run
| run_offset(32) | level_offset( 0),
179 /*64*/ extra_bits(4) | extra_run
| run_offset(48) | level_offset( 0),
181 /*65*/ extra_bits(2) | extra_run
| run_offset( 4) | level_offset( 1),
182 /*66*/ extra_bits(3) | extra_run
| run_offset( 8) | level_offset( 1),
183 /*67*/ extra_bits(4) | extra_run
| run_offset(16) | level_offset( 1),
185 /*68*/ extra_bits(2) | extra_level
| run_offset( 0) | level_offset( 4),
186 /*69*/ extra_bits(3) | extra_level
| run_offset( 0) | level_offset( 8),
187 /*70*/ extra_bits(4) | extra_level
| run_offset( 0) | level_offset(16),
189 /*71*/ extra_bits(2) | extra_level
| run_offset( 1) | level_offset( 3),
190 /*72*/ extra_bits(3) | extra_level
| run_offset( 1) | level_offset( 7),
192 //extra_bits = 3bits; extra_run/level = 1 bit; run_offset = 6bits; level_offset = 5 bits;
199 static void x8_get_ac_rlf(IntraX8Context
* const w
, const int mode
,
200 int * const run
, int * const level
, int * const final
){
201 MpegEncContext
* const s
= w
->s
;
204 // x8_select_ac_table(w,mode);
205 i
= get_vlc2(&s
->gb
, w
->j_ac_vlc
[mode
]->table
, AC_VLC_BITS
, AC_VLC_MTD
);
210 (*level
)=(*final
)=//prevent 'may be used unilitialized'
211 (*run
)=64;//this would cause error exit in the ac loop
215 (*final
) = t
= (i
>22);
218 i== 0-15 r=0-15 l=0 ;r=i& %01111
219 i==16-19 r=0-3 l=1 ;r=i& %00011
220 i==20-21 r=0-1 l=2 ;r=i& %00001
221 i==22 r=0 l=3 ;r=i& %00000
222 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
223 t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter */
224 l
=(0xE50000>>(i
&(0x1E)))&3;/*0x1E or (~1) or ((i>>1)<<1)*/
225 t
=(0x01030F>>(l
<<3));
229 }else if(i
<73){//[46-72]
234 sm
=ac_decode_table
[i
];
236 e
=get_bits(&s
->gb
,sm
&0xF);sm
>>=8;//3bits
237 mask
=sm
&0xff;sm
>>=8; //1bit
239 (*run
) =(sm
&0xff) + (e
&( mask
));//6bits
240 (*level
)=(sm
>>8) + (e
&(~mask
));//5bits
242 }else if(i
<75){//[73-74]
243 static const uint8_t crazy_mix_runlevel
[32]={
244 0x22,0x32,0x33,0x53,0x23,0x42,0x43,0x63,
245 0x24,0x52,0x34,0x73,0x25,0x62,0x44,0x83,
246 0x26,0x72,0x35,0x54,0x27,0x82,0x45,0x64,
247 0x28,0x92,0x36,0x74,0x29,0xa2,0x46,0x84};
250 e
=get_bits(&s
->gb
,5);//get the extra bits
251 (*run
) =crazy_mix_runlevel
[e
]>>4;
252 (*level
)=crazy_mix_runlevel
[e
]&0x0F;
254 (*level
)=get_bits( &s
->gb
, 7-3*(i
&1));
255 (*run
) =get_bits( &s
->gb
, 6);
256 (*final
)=get_bits1(&s
->gb
);
261 //static const uint8_t dc_extra_sbits[] ={0, 1,1, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 };
262 static const uint8_t dc_index_offset
[] ={ 0, 1,2, 3,4, 5,7, 9,13, 17,25, 33,49, 65,97, 129,193};
264 static int x8_get_dc_rlf(IntraX8Context
* const w
,int const mode
, int * const level
, int * const final
){
265 MpegEncContext
* const s
= w
->s
;
269 if( !w
->j_dc_vlc
[mode
] ) {
271 table_index
= get_bits(&s
->gb
, 3);
272 //4 modes, same table
273 w
->j_dc_vlc
[mode
]= &j_dc_vlc
[w
->quant
<13][table_index
];
276 assert(w
->j_dc_vlc
[mode
]->table
);
278 i
=get_vlc2(&s
->gb
, w
->j_dc_vlc
[mode
]->table
, DC_VLC_BITS
, DC_VLC_MTD
);
280 /*(i>=17) {i-=17;final=1;}*/
289 c
=(i
+1)>>1;//hackish way to calculate dc_extra_sbits[]
292 e
=get_bits(&s
->gb
,c
);//get the extra bits
293 i
=dc_index_offset
[i
]+(e
>>1);
295 e
= -(e
& 1);//0,0xffffff
296 (*level
)= (i
^ e
) - e
;// (i^0)-0 , (i^0xff)-(-1)
301 static int x8_setup_spatial_predictor(IntraX8Context
* const w
, const int chroma
){
302 MpegEncContext
* const s
= w
->s
;
307 w
->dsp
.setup_spatial_compensation(s
->dest
[chroma
], s
->edge_emu_buffer
,
308 s
->current_picture
.f
.linesize
[chroma
>0],
309 &range
, &sum
, w
->edges
);
311 w
->orient
=w
->chroma_orient
;
312 quant
=w
->quant_dc_chroma
;
318 if(range
< quant
|| range
< 3){
320 if(range
< 3){//yep you read right, a +-1 idct error may break decoding!
323 w
->predicted_dc
= (sum
*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899
329 assert(w
->orient
< 3);
330 if(range
< 2*w
->quant
){
331 if( (w
->edges
&3) == 0){
332 if(w
->orient
==1) w
->orient
=11;
333 if(w
->orient
==2) w
->orient
=10;
339 static const uint8_t prediction_table
[3][12]={
340 {0,8,4, 10,11, 2,6,9,1,3,5,7},
341 {4,0,8, 11,10, 3,5,2,6,9,1,7},
342 {8,0,4, 10,11, 1,7,2,6,9,3,5}
344 w
->raw_orient
=x8_get_orient_vlc(w
);
345 if(w
->raw_orient
<0) return -1;
346 assert(w
->raw_orient
< 12 );
348 w
->orient
=prediction_table
[w
->orient
][w
->raw_orient
];
353 static void x8_update_predictions(IntraX8Context
* const w
, const int orient
, const int est_run
){
354 MpegEncContext
* const s
= w
->s
;
356 w
->prediction_table
[s
->mb_x
*2+(s
->mb_y
&1)] = (est_run
<<2) + 1*(orient
==4) + 2*(orient
==8);
362 static void x8_get_prediction_chroma(IntraX8Context
* const w
){
363 MpegEncContext
* const s
= w
->s
;
365 w
->edges
= 1*( !(s
->mb_x
>>1) );
366 w
->edges
|= 2*( !(s
->mb_y
>>1) );
367 w
->edges
|= 4*( s
->mb_x
>= (2*s
->mb_width
-1) );//mb_x for chroma would always be odd
370 if(w
->edges
&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC
371 w
->chroma_orient
=4<<((0xCC>>w
->edges
)&1);
374 w
->chroma_orient
= (w
->prediction_table
[2*s
->mb_x
-2] & 0x03)<<2;//block[x-1][y|1-1)]
377 static void x8_get_prediction(IntraX8Context
* const w
){
378 MpegEncContext
* const s
= w
->s
;
381 w
->edges
= 1*( !s
->mb_x
);
382 w
->edges
|= 2*( !s
->mb_y
);
383 w
->edges
|= 4*( s
->mb_x
>= (2*s
->mb_width
-1) );
389 //take the one from the above block[0][y-1]
390 w
->est_run
= w
->prediction_table
[!(s
->mb_y
&1)]>>2;
394 //take the one from the previous block[x-1][0]
395 w
->est_run
= w
->prediction_table
[2*s
->mb_x
-2]>>2;
404 b
= w
->prediction_table
[2*s
->mb_x
+ !(s
->mb_y
&1) ];//block[x ][y-1]
405 a
= w
->prediction_table
[2*s
->mb_x
-2 + (s
->mb_y
&1) ];//block[x-1][y ]
406 c
= w
->prediction_table
[2*s
->mb_x
-2 + !(s
->mb_y
&1) ];//block[x-1][y-1]
408 w
->est_run
= FFMIN(b
,a
);
409 /* This condition has nothing to do with w->edges, even if it looks
410 similar it would trigger if e.g. x=3;y=2;
411 I guess somebody wrote something wrong and it became standard. */
412 if( (s
->mb_x
& s
->mb_y
) != 0 ) w
->est_run
=FFMIN(c
,w
->est_run
);
419 i
=( 0xFFEAF4C4>>(2*b
+8*a
) )&3;
420 if(i
!=3) w
->orient
=i
;
421 else w
->orient
=( 0xFFEAD8>>(2*c
+8*(w
->quant
>12)) )&3;
427 pad 2 2 2; pad X 1 0; pad 0 1 0 <-
428 -> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4
433 pad 2 2 2; pad 1 2 0 <-
434 -> 11 10'10 10 '11 01'10 00=>0xEAD8
439 static void x8_ac_compensation(IntraX8Context
* const w
, int const direction
, int const dc_level
){
440 MpegEncContext
* const s
= w
->s
;
442 #define B(x,y) s->block[0][s->dsp.idct_permutation[(x)+(y)*8]]
443 #define T(x) ((x) * dc_level + 0x8000) >> 16;
486 s
->block_last_index
[0] = FFMAX(s
->block_last_index
[0], 7*8);
494 s
->block_last_index
[0] = FFMAX(s
->block_last_index
[0], 7*8);
502 s
->block_last_index
[0] = FFMAX(s
->block_last_index
[0], 7);
509 static void dsp_x8_put_solidcolor(uint8_t const pix
, uint8_t * dst
, int const linesize
){
517 static const int16_t quant_table
[64] = {
518 256, 256, 256, 256, 256, 256, 259, 262,
519 265, 269, 272, 275, 278, 282, 285, 288,
520 292, 295, 299, 303, 306, 310, 314, 317,
521 321, 325, 329, 333, 337, 341, 345, 349,
522 353, 358, 362, 366, 371, 375, 379, 384,
523 389, 393, 398, 403, 408, 413, 417, 422,
524 428, 433, 438, 443, 448, 454, 459, 465,
525 470, 476, 482, 488, 493, 499, 505, 511
528 static int x8_decode_intra_mb(IntraX8Context
* const w
, const int chroma
){
529 MpegEncContext
* const s
= w
->s
;
533 int ac_mode
,dc_mode
,est_run
,dc_level
;
536 int use_quant_matrix
;
539 assert(w
->orient
<12);
540 s
->dsp
.clear_block(s
->block
[0]);
545 dc_mode
=!!w
->est_run
;//0,1
548 if(x8_get_dc_rlf(w
, dc_mode
, &dc_level
, &final
)) return -1;
551 if(!final
){//decode ac
552 use_quant_matrix
=w
->use_quant_matrix
;
555 est_run
= 64;//not used
557 if (w
->raw_orient
< 3){
558 use_quant_matrix
= 0;
560 if(w
->raw_orient
> 4){
573 x8_select_ac_table(w
,ac_mode
);
574 /*scantable_selector[12]={0,2,0,1,1,1,0,2,2,0,1,2};<-
575 -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 =>0x928548 */
576 scantable
= w
->scantable
[ (0x928548>>(2*w
->orient
))&3 ].permutated
;
582 x8_select_ac_table(w
,3);
585 x8_get_ac_rlf(w
,ac_mode
,&run
,&level
,&final
);
589 //this also handles vlc error in x8_get_ac_rlf
592 level
= (level
+1) * w
->dquant
;
595 sign
= - get_bits1(&s
->gb
);
596 level
= (level
^ sign
) - sign
;
598 if(use_quant_matrix
){
599 level
= (level
*quant_table
[pos
])>>8;
601 s
->block
[0][ scantable
[pos
] ]=level
;
604 s
->block_last_index
[0]=pos
;
606 s
->block_last_index
[0]=0;
607 if(w
->flat_dc
&& ((unsigned)(dc_level
+1)) < 3){//[-1;1]
608 int32_t divide_quant
= !chroma
? w
->divide_quant_dc_luma
:
609 w
->divide_quant_dc_chroma
;
610 int32_t dc_quant
= !chroma
? w
->quant
:
613 //original intent dc_level+=predicted_dc/quant; but it got lost somewhere in the rounding
614 dc_level
+= (w
->predicted_dc
*divide_quant
+ (1<<12) )>>13;
616 dsp_x8_put_solidcolor( av_clip_uint8((dc_level
*dc_quant
+4)>>3),
617 s
->dest
[chroma
], s
->current_picture
.f
.linesize
[!!chroma
]);
621 zeros_only
= (dc_level
== 0);
624 s
->block
[0][0] = dc_level
*w
->quant
;
626 s
->block
[0][0] = dc_level
*w
->quant_dc_chroma
;
629 //there is !zero_only check in the original, but dc_level check is enough
630 if( (unsigned int)(dc_level
+1) >= 3 && (w
->edges
&3) != 3 ){
632 /*ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 };<-
633 -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 =>0x6A017C */
634 direction
= (0x6A017C>>(w
->orient
*2))&3;
636 x8_ac_compensation(w
, direction
, s
->block
[0][0]);//modify block_last[]
641 dsp_x8_put_solidcolor(w
->predicted_dc
, s
->dest
[chroma
], s
->current_picture
.f
.linesize
[!!chroma
]);
643 w
->dsp
.spatial_compensation
[w
->orient
]( s
->edge_emu_buffer
,
645 s
->current_picture
.f
.linesize
[!!chroma
] );
648 s
->dsp
.idct_add ( s
->dest
[chroma
],
649 s
->current_picture
.f
.linesize
[!!chroma
],
655 x8_update_predictions(w
,w
->orient
,n
);
659 uint8_t* ptr
= s
->dest
[chroma
];
660 int linesize
= s
->current_picture
.f
.linesize
[!!chroma
];
662 if(!( (w
->edges
&2) || ( zeros_only
&& (w
->orient
|4)==4 ) )){
663 w
->dsp
.h_loop_filter(ptr
, linesize
, w
->quant
);
665 if(!( (w
->edges
&1) || ( zeros_only
&& (w
->orient
|8)==8 ) )){
666 w
->dsp
.v_loop_filter(ptr
, linesize
, w
->quant
);
672 static void x8_init_block_index(MpegEncContext
*s
){ //FIXME maybe merge with ff_*
673 //not s->linesize as this would be wrong for field pics
674 //not that IntraX8 has interlacing support ;)
675 const int linesize
= s
->current_picture
.f
.linesize
[0];
676 const int uvlinesize
= s
->current_picture
.f
.linesize
[1];
678 s
->dest
[0] = s
->current_picture
.f
.data
[0];
679 s
->dest
[1] = s
->current_picture
.f
.data
[1];
680 s
->dest
[2] = s
->current_picture
.f
.data
[2];
682 s
->dest
[0] += s
->mb_y
* linesize
<< 3;
683 s
->dest
[1] += ( s
->mb_y
&(~1) ) * uvlinesize
<< 2;//chroma blocks are on add rows
684 s
->dest
[2] += ( s
->mb_y
&(~1) ) * uvlinesize
<< 2;
688 * Initialize IntraX8 frame decoder.
689 * Requires valid MpegEncContext with valid s->mb_width before calling.
690 * @param w pointer to IntraX8Context
691 * @param s pointer to MpegEncContext of the parent codec
693 av_cold
void ff_intrax8_common_init(IntraX8Context
* w
, MpegEncContext
* const s
){
697 assert(s
->mb_width
>0);
698 w
->prediction_table
=av_mallocz(s
->mb_width
*2*2);//two rows, 2 blocks per cannon mb
700 ff_init_scantable(s
->dsp
.idct_permutation
, &w
->scantable
[0], ff_wmv1_scantable
[0]);
701 ff_init_scantable(s
->dsp
.idct_permutation
, &w
->scantable
[1], ff_wmv1_scantable
[2]);
702 ff_init_scantable(s
->dsp
.idct_permutation
, &w
->scantable
[2], ff_wmv1_scantable
[3]);
704 ff_intrax8dsp_init(&w
->dsp
);
708 * Destroy IntraX8 frame structure.
709 * @param w pointer to IntraX8Context
711 av_cold
void ff_intrax8_common_end(IntraX8Context
* w
)
713 av_freep(&w
->prediction_table
);
717 * Decode single IntraX8 frame.
718 * The parent codec must fill s->loopfilter and s->gb (bitstream).
719 * The parent codec must call MPV_frame_start(), ff_er_frame_start() before calling this function.
720 * The parent codec must call ff_er_frame_end(), MPV_frame_end() after calling this function.
721 * This function does not use MPV_decode_mb().
722 * @param w pointer to IntraX8Context
723 * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
724 * @param quant_offset offset away from zero
726 //FIXME extern uint8_t ff_wmv3_dc_scale_table[32];
727 int ff_intrax8_decode_picture(IntraX8Context
* const w
, int dquant
, int quant_offset
){
728 MpegEncContext
* const s
= w
->s
;
731 w
->use_quant_matrix
= get_bits1(&s
->gb
);
734 w
->quant
= dquant
>> 1;
735 w
->qsum
= quant_offset
;
737 w
->divide_quant_dc_luma
= ((1<<16) + (w
->quant
>>1)) / w
->quant
;
739 w
->quant_dc_chroma
= w
->quant
;
740 w
->divide_quant_dc_chroma
= w
->divide_quant_dc_luma
;
742 w
->quant_dc_chroma
= w
->quant
+((w
->quant
+3)>>3);
743 w
->divide_quant_dc_chroma
= ((1<<16) + (w
->quant_dc_chroma
>>1)) / w
->quant_dc_chroma
;
745 x8_reset_vlc_tables(w
);
750 for(s
->mb_y
=0; s
->mb_y
< s
->mb_height
*2; s
->mb_y
++){
751 x8_init_block_index(s
);
752 mb_xy
=(s
->mb_y
>>1)*s
->mb_stride
;
754 for(s
->mb_x
=0; s
->mb_x
< s
->mb_width
*2; s
->mb_x
++){
755 x8_get_prediction(w
);
756 if(x8_setup_spatial_predictor(w
,0)) goto error
;
757 if(x8_decode_intra_mb(w
,0)) goto error
;
759 if( s
->mb_x
& s
->mb_y
& 1 ){
760 x8_get_prediction_chroma(w
);
762 /*when setting up chroma, no vlc is read,
763 so no error condition can be reached*/
764 x8_setup_spatial_predictor(w
,1);
765 if(x8_decode_intra_mb(w
,1)) goto error
;
767 x8_setup_spatial_predictor(w
,2);
768 if(x8_decode_intra_mb(w
,2)) goto error
;
773 /*emulate MB info in the relevant tables*/
774 s
->mbskip_table
[mb_xy
]=0;
775 s
->mbintra_table
[mb_xy
]=1;
776 s
->current_picture
.f
.qscale_table
[mb_xy
] = w
->quant
;
782 ff_draw_horiz_band(s
, (s
->mb_y
-1)*8, 16);
787 ff_er_add_slice(s
, s
->resync_mb_x
, s
->resync_mb_y
,
788 (s
->mb_x
>>1)-1, (s
->mb_y
>>1)-1,