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"
26 #include "error_resilience.h"
29 #include "mpegvideo.h"
30 #include "msmpeg4data.h"
31 #include "intrax8huf.h"
33 #include "intrax8dsp.h"
35 #define MAX_TABLE_DEPTH(table_bits, max_bits) ((max_bits+table_bits-1)/table_bits)
41 #define DC_VLC_MTD MAX_TABLE_DEPTH(DC_VLC_BITS, MAX_DC_VLC_BITS)
42 #define AC_VLC_MTD MAX_TABLE_DEPTH(AC_VLC_BITS, MAX_AC_VLC_BITS)
43 #define OR_VLC_MTD MAX_TABLE_DEPTH(OR_VLC_BITS, MAX_OR_VLC_BITS)
45 static VLC j_ac_vlc[2][2][8]; //[quant<13],[intra/inter],[select]
46 static VLC j_dc_vlc[2][8]; //[quant], [select]
47 static VLC j_orient_vlc[2][4]; //[quant], [select]
49 static av_cold void x8_vlc_init(void){
53 static const uint16_t sizes[8*4 + 8*2 + 2 + 4] = {
54 576, 548, 582, 618, 546, 616, 560, 642,
55 584, 582, 704, 664, 512, 544, 656, 640,
56 512, 648, 582, 566, 532, 614, 596, 648,
57 586, 552, 584, 590, 544, 578, 584, 624,
59 528, 528, 526, 528, 536, 528, 526, 544,
60 544, 512, 512, 528, 528, 544, 512, 544,
62 128, 128, 128, 128, 128, 128};
64 static VLC_TYPE table[28150][2];
66 #define init_ac_vlc(dst,src) \
67 dst.table = &table[offset]; \
68 dst.table_allocated = sizes[sizeidx]; \
69 offset += sizes[sizeidx++]; \
74 INIT_VLC_USE_NEW_STATIC)
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] );
85 #define init_dc_vlc(dst,src) \
86 dst.table = &table[offset]; \
87 dst.table_allocated = sizes[sizeidx]; \
88 offset += sizes[sizeidx++]; \
93 INIT_VLC_USE_NEW_STATIC);
95 init_dc_vlc( j_dc_vlc[0][i], x8_dc_highquant_table[i][0]);
96 init_dc_vlc( j_dc_vlc[1][i], x8_dc_lowquant_table [i][0]);
101 #define init_or_vlc(dst,src) \
102 dst.table = &table[offset]; \
103 dst.table_allocated = sizes[sizeidx]; \
104 offset += sizes[sizeidx++]; \
109 INIT_VLC_USE_NEW_STATIC);
111 init_or_vlc( j_orient_vlc[0][i], x8_orient_highquant_table[i][0]);
114 init_or_vlc( j_orient_vlc[1][i], x8_orient_lowquant_table [i][0])
116 if (offset != sizeof(table)/sizeof(VLC_TYPE)/2)
117 av_log(NULL, AV_LOG_ERROR, "table size %i does not match needed %i\n", (int)(sizeof(table)/sizeof(VLC_TYPE)/2), offset);
121 static void x8_reset_vlc_tables(IntraX8Context * w){
122 memset(w->j_dc_vlc,0,sizeof(w->j_dc_vlc));
123 memset(w->j_ac_vlc,0,sizeof(w->j_ac_vlc));
124 w->j_orient_vlc=NULL;
127 static inline void x8_select_ac_table(IntraX8Context * const w , int mode){
128 MpegEncContext * const s= w->s;
133 if( w->j_ac_vlc[mode] ) return;
135 table_index = get_bits(&s->gb, 3);
136 w->j_ac_vlc[mode] = &j_ac_vlc[w->quant<13][mode>>1][table_index];//2 modes use same tables
137 av_assert2(w->j_ac_vlc[mode]);
140 static inline int x8_get_orient_vlc(IntraX8Context * w){
141 MpegEncContext * const s= w->s;
144 if(!w->j_orient_vlc ){
145 table_index = get_bits(&s->gb, 1+(w->quant<13) );
146 w->j_orient_vlc = &j_orient_vlc[w->quant<13][table_index];
149 return get_vlc2(&s->gb, w->j_orient_vlc->table, OR_VLC_BITS, OR_VLC_MTD);
152 #define extra_bits(eb) (eb)
153 #define extra_run (0xFF<<8)
154 #define extra_level (0x00<<8)
155 #define run_offset(r) ((r)<<16)
156 #define level_offset(l) ((l)<<24)
157 static const uint32_t ac_decode_table[]={
158 /*46*/ extra_bits(3) | extra_run | run_offset(16) | level_offset( 0),
159 /*47*/ extra_bits(3) | extra_run | run_offset(24) | level_offset( 0),
160 /*48*/ extra_bits(2) | extra_run | run_offset( 4) | level_offset( 1),
161 /*49*/ extra_bits(3) | extra_run | run_offset( 8) | level_offset( 1),
163 /*50*/ extra_bits(5) | extra_run | run_offset(32) | level_offset( 0),
164 /*51*/ extra_bits(4) | extra_run | run_offset(16) | level_offset( 1),
166 /*52*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
167 /*53*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 8),
168 /*54*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset(12),
169 /*55*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(16),
170 /*56*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(24),
172 /*57*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
173 /*58*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
175 /*59*/ extra_bits(2) | extra_run | run_offset(16) | level_offset( 0),
176 /*60*/ extra_bits(2) | extra_run | run_offset(20) | level_offset( 0),
177 /*61*/ extra_bits(2) | extra_run | run_offset(24) | level_offset( 0),
178 /*62*/ extra_bits(2) | extra_run | run_offset(28) | level_offset( 0),
179 /*63*/ extra_bits(4) | extra_run | run_offset(32) | level_offset( 0),
180 /*64*/ extra_bits(4) | extra_run | run_offset(48) | level_offset( 0),
182 /*65*/ extra_bits(2) | extra_run | run_offset( 4) | level_offset( 1),
183 /*66*/ extra_bits(3) | extra_run | run_offset( 8) | level_offset( 1),
184 /*67*/ extra_bits(4) | extra_run | run_offset(16) | level_offset( 1),
186 /*68*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
187 /*69*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset( 8),
188 /*70*/ extra_bits(4) | extra_level | run_offset( 0) | level_offset(16),
190 /*71*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
191 /*72*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
193 //extra_bits = 3bits; extra_run/level = 1 bit; run_offset = 6bits; level_offset = 5 bits;
200 static void x8_get_ac_rlf(IntraX8Context * const w, const int mode,
201 int * const run, int * const level, int * const final){
202 MpegEncContext * const s= w->s;
205 // x8_select_ac_table(w,mode);
206 i = get_vlc2(&s->gb, w->j_ac_vlc[mode]->table, AC_VLC_BITS, AC_VLC_MTD);
211 (*level)=(*final)=//prevent 'may be used unilitialized'
212 (*run)=64;//this would cause error exit in the ac loop
216 (*final) = t = (i>22);
219 i== 0-15 r=0-15 l=0 ;r=i& %01111
220 i==16-19 r=0-3 l=1 ;r=i& %00011
221 i==20-21 r=0-1 l=2 ;r=i& %00001
222 i==22 r=0 l=3 ;r=i& %00000
223 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
224 t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter */
225 l=(0xE50000>>(i&(0x1E)))&3;/*0x1E or (~1) or ((i>>1)<<1)*/
226 t=(0x01030F>>(l<<3));
230 }else if(i<73){//[46-72]
235 sm=ac_decode_table[i];
237 e=get_bits(&s->gb,sm&0xF);sm>>=8;//3bits
238 mask=sm&0xff;sm>>=8; //1bit
240 (*run) =(sm&0xff) + (e&( mask));//6bits
241 (*level)=(sm>>8) + (e&(~mask));//5bits
243 }else if(i<75){//[73-74]
244 static const uint8_t crazy_mix_runlevel[32]={
245 0x22,0x32,0x33,0x53,0x23,0x42,0x43,0x63,
246 0x24,0x52,0x34,0x73,0x25,0x62,0x44,0x83,
247 0x26,0x72,0x35,0x54,0x27,0x82,0x45,0x64,
248 0x28,0x92,0x36,0x74,0x29,0xa2,0x46,0x84};
251 e=get_bits(&s->gb,5);//get the extra bits
252 (*run) =crazy_mix_runlevel[e]>>4;
253 (*level)=crazy_mix_runlevel[e]&0x0F;
255 (*level)=get_bits( &s->gb, 7-3*(i&1));
256 (*run) =get_bits( &s->gb, 6);
257 (*final)=get_bits1(&s->gb);
262 //static const uint8_t dc_extra_sbits[] ={0, 1,1, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 };
263 static const uint8_t dc_index_offset[] ={ 0, 1,2, 3,4, 5,7, 9,13, 17,25, 33,49, 65,97, 129,193};
265 static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const level, int * const final){
266 MpegEncContext * const s= w->s;
270 if( !w->j_dc_vlc[mode] ) {
272 table_index = get_bits(&s->gb, 3);
273 //4 modes, same table
274 w->j_dc_vlc[mode]= &j_dc_vlc[w->quant<13][table_index];
277 i=get_vlc2(&s->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
279 /*(i>=17) {i-=17;final=1;}*/
288 c=(i+1)>>1;//hackish way to calculate dc_extra_sbits[]
291 e=get_bits(&s->gb,c);//get the extra bits
292 i=dc_index_offset[i]+(e>>1);
294 e= -(e & 1);//0,0xffffff
295 (*level)= (i ^ e) - e;// (i^0)-0 , (i^0xff)-(-1)
300 static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma){
301 MpegEncContext * const s= w->s;
306 w->dsp.setup_spatial_compensation(s->dest[chroma], s->sc.edge_emu_buffer,
307 s->current_picture.f->linesize[chroma>0],
308 &range, &sum, w->edges);
310 w->orient=w->chroma_orient;
311 quant=w->quant_dc_chroma;
317 if(range < quant || range < 3){
319 if(range < 3){//yep you read right, a +-1 idct error may break decoding!
322 w->predicted_dc = (sum*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899
328 av_assert2(w->orient < 3);
329 if(range < 2*w->quant){
330 if( (w->edges&3) == 0){
331 if(w->orient==1) w->orient=11;
332 if(w->orient==2) w->orient=10;
338 static const uint8_t prediction_table[3][12]={
339 {0,8,4, 10,11, 2,6,9,1,3,5,7},
340 {4,0,8, 11,10, 3,5,2,6,9,1,7},
341 {8,0,4, 10,11, 1,7,2,6,9,3,5}
343 w->raw_orient=x8_get_orient_vlc(w);
344 if(w->raw_orient<0) return -1;
345 av_assert2(w->raw_orient < 12 );
346 av_assert2(w->orient<3);
347 w->orient=prediction_table[w->orient][w->raw_orient];
352 static void x8_update_predictions(IntraX8Context * const w, const int orient, const int est_run ){
353 MpegEncContext * const s= w->s;
355 w->prediction_table[s->mb_x*2+(s->mb_y&1)] = (est_run<<2) + 1*(orient==4) + 2*(orient==8);
361 static void x8_get_prediction_chroma(IntraX8Context * const w){
362 MpegEncContext * const s= w->s;
364 w->edges = 1*( !(s->mb_x>>1) );
365 w->edges|= 2*( !(s->mb_y>>1) );
366 w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );//mb_x for chroma would always be odd
369 if(w->edges&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC
370 w->chroma_orient=4<<((0xCC>>w->edges)&1);
373 w->chroma_orient = (w->prediction_table[2*s->mb_x-2] & 0x03)<<2;//block[x-1][y|1-1)]
376 static void x8_get_prediction(IntraX8Context * const w){
377 MpegEncContext * const s= w->s;
380 w->edges = 1*( !s->mb_x );
381 w->edges|= 2*( !s->mb_y );
382 w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );
388 //take the one from the above block[0][y-1]
389 w->est_run = w->prediction_table[!(s->mb_y&1)]>>2;
393 //take the one from the previous block[x-1][0]
394 w->est_run = w->prediction_table[2*s->mb_x-2]>>2;
403 b= w->prediction_table[2*s->mb_x + !(s->mb_y&1) ];//block[x ][y-1]
404 a= w->prediction_table[2*s->mb_x-2 + (s->mb_y&1) ];//block[x-1][y ]
405 c= w->prediction_table[2*s->mb_x-2 + !(s->mb_y&1) ];//block[x-1][y-1]
407 w->est_run = FFMIN(b,a);
408 /* This condition has nothing to do with w->edges, even if it looks
409 similar it would trigger if e.g. x=3;y=2;
410 I guess somebody wrote something wrong and it became standard. */
411 if( (s->mb_x & s->mb_y) != 0 ) w->est_run=FFMIN(c,w->est_run);
418 i=( 0xFFEAF4C4>>(2*b+8*a) )&3;
419 if(i!=3) w->orient=i;
420 else w->orient=( 0xFFEAD8>>(2*c+8*(w->quant>12)) )&3;
426 pad 2 2 2; pad X 1 0; pad 0 1 0 <-
427 -> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4
432 pad 2 2 2; pad 1 2 0 <-
433 -> 11 10'10 10 '11 01'10 00=>0xEAD8
438 static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){
439 MpegEncContext * const s= w->s;
441 #define B(x,y) s->block[0][w->idct_permutation[(x)+(y)*8]]
442 #define T(x) ((x) * dc_level + 0x8000) >> 16;
485 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
493 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
501 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7);
508 static void dsp_x8_put_solidcolor(uint8_t const pix, uint8_t * dst, int const linesize){
516 static const int16_t quant_table[64] = {
517 256, 256, 256, 256, 256, 256, 259, 262,
518 265, 269, 272, 275, 278, 282, 285, 288,
519 292, 295, 299, 303, 306, 310, 314, 317,
520 321, 325, 329, 333, 337, 341, 345, 349,
521 353, 358, 362, 366, 371, 375, 379, 384,
522 389, 393, 398, 403, 408, 413, 417, 422,
523 428, 433, 438, 443, 448, 454, 459, 465,
524 470, 476, 482, 488, 493, 499, 505, 511
527 static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
528 MpegEncContext * const s= w->s;
532 int ac_mode,dc_mode,est_run,dc_level;
535 int use_quant_matrix;
538 av_assert2(w->orient<12);
539 s->bdsp.clear_block(s->block[0]);
544 dc_mode=!!w->est_run;//0,1
547 if(x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) return -1;
550 if(!final){//decode ac
551 use_quant_matrix=w->use_quant_matrix;
554 est_run = 64;//not used
556 if (w->raw_orient < 3){
557 use_quant_matrix = 0;
559 if(w->raw_orient > 4){
572 x8_select_ac_table(w,ac_mode);
573 /*scantable_selector[12]={0,2,0,1,1,1,0,2,2,0,1,2};<-
574 -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 =>0x928548 */
575 scantable = w->scantable[ (0x928548>>(2*w->orient))&3 ].permutated;
581 x8_select_ac_table(w,3);
584 x8_get_ac_rlf(w,ac_mode,&run,&level,&final);
588 //this also handles vlc error in x8_get_ac_rlf
591 level= (level+1) * w->dquant;
594 sign = - get_bits1(&s->gb);
595 level = (level ^ sign) - sign;
597 if(use_quant_matrix){
598 level = (level*quant_table[pos])>>8;
600 s->block[0][ scantable[pos] ]=level;
603 s->block_last_index[0]=pos;
605 s->block_last_index[0]=0;
606 if(w->flat_dc && ((unsigned)(dc_level+1)) < 3){//[-1;1]
607 int32_t divide_quant= !chroma ? w->divide_quant_dc_luma:
608 w->divide_quant_dc_chroma;
609 int32_t dc_quant = !chroma ? w->quant:
612 //original intent dc_level+=predicted_dc/quant; but it got lost somewhere in the rounding
613 dc_level+= (w->predicted_dc*divide_quant + (1<<12) )>>13;
615 dsp_x8_put_solidcolor( av_clip_uint8((dc_level*dc_quant+4)>>3),
616 s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
620 zeros_only = (dc_level == 0);
623 s->block[0][0] = dc_level*w->quant;
625 s->block[0][0] = dc_level*w->quant_dc_chroma;
628 //there is !zero_only check in the original, but dc_level check is enough
629 if( (unsigned int)(dc_level+1) >= 3 && (w->edges&3) != 3 ){
631 /*ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 };<-
632 -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 =>0x6A017C */
633 direction= (0x6A017C>>(w->orient*2))&3;
635 x8_ac_compensation(w, direction, s->block[0][0]);//modify block_last[]
640 dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
642 w->dsp.spatial_compensation[w->orient]( s->sc.edge_emu_buffer,
644 s->current_picture.f->linesize[!!chroma] );
647 w->wdsp.idct_add(s->dest[chroma],
648 s->current_picture.f->linesize[!!chroma],
654 x8_update_predictions(w,w->orient,n);
658 uint8_t* ptr = s->dest[chroma];
659 int linesize = s->current_picture.f->linesize[!!chroma];
661 if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){
662 w->dsp.h_loop_filter(ptr, linesize, w->quant);
664 if(!( (w->edges&1) || ( zeros_only && (w->orient|8)==8 ) )){
665 w->dsp.v_loop_filter(ptr, linesize, w->quant);
671 static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_*
672 //not s->linesize as this would be wrong for field pics
673 //not that IntraX8 has interlacing support ;)
674 const int linesize = s->current_picture.f->linesize[0];
675 const int uvlinesize = s->current_picture.f->linesize[1];
677 s->dest[0] = s->current_picture.f->data[0];
678 s->dest[1] = s->current_picture.f->data[1];
679 s->dest[2] = s->current_picture.f->data[2];
681 s->dest[0] += s->mb_y * linesize << 3;
682 s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows
683 s->dest[2] += ( s->mb_y&(~1) ) * uvlinesize << 2;
687 * Initialize IntraX8 frame decoder.
688 * Requires valid MpegEncContext with valid s->mb_width before calling.
689 * @param w pointer to IntraX8Context
690 * @param s pointer to MpegEncContext of the parent codec
692 av_cold void ff_intrax8_common_init(IntraX8Context * w, MpegEncContext * const s){
696 av_assert0(s->mb_width>0);
697 w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
699 ff_wmv2dsp_init(&w->wdsp);
700 ff_init_scantable_permutation(w->idct_permutation,
703 ff_init_scantable(w->idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
704 ff_init_scantable(w->idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
705 ff_init_scantable(w->idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
707 ff_intrax8dsp_init(&w->dsp);
711 * Destroy IntraX8 frame structure.
712 * @param w pointer to IntraX8Context
714 av_cold void ff_intrax8_common_end(IntraX8Context * w)
716 av_freep(&w->prediction_table);
720 * Decode single IntraX8 frame.
721 * The parent codec must fill s->loopfilter and s->gb (bitstream).
722 * The parent codec must call ff_mpv_frame_start(), ff_er_frame_start() before calling this function.
723 * The parent codec must call ff_er_frame_end(), ff_mpv_frame_end() after calling this function.
724 * This function does not use ff_mpv_decode_mb().
725 * lowres decoding is theoretically impossible.
726 * @param w pointer to IntraX8Context
727 * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
728 * @param quant_offset offset away from zero
730 int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_offset){
731 MpegEncContext * const s= w->s;
733 w->use_quant_matrix = get_bits1(&s->gb);
736 w->quant = dquant >> 1;
737 w->qsum = quant_offset;
739 w->divide_quant_dc_luma = ((1<<16) + (w->quant>>1)) / w->quant;
741 w->quant_dc_chroma = w->quant;
742 w->divide_quant_dc_chroma = w->divide_quant_dc_luma;
744 w->quant_dc_chroma = w->quant+((w->quant+3)>>3);
745 w->divide_quant_dc_chroma = ((1<<16) + (w->quant_dc_chroma>>1)) / w->quant_dc_chroma;
747 x8_reset_vlc_tables(w);
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;
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;
761 if( s->mb_x & s->mb_y & 1 ){
762 x8_get_prediction_chroma(w);
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;
769 x8_setup_spatial_predictor(w,2);
770 if(x8_decode_intra_mb(w,2)) goto error;
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;
784 ff_mpeg_draw_horiz_band(s, (s->mb_y-1)*8, 16);
789 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
790 (s->mb_x>>1)-1, (s->mb_y>>1)-1,