2 * This file is part of FFmpeg.
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.
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.
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
21 * @brief IntraX8 (J-Frame) subdecoder, used by WMV2 and VC-1
24 #include "libavutil/avassert.h"
27 #include "mpegvideo.h"
28 #include "msmpeg4data.h"
29 #include "intrax8huf.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 av_assert2(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];
146 return get_vlc2(&s->gb, w->j_orient_vlc->table, OR_VLC_BITS, OR_VLC_MTD);
149 #define extra_bits(eb) (eb)
150 #define extra_run (0xFF<<8)
151 #define extra_level (0x00<<8)
152 #define run_offset(r) ((r)<<16)
153 #define level_offset(l) ((l)<<24)
154 static const uint32_t ac_decode_table[]={
155 /*46*/ extra_bits(3) | extra_run | run_offset(16) | level_offset( 0),
156 /*47*/ extra_bits(3) | extra_run | run_offset(24) | level_offset( 0),
157 /*48*/ extra_bits(2) | extra_run | run_offset( 4) | level_offset( 1),
158 /*49*/ extra_bits(3) | extra_run | run_offset( 8) | level_offset( 1),
160 /*50*/ extra_bits(5) | extra_run | run_offset(32) | level_offset( 0),
161 /*51*/ extra_bits(4) | extra_run | run_offset(16) | level_offset( 1),
163 /*52*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
164 /*53*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 8),
165 /*54*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset(12),
166 /*55*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(16),
167 /*56*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(24),
169 /*57*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
170 /*58*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
172 /*59*/ extra_bits(2) | extra_run | run_offset(16) | level_offset( 0),
173 /*60*/ extra_bits(2) | extra_run | run_offset(20) | level_offset( 0),
174 /*61*/ extra_bits(2) | extra_run | run_offset(24) | level_offset( 0),
175 /*62*/ extra_bits(2) | extra_run | run_offset(28) | level_offset( 0),
176 /*63*/ extra_bits(4) | extra_run | run_offset(32) | level_offset( 0),
177 /*64*/ extra_bits(4) | extra_run | run_offset(48) | level_offset( 0),
179 /*65*/ extra_bits(2) | extra_run | run_offset( 4) | level_offset( 1),
180 /*66*/ extra_bits(3) | extra_run | run_offset( 8) | level_offset( 1),
181 /*67*/ extra_bits(4) | extra_run | run_offset(16) | level_offset( 1),
183 /*68*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
184 /*69*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset( 8),
185 /*70*/ extra_bits(4) | extra_level | run_offset( 0) | level_offset(16),
187 /*71*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
188 /*72*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
190 //extra_bits = 3bits; extra_run/level = 1 bit; run_offset = 6bits; level_offset = 5 bits;
197 static void x8_get_ac_rlf(IntraX8Context * const w, const int mode,
198 int * const run, int * const level, int * const final){
199 MpegEncContext * const s= w->s;
202 // x8_select_ac_table(w,mode);
203 i = get_vlc2(&s->gb, w->j_ac_vlc[mode]->table, AC_VLC_BITS, AC_VLC_MTD);
208 (*level)=(*final)=//prevent 'may be used unilitialized'
209 (*run)=64;//this would cause error exit in the ac loop
213 (*final) = t = (i>22);
216 i== 0-15 r=0-15 l=0 ;r=i& %01111
217 i==16-19 r=0-3 l=1 ;r=i& %00011
218 i==20-21 r=0-1 l=2 ;r=i& %00001
219 i==22 r=0 l=3 ;r=i& %00000
220 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
221 t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter */
222 l=(0xE50000>>(i&(0x1E)))&3;/*0x1E or (~1) or ((i>>1)<<1)*/
223 t=(0x01030F>>(l<<3));
227 }else if(i<73){//[46-72]
232 sm=ac_decode_table[i];
234 e=get_bits(&s->gb,sm&0xF);sm>>=8;//3bits
235 mask=sm&0xff;sm>>=8; //1bit
237 (*run) =(sm&0xff) + (e&( mask));//6bits
238 (*level)=(sm>>8) + (e&(~mask));//5bits
240 }else if(i<75){//[73-74]
241 static const uint8_t crazy_mix_runlevel[32]={
242 0x22,0x32,0x33,0x53,0x23,0x42,0x43,0x63,
243 0x24,0x52,0x34,0x73,0x25,0x62,0x44,0x83,
244 0x26,0x72,0x35,0x54,0x27,0x82,0x45,0x64,
245 0x28,0x92,0x36,0x74,0x29,0xa2,0x46,0x84};
248 e=get_bits(&s->gb,5);//get the extra bits
249 (*run) =crazy_mix_runlevel[e]>>4;
250 (*level)=crazy_mix_runlevel[e]&0x0F;
252 (*level)=get_bits( &s->gb, 7-3*(i&1));
253 (*run) =get_bits( &s->gb, 6);
254 (*final)=get_bits1(&s->gb);
259 //static const uint8_t dc_extra_sbits[] ={0, 1,1, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 };
260 static const uint8_t dc_index_offset[] ={ 0, 1,2, 3,4, 5,7, 9,13, 17,25, 33,49, 65,97, 129,193};
262 static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const level, int * const final){
263 MpegEncContext * const s= w->s;
267 if( !w->j_dc_vlc[mode] ) {
269 table_index = get_bits(&s->gb, 3);
270 //4 modes, same table
271 w->j_dc_vlc[mode]= &j_dc_vlc[w->quant<13][table_index];
274 i=get_vlc2(&s->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
276 /*(i>=17) {i-=17;final=1;}*/
285 c=(i+1)>>1;//hackish way to calculate dc_extra_sbits[]
288 e=get_bits(&s->gb,c);//get the extra bits
289 i=dc_index_offset[i]+(e>>1);
291 e= -(e & 1);//0,0xffffff
292 (*level)= (i ^ e) - e;// (i^0)-0 , (i^0xff)-(-1)
297 static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma){
298 MpegEncContext * const s= w->s;
303 s->dsp.x8_setup_spatial_compensation(s->dest[chroma], s->edge_emu_buffer,
304 s->current_picture.f.linesize[chroma>0],
305 &range, &sum, w->edges);
307 w->orient=w->chroma_orient;
308 quant=w->quant_dc_chroma;
314 if(range < quant || range < 3){
316 if(range < 3){//yep you read right, a +-1 idct error may break decoding!
319 w->predicted_dc = (sum*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899
325 av_assert2(w->orient < 3);
326 if(range < 2*w->quant){
327 if( (w->edges&3) == 0){
328 if(w->orient==1) w->orient=11;
329 if(w->orient==2) w->orient=10;
335 static const uint8_t prediction_table[3][12]={
336 {0,8,4, 10,11, 2,6,9,1,3,5,7},
337 {4,0,8, 11,10, 3,5,2,6,9,1,7},
338 {8,0,4, 10,11, 1,7,2,6,9,3,5}
340 w->raw_orient=x8_get_orient_vlc(w);
341 if(w->raw_orient<0) return -1;
342 av_assert2(w->raw_orient < 12 );
343 av_assert2(w->orient<3);
344 w->orient=prediction_table[w->orient][w->raw_orient];
349 static void x8_update_predictions(IntraX8Context * const w, const int orient, const int est_run ){
350 MpegEncContext * const s= w->s;
352 w->prediction_table[s->mb_x*2+(s->mb_y&1)] = (est_run<<2) + 1*(orient==4) + 2*(orient==8);
358 static void x8_get_prediction_chroma(IntraX8Context * const w){
359 MpegEncContext * const s= w->s;
361 w->edges = 1*( !(s->mb_x>>1) );
362 w->edges|= 2*( !(s->mb_y>>1) );
363 w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );//mb_x for chroma would always be odd
366 if(w->edges&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC
367 w->chroma_orient=4<<((0xCC>>w->edges)&1);
370 w->chroma_orient = (w->prediction_table[2*s->mb_x-2] & 0x03)<<2;//block[x-1][y|1-1)]
373 static void x8_get_prediction(IntraX8Context * const w){
374 MpegEncContext * const s= w->s;
377 w->edges = 1*( !s->mb_x );
378 w->edges|= 2*( !s->mb_y );
379 w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );
385 //take the one from the above block[0][y-1]
386 w->est_run = w->prediction_table[!(s->mb_y&1)]>>2;
390 //take the one from the previous block[x-1][0]
391 w->est_run = w->prediction_table[2*s->mb_x-2]>>2;
400 b= w->prediction_table[2*s->mb_x + !(s->mb_y&1) ];//block[x ][y-1]
401 a= w->prediction_table[2*s->mb_x-2 + (s->mb_y&1) ];//block[x-1][y ]
402 c= w->prediction_table[2*s->mb_x-2 + !(s->mb_y&1) ];//block[x-1][y-1]
404 w->est_run = FFMIN(b,a);
405 /* This condition has nothing to do with w->edges, even if it looks
406 similar it would trigger if e.g. x=3;y=2;
407 I guess somebody wrote something wrong and it became standard. */
408 if( (s->mb_x & s->mb_y) != 0 ) w->est_run=FFMIN(c,w->est_run);
415 i=( 0xFFEAF4C4>>(2*b+8*a) )&3;
416 if(i!=3) w->orient=i;
417 else w->orient=( 0xFFEAD8>>(2*c+8*(w->quant>12)) )&3;
423 pad 2 2 2; pad X 1 0; pad 0 1 0 <-
424 -> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4
429 pad 2 2 2; pad 1 2 0 <-
430 -> 11 10'10 10 '11 01'10 00=>0xEAD8
435 static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){
436 MpegEncContext * const s= w->s;
438 #define B(x,y) s->block[0][s->dsp.idct_permutation[(x)+(y)*8]]
439 #define T(x) ((x) * dc_level + 0x8000) >> 16;
482 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
490 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
498 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7);
505 static void dsp_x8_put_solidcolor(uint8_t const pix, uint8_t * dst, int const linesize){
513 static const int16_t quant_table[64] = {
514 256, 256, 256, 256, 256, 256, 259, 262,
515 265, 269, 272, 275, 278, 282, 285, 288,
516 292, 295, 299, 303, 306, 310, 314, 317,
517 321, 325, 329, 333, 337, 341, 345, 349,
518 353, 358, 362, 366, 371, 375, 379, 384,
519 389, 393, 398, 403, 408, 413, 417, 422,
520 428, 433, 438, 443, 448, 454, 459, 465,
521 470, 476, 482, 488, 493, 499, 505, 511
524 static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
525 MpegEncContext * const s= w->s;
529 int ac_mode,dc_mode,est_run,dc_level;
532 int use_quant_matrix;
535 av_assert2(w->orient<12);
536 s->dsp.clear_block(s->block[0]);
541 dc_mode=!!w->est_run;//0,1
544 if(x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) return -1;
547 if(!final){//decode ac
548 use_quant_matrix=w->use_quant_matrix;
551 est_run = 64;//not used
553 if (w->raw_orient < 3){
554 use_quant_matrix = 0;
556 if(w->raw_orient > 4){
569 x8_select_ac_table(w,ac_mode);
570 /*scantable_selector[12]={0,2,0,1,1,1,0,2,2,0,1,2};<-
571 -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 =>0x928548 */
572 scantable = w->scantable[ (0x928548>>(2*w->orient))&3 ].permutated;
578 x8_select_ac_table(w,3);
581 x8_get_ac_rlf(w,ac_mode,&run,&level,&final);
585 //this also handles vlc error in x8_get_ac_rlf
588 level= (level+1) * w->dquant;
591 sign = - get_bits1(&s->gb);
592 level = (level ^ sign) - sign;
594 if(use_quant_matrix){
595 level = (level*quant_table[pos])>>8;
597 s->block[0][ scantable[pos] ]=level;
600 s->block_last_index[0]=pos;
602 s->block_last_index[0]=0;
603 if(w->flat_dc && ((unsigned)(dc_level+1)) < 3){//[-1;1]
604 int32_t divide_quant= !chroma ? w->divide_quant_dc_luma:
605 w->divide_quant_dc_chroma;
606 int32_t dc_quant = !chroma ? w->quant:
609 //original intent dc_level+=predicted_dc/quant; but it got lost somewhere in the rounding
610 dc_level+= (w->predicted_dc*divide_quant + (1<<12) )>>13;
612 dsp_x8_put_solidcolor( av_clip_uint8((dc_level*dc_quant+4)>>3),
613 s->dest[chroma], s->current_picture.f.linesize[!!chroma]);
617 zeros_only = (dc_level == 0);
620 s->block[0][0] = dc_level*w->quant;
622 s->block[0][0] = dc_level*w->quant_dc_chroma;
625 //there is !zero_only check in the original, but dc_level check is enough
626 if( (unsigned int)(dc_level+1) >= 3 && (w->edges&3) != 3 ){
628 /*ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 };<-
629 -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 =>0x6A017C */
630 direction= (0x6A017C>>(w->orient*2))&3;
632 x8_ac_compensation(w, direction, s->block[0][0]);//modify block_last[]
637 dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f.linesize[!!chroma]);
639 s->dsp.x8_spatial_compensation[w->orient]( s->edge_emu_buffer,
641 s->current_picture.f.linesize[!!chroma] );
644 s->dsp.idct_add ( s->dest[chroma],
645 s->current_picture.f.linesize[!!chroma],
651 x8_update_predictions(w,w->orient,n);
655 uint8_t* ptr = s->dest[chroma];
656 int linesize = s->current_picture.f.linesize[!!chroma];
658 if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){
659 s->dsp.x8_h_loop_filter(ptr, linesize, w->quant);
661 if(!( (w->edges&1) || ( zeros_only && (w->orient|8)==8 ) )){
662 s->dsp.x8_v_loop_filter(ptr, linesize, w->quant);
668 static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_*
669 //not s->linesize as this would be wrong for field pics
670 //not that IntraX8 has interlacing support ;)
671 const int linesize = s->current_picture.f.linesize[0];
672 const int uvlinesize = s->current_picture.f.linesize[1];
674 s->dest[0] = s->current_picture.f.data[0];
675 s->dest[1] = s->current_picture.f.data[1];
676 s->dest[2] = s->current_picture.f.data[2];
678 s->dest[0] += s->mb_y * linesize << 3;
679 s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows
680 s->dest[2] += ( s->mb_y&(~1) ) * uvlinesize << 2;
684 * Initialize IntraX8 frame decoder.
685 * Requires valid MpegEncContext with valid s->mb_width before calling.
686 * @param w pointer to IntraX8Context
687 * @param s pointer to MpegEncContext of the parent codec
689 av_cold void ff_intrax8_common_init(IntraX8Context * w, MpegEncContext * const s){
693 av_assert0(s->mb_width>0);
694 w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
696 ff_init_scantable(s->dsp.idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
697 ff_init_scantable(s->dsp.idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
698 ff_init_scantable(s->dsp.idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
702 * Destroy IntraX8 frame structure.
703 * @param w pointer to IntraX8Context
705 av_cold void ff_intrax8_common_end(IntraX8Context * w)
707 av_freep(&w->prediction_table);
711 * Decode single IntraX8 frame.
712 * The parent codec must fill s->loopfilter and s->gb (bitstream).
713 * The parent codec must call MPV_frame_start(), ff_er_frame_start() before calling this function.
714 * The parent codec must call ff_er_frame_end(), MPV_frame_end() after calling this function.
715 * This function does not use MPV_decode_mb().
716 * lowres decoding is theoretically impossible.
717 * @param w pointer to IntraX8Context
718 * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
719 * @param quant_offset offset away from zero
721 //FIXME extern uint8_t ff_wmv3_dc_scale_table[32];
722 int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_offset){
723 MpegEncContext * const s= w->s;
725 w->use_quant_matrix = get_bits1(&s->gb);
728 w->quant = dquant >> 1;
729 w->qsum = quant_offset;
731 w->divide_quant_dc_luma = ((1<<16) + (w->quant>>1)) / w->quant;
733 w->quant_dc_chroma = w->quant;
734 w->divide_quant_dc_chroma = w->divide_quant_dc_luma;
736 w->quant_dc_chroma = w->quant+((w->quant+3)>>3);
737 w->divide_quant_dc_chroma = ((1<<16) + (w->quant_dc_chroma>>1)) / w->quant_dc_chroma;
739 x8_reset_vlc_tables(w);
744 for(s->mb_y=0; s->mb_y < s->mb_height*2; s->mb_y++){
745 x8_init_block_index(s);
746 mb_xy=(s->mb_y>>1)*s->mb_stride;
748 for(s->mb_x=0; s->mb_x < s->mb_width*2; s->mb_x++){
749 x8_get_prediction(w);
750 if(x8_setup_spatial_predictor(w,0)) goto error;
751 if(x8_decode_intra_mb(w,0)) goto error;
753 if( s->mb_x & s->mb_y & 1 ){
754 x8_get_prediction_chroma(w);
756 /*when setting up chroma, no vlc is read,
757 so no error condition can be reached*/
758 x8_setup_spatial_predictor(w,1);
759 if(x8_decode_intra_mb(w,1)) goto error;
761 x8_setup_spatial_predictor(w,2);
762 if(x8_decode_intra_mb(w,2)) goto error;
767 /*emulate MB info in the relevant tables*/
768 s->mbskip_table [mb_xy]=0;
769 s->mbintra_table[mb_xy]=1;
770 s->current_picture.f.qscale_table[mb_xy] = w->quant;
776 ff_draw_horiz_band(s, (s->mb_y-1)*8, 16);
781 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y,
782 (s->mb_x>>1)-1, (s->mb_y>>1)-1,