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
25 #include "error_resilience.h"
28 #include "mpegvideo.h"
29 #include "msmpeg4data.h"
30 #include "intrax8huf.h"
32 #include "intrax8dsp.h"
34 #define MAX_TABLE_DEPTH(table_bits, max_bits) ((max_bits+table_bits-1)/table_bits)
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)
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]
48 static av_cold void x8_vlc_init(void){
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,
58 528, 528, 526, 528, 536, 528, 526, 544,
59 544, 512, 512, 528, 528, 544, 512, 544,
61 128, 128, 128, 128, 128, 128};
63 static VLC_TYPE table[28150][2];
65 #define init_ac_vlc(dst,src) \
66 dst.table = &table[offset]; \
67 dst.table_allocated = sizes[sizeidx]; \
68 offset += sizes[sizeidx++]; \
73 INIT_VLC_USE_NEW_STATIC)
76 init_ac_vlc( j_ac_vlc[0][0][i], x8_ac0_highquant_table[i][0] );
77 init_ac_vlc( j_ac_vlc[0][1][i], x8_ac1_highquant_table[i][0] );
78 init_ac_vlc( j_ac_vlc[1][0][i], x8_ac0_lowquant_table [i][0] );
79 init_ac_vlc( j_ac_vlc[1][1][i], x8_ac1_lowquant_table [i][0] );
84 #define init_dc_vlc(dst,src) \
85 dst.table = &table[offset]; \
86 dst.table_allocated = sizes[sizeidx]; \
87 offset += sizes[sizeidx++]; \
92 INIT_VLC_USE_NEW_STATIC);
94 init_dc_vlc( j_dc_vlc[0][i], x8_dc_highquant_table[i][0]);
95 init_dc_vlc( j_dc_vlc[1][i], x8_dc_lowquant_table [i][0]);
100 #define init_or_vlc(dst,src) \
101 dst.table = &table[offset]; \
102 dst.table_allocated = sizes[sizeidx]; \
103 offset += sizes[sizeidx++]; \
108 INIT_VLC_USE_NEW_STATIC);
110 init_or_vlc( j_orient_vlc[0][i], x8_orient_highquant_table[i][0]);
113 init_or_vlc( j_orient_vlc[1][i], x8_orient_lowquant_table [i][0])
115 if (offset != sizeof(table)/sizeof(VLC_TYPE)/2)
116 av_log(NULL, AV_LOG_ERROR, "table size %i does not match needed %i\n", (int)(sizeof(table)/sizeof(VLC_TYPE)/2), offset);
120 static void x8_reset_vlc_tables(IntraX8Context * w){
121 memset(w->j_dc_vlc,0,sizeof(w->j_dc_vlc));
122 memset(w->j_ac_vlc,0,sizeof(w->j_ac_vlc));
123 w->j_orient_vlc=NULL;
126 static inline void x8_select_ac_table(IntraX8Context * const w , int mode){
127 MpegEncContext * const s= w->s;
132 if( w->j_ac_vlc[mode] ) return;
134 table_index = get_bits(&s->gb, 3);
135 w->j_ac_vlc[mode] = &j_ac_vlc[w->quant<13][mode>>1][table_index];//2 modes use same tables
136 assert(w->j_ac_vlc[mode]);
139 static inline int x8_get_orient_vlc(IntraX8Context * w){
140 MpegEncContext * const s= w->s;
143 if(!w->j_orient_vlc ){
144 table_index = get_bits(&s->gb, 1+(w->quant<13) );
145 w->j_orient_vlc = &j_orient_vlc[w->quant<13][table_index];
147 assert(w->j_orient_vlc);
148 assert(w->j_orient_vlc->table);
150 return get_vlc2(&s->gb, w->j_orient_vlc->table, OR_VLC_BITS, OR_VLC_MTD);
153 #define extra_bits(eb) (eb)
154 #define extra_run (0xFF<<8)
155 #define extra_level (0x00<<8)
156 #define run_offset(r) ((r)<<16)
157 #define level_offset(l) ((l)<<24)
158 static const uint32_t ac_decode_table[]={
159 /*46*/ extra_bits(3) | extra_run | run_offset(16) | level_offset( 0),
160 /*47*/ extra_bits(3) | extra_run | run_offset(24) | level_offset( 0),
161 /*48*/ extra_bits(2) | extra_run | run_offset( 4) | level_offset( 1),
162 /*49*/ extra_bits(3) | extra_run | run_offset( 8) | level_offset( 1),
164 /*50*/ extra_bits(5) | extra_run | run_offset(32) | level_offset( 0),
165 /*51*/ extra_bits(4) | extra_run | run_offset(16) | level_offset( 1),
167 /*52*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
168 /*53*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 8),
169 /*54*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset(12),
170 /*55*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(16),
171 /*56*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset(24),
173 /*57*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
174 /*58*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
176 /*59*/ extra_bits(2) | extra_run | run_offset(16) | level_offset( 0),
177 /*60*/ extra_bits(2) | extra_run | run_offset(20) | level_offset( 0),
178 /*61*/ extra_bits(2) | extra_run | run_offset(24) | level_offset( 0),
179 /*62*/ extra_bits(2) | extra_run | run_offset(28) | level_offset( 0),
180 /*63*/ extra_bits(4) | extra_run | run_offset(32) | level_offset( 0),
181 /*64*/ extra_bits(4) | extra_run | run_offset(48) | level_offset( 0),
183 /*65*/ extra_bits(2) | extra_run | run_offset( 4) | level_offset( 1),
184 /*66*/ extra_bits(3) | extra_run | run_offset( 8) | level_offset( 1),
185 /*67*/ extra_bits(4) | extra_run | run_offset(16) | level_offset( 1),
187 /*68*/ extra_bits(2) | extra_level | run_offset( 0) | level_offset( 4),
188 /*69*/ extra_bits(3) | extra_level | run_offset( 0) | level_offset( 8),
189 /*70*/ extra_bits(4) | extra_level | run_offset( 0) | level_offset(16),
191 /*71*/ extra_bits(2) | extra_level | run_offset( 1) | level_offset( 3),
192 /*72*/ extra_bits(3) | extra_level | run_offset( 1) | level_offset( 7),
194 //extra_bits = 3bits; extra_run/level = 1 bit; run_offset = 6bits; level_offset = 5 bits;
201 static void x8_get_ac_rlf(IntraX8Context * const w, const int mode,
202 int * const run, int * const level, int * const final){
203 MpegEncContext * const s= w->s;
206 // x8_select_ac_table(w,mode);
207 i = get_vlc2(&s->gb, w->j_ac_vlc[mode]->table, AC_VLC_BITS, AC_VLC_MTD);
212 (*level)=(*final)=//prevent 'may be used unilitialized'
213 (*run)=64;//this would cause error exit in the ac loop
217 (*final) = t = (i>22);
220 i== 0-15 r=0-15 l=0 ;r=i& %01111
221 i==16-19 r=0-3 l=1 ;r=i& %00011
222 i==20-21 r=0-1 l=2 ;r=i& %00001
223 i==22 r=0 l=3 ;r=i& %00000
224 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
225 t=lut_mask[l]={0x0f,0x03,0x01,0x00}[l]; as i<256 the higher bits do not matter */
226 l=(0xE50000>>(i&(0x1E)))&3;/*0x1E or (~1) or ((i>>1)<<1)*/
227 t=(0x01030F>>(l<<3));
231 }else if(i<73){//[46-72]
236 sm=ac_decode_table[i];
238 e=get_bits(&s->gb,sm&0xF);sm>>=8;//3bits
239 mask=sm&0xff;sm>>=8; //1bit
241 (*run) =(sm&0xff) + (e&( mask));//6bits
242 (*level)=(sm>>8) + (e&(~mask));//5bits
244 }else if(i<75){//[73-74]
245 static const uint8_t crazy_mix_runlevel[32]={
246 0x22,0x32,0x33,0x53,0x23,0x42,0x43,0x63,
247 0x24,0x52,0x34,0x73,0x25,0x62,0x44,0x83,
248 0x26,0x72,0x35,0x54,0x27,0x82,0x45,0x64,
249 0x28,0x92,0x36,0x74,0x29,0xa2,0x46,0x84};
252 e=get_bits(&s->gb,5);//get the extra bits
253 (*run) =crazy_mix_runlevel[e]>>4;
254 (*level)=crazy_mix_runlevel[e]&0x0F;
256 (*level)=get_bits( &s->gb, 7-3*(i&1));
257 (*run) =get_bits( &s->gb, 6);
258 (*final)=get_bits1(&s->gb);
263 //static const uint8_t dc_extra_sbits[] ={0, 1,1, 1,1, 2,2, 3,3, 4,4, 5,5, 6,6, 7,7 };
264 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 static int x8_get_dc_rlf(IntraX8Context * const w,int const mode, int * const level, int * const final){
267 MpegEncContext * const s= w->s;
271 if( !w->j_dc_vlc[mode] ) {
273 table_index = get_bits(&s->gb, 3);
274 //4 modes, same table
275 w->j_dc_vlc[mode]= &j_dc_vlc[w->quant<13][table_index];
278 assert(w->j_dc_vlc[mode]->table);
280 i=get_vlc2(&s->gb, w->j_dc_vlc[mode]->table, DC_VLC_BITS, DC_VLC_MTD);
282 /*(i>=17) {i-=17;final=1;}*/
291 c=(i+1)>>1;//hackish way to calculate dc_extra_sbits[]
294 e=get_bits(&s->gb,c);//get the extra bits
295 i=dc_index_offset[i]+(e>>1);
297 e= -(e & 1);//0,0xffffff
298 (*level)= (i ^ e) - e;// (i^0)-0 , (i^0xff)-(-1)
303 static int x8_setup_spatial_predictor(IntraX8Context * const w, const int chroma){
304 MpegEncContext * const s= w->s;
309 w->dsp.setup_spatial_compensation(s->dest[chroma], s->edge_emu_buffer,
310 s->current_picture.f->linesize[chroma>0],
311 &range, &sum, w->edges);
313 w->orient=w->chroma_orient;
314 quant=w->quant_dc_chroma;
320 if(range < quant || range < 3){
322 if(range < 3){//yep you read right, a +-1 idct error may break decoding!
325 w->predicted_dc = (sum*6899)>>17;//((1<<17)+9)/(8+8+1+2)=6899
331 assert(w->orient < 3);
332 if(range < 2*w->quant){
333 if( (w->edges&3) == 0){
334 if(w->orient==1) w->orient=11;
335 if(w->orient==2) w->orient=10;
341 static const uint8_t prediction_table[3][12]={
342 {0,8,4, 10,11, 2,6,9,1,3,5,7},
343 {4,0,8, 11,10, 3,5,2,6,9,1,7},
344 {8,0,4, 10,11, 1,7,2,6,9,3,5}
346 w->raw_orient=x8_get_orient_vlc(w);
347 if(w->raw_orient<0) return -1;
348 assert(w->raw_orient < 12 );
350 w->orient=prediction_table[w->orient][w->raw_orient];
355 static void x8_update_predictions(IntraX8Context * const w, const int orient, const int est_run ){
356 MpegEncContext * const s= w->s;
358 w->prediction_table[s->mb_x*2+(s->mb_y&1)] = (est_run<<2) + 1*(orient==4) + 2*(orient==8);
364 static void x8_get_prediction_chroma(IntraX8Context * const w){
365 MpegEncContext * const s= w->s;
367 w->edges = 1*( !(s->mb_x>>1) );
368 w->edges|= 2*( !(s->mb_y>>1) );
369 w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );//mb_x for chroma would always be odd
372 if(w->edges&3){//lut_co[8]={inv,4,8,8, inv,4,8,8}<- =>{1,1,0,0;1,1,0,0} => 0xCC
373 w->chroma_orient=4<<((0xCC>>w->edges)&1);
376 w->chroma_orient = (w->prediction_table[2*s->mb_x-2] & 0x03)<<2;//block[x-1][y|1-1)]
379 static void x8_get_prediction(IntraX8Context * const w){
380 MpegEncContext * const s= w->s;
383 w->edges = 1*( !s->mb_x );
384 w->edges|= 2*( !s->mb_y );
385 w->edges|= 4*( s->mb_x >= (2*s->mb_width-1) );
391 //take the one from the above block[0][y-1]
392 w->est_run = w->prediction_table[!(s->mb_y&1)]>>2;
396 //take the one from the previous block[x-1][0]
397 w->est_run = w->prediction_table[2*s->mb_x-2]>>2;
406 b= w->prediction_table[2*s->mb_x + !(s->mb_y&1) ];//block[x ][y-1]
407 a= w->prediction_table[2*s->mb_x-2 + (s->mb_y&1) ];//block[x-1][y ]
408 c= w->prediction_table[2*s->mb_x-2 + !(s->mb_y&1) ];//block[x-1][y-1]
410 w->est_run = FFMIN(b,a);
411 /* This condition has nothing to do with w->edges, even if it looks
412 similar it would trigger if e.g. x=3;y=2;
413 I guess somebody wrote something wrong and it became standard. */
414 if( (s->mb_x & s->mb_y) != 0 ) w->est_run=FFMIN(c,w->est_run);
421 i=( 0xFFEAF4C4>>(2*b+8*a) )&3;
422 if(i!=3) w->orient=i;
423 else w->orient=( 0xFFEAD8>>(2*c+8*(w->quant>12)) )&3;
429 pad 2 2 2; pad X 1 0; pad 0 1 0 <-
430 -> 11 10 '10 10 '11 11'01 00 '11 00'01 00=>0xEAF4C4
435 pad 2 2 2; pad 1 2 0 <-
436 -> 11 10'10 10 '11 01'10 00=>0xEAD8
441 static void x8_ac_compensation(IntraX8Context * const w, int const direction, int const dc_level){
442 MpegEncContext * const s= w->s;
444 #define B(x, y) s->block[0][s->idsp.idct_permutation[(x) + (y) * 8]]
445 #define T(x) ((x) * dc_level + 0x8000) >> 16;
488 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
496 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7*8);
504 s->block_last_index[0] = FFMAX(s->block_last_index[0], 7);
511 static void dsp_x8_put_solidcolor(uint8_t const pix, uint8_t * dst, int const linesize){
519 static const int16_t quant_table[64] = {
520 256, 256, 256, 256, 256, 256, 259, 262,
521 265, 269, 272, 275, 278, 282, 285, 288,
522 292, 295, 299, 303, 306, 310, 314, 317,
523 321, 325, 329, 333, 337, 341, 345, 349,
524 353, 358, 362, 366, 371, 375, 379, 384,
525 389, 393, 398, 403, 408, 413, 417, 422,
526 428, 433, 438, 443, 448, 454, 459, 465,
527 470, 476, 482, 488, 493, 499, 505, 511
530 static int x8_decode_intra_mb(IntraX8Context* const w, const int chroma){
531 MpegEncContext * const s= w->s;
535 int ac_mode,dc_mode,est_run,dc_level;
538 int use_quant_matrix;
541 assert(w->orient<12);
542 s->bdsp.clear_block(s->block[0]);
547 dc_mode=!!w->est_run;//0,1
550 if(x8_get_dc_rlf(w, dc_mode, &dc_level, &final)) return -1;
553 if(!final){//decode ac
554 use_quant_matrix=w->use_quant_matrix;
557 est_run = 64;//not used
559 if (w->raw_orient < 3){
560 use_quant_matrix = 0;
562 if(w->raw_orient > 4){
575 x8_select_ac_table(w,ac_mode);
576 /*scantable_selector[12]={0,2,0,1,1,1,0,2,2,0,1,2};<-
577 -> 10'01' 00'10' 10'00' 01'01' 01'00' 10'00 =>0x928548 */
578 scantable = w->scantable[ (0x928548>>(2*w->orient))&3 ].permutated;
584 x8_select_ac_table(w,3);
587 x8_get_ac_rlf(w,ac_mode,&run,&level,&final);
591 //this also handles vlc error in x8_get_ac_rlf
594 level= (level+1) * w->dquant;
597 sign = - get_bits1(&s->gb);
598 level = (level ^ sign) - sign;
600 if(use_quant_matrix){
601 level = (level*quant_table[pos])>>8;
603 s->block[0][ scantable[pos] ]=level;
606 s->block_last_index[0]=pos;
608 s->block_last_index[0]=0;
609 if(w->flat_dc && ((unsigned)(dc_level+1)) < 3){//[-1;1]
610 int32_t divide_quant= !chroma ? w->divide_quant_dc_luma:
611 w->divide_quant_dc_chroma;
612 int32_t dc_quant = !chroma ? w->quant:
615 //original intent dc_level+=predicted_dc/quant; but it got lost somewhere in the rounding
616 dc_level+= (w->predicted_dc*divide_quant + (1<<12) )>>13;
618 dsp_x8_put_solidcolor( av_clip_uint8((dc_level*dc_quant+4)>>3),
619 s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
623 zeros_only = (dc_level == 0);
626 s->block[0][0] = dc_level*w->quant;
628 s->block[0][0] = dc_level*w->quant_dc_chroma;
631 //there is !zero_only check in the original, but dc_level check is enough
632 if( (unsigned int)(dc_level+1) >= 3 && (w->edges&3) != 3 ){
634 /*ac_comp_direction[orient] = { 0, 3, 3, 1, 1, 0, 0, 0, 2, 2, 2, 1 };<-
635 -> 01'10' 10'10' 00'00' 00'01' 01'11' 11'00 =>0x6A017C */
636 direction= (0x6A017C>>(w->orient*2))&3;
638 x8_ac_compensation(w, direction, s->block[0][0]);//modify block_last[]
643 dsp_x8_put_solidcolor(w->predicted_dc, s->dest[chroma], s->current_picture.f->linesize[!!chroma]);
645 w->dsp.spatial_compensation[w->orient]( s->edge_emu_buffer,
647 s->current_picture.f->linesize[!!chroma] );
650 s->idsp.idct_add(s->dest[chroma],
651 s->current_picture.f->linesize[!!chroma],
657 x8_update_predictions(w,w->orient,n);
661 uint8_t* ptr = s->dest[chroma];
662 int linesize = s->current_picture.f->linesize[!!chroma];
664 if(!( (w->edges&2) || ( zeros_only && (w->orient|4)==4 ) )){
665 w->dsp.h_loop_filter(ptr, linesize, w->quant);
667 if(!( (w->edges&1) || ( zeros_only && (w->orient|8)==8 ) )){
668 w->dsp.v_loop_filter(ptr, linesize, w->quant);
674 static void x8_init_block_index(MpegEncContext *s){ //FIXME maybe merge with ff_*
675 //not s->linesize as this would be wrong for field pics
676 //not that IntraX8 has interlacing support ;)
677 const int linesize = s->current_picture.f->linesize[0];
678 const int uvlinesize = s->current_picture.f->linesize[1];
680 s->dest[0] = s->current_picture.f->data[0];
681 s->dest[1] = s->current_picture.f->data[1];
682 s->dest[2] = s->current_picture.f->data[2];
684 s->dest[0] += s->mb_y * linesize << 3;
685 s->dest[1] += ( s->mb_y&(~1) ) * uvlinesize << 2;//chroma blocks are on add rows
686 s->dest[2] += ( s->mb_y&(~1) ) * uvlinesize << 2;
690 * Initialize IntraX8 frame decoder.
691 * Requires valid MpegEncContext with valid s->mb_width before calling.
692 * @param w pointer to IntraX8Context
693 * @param s pointer to MpegEncContext of the parent codec
695 av_cold void ff_intrax8_common_init(IntraX8Context * w, MpegEncContext * const s){
699 assert(s->mb_width>0);
700 w->prediction_table=av_mallocz(s->mb_width*2*2);//two rows, 2 blocks per cannon mb
702 ff_init_scantable(s->idsp.idct_permutation, &w->scantable[0], ff_wmv1_scantable[0]);
703 ff_init_scantable(s->idsp.idct_permutation, &w->scantable[1], ff_wmv1_scantable[2]);
704 ff_init_scantable(s->idsp.idct_permutation, &w->scantable[2], ff_wmv1_scantable[3]);
706 ff_intrax8dsp_init(&w->dsp);
710 * Destroy IntraX8 frame structure.
711 * @param w pointer to IntraX8Context
713 av_cold void ff_intrax8_common_end(IntraX8Context * w)
715 av_freep(&w->prediction_table);
719 * Decode single IntraX8 frame.
720 * The parent codec must fill s->loopfilter and s->gb (bitstream).
721 * The parent codec must call ff_mpv_frame_start(), ff_er_frame_start() before calling this function.
722 * The parent codec must call ff_er_frame_end(), ff_mpv_frame_end() after calling this function.
723 * This function does not use ff_mpv_decode_mb().
724 * @param w pointer to IntraX8Context
725 * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
726 * @param quant_offset offset away from zero
728 int ff_intrax8_decode_picture(IntraX8Context * const w, int dquant, int quant_offset){
729 MpegEncContext * const s= w->s;
732 w->use_quant_matrix = get_bits1(&s->gb);
735 w->quant = dquant >> 1;
736 w->qsum = quant_offset;
738 w->divide_quant_dc_luma = ((1<<16) + (w->quant>>1)) / w->quant;
740 w->quant_dc_chroma = w->quant;
741 w->divide_quant_dc_chroma = w->divide_quant_dc_luma;
743 w->quant_dc_chroma = w->quant+((w->quant+3)>>3);
744 w->divide_quant_dc_chroma = ((1<<16) + (w->quant_dc_chroma>>1)) / w->quant_dc_chroma;
746 x8_reset_vlc_tables(w);
751 for(s->mb_y=0; s->mb_y < s->mb_height*2; s->mb_y++){
752 x8_init_block_index(s);
753 mb_xy=(s->mb_y>>1)*s->mb_stride;
755 for(s->mb_x=0; s->mb_x < s->mb_width*2; s->mb_x++){
756 x8_get_prediction(w);
757 if(x8_setup_spatial_predictor(w,0)) goto error;
758 if(x8_decode_intra_mb(w,0)) goto error;
760 if( s->mb_x & s->mb_y & 1 ){
761 x8_get_prediction_chroma(w);
763 /*when setting up chroma, no vlc is read,
764 so no error condition can be reached*/
765 x8_setup_spatial_predictor(w,1);
766 if(x8_decode_intra_mb(w,1)) goto error;
768 x8_setup_spatial_predictor(w,2);
769 if(x8_decode_intra_mb(w,2)) goto error;
774 /*emulate MB info in the relevant tables*/
775 s->mbskip_table [mb_xy]=0;
776 s->mbintra_table[mb_xy]=1;
777 s->current_picture.qscale_table[mb_xy] = w->quant;
783 ff_mpeg_draw_horiz_band(s, (s->mb_y-1)*8, 16);
788 ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
789 (s->mb_x>>1)-1, (s->mb_y>>1)-1,