1 /*****************************************************************************
2 * vpar_blocks.c : blocks parsing
4 *****************************************************************************/
6 /*****************************************************************************
8 *****************************************************************************/
16 #include <X11/extensions/XShm.h>
21 #include "vlc_thread.h"
24 #include "debug.h" /* ?? temporaire, requis par netlist.h */
27 #include "input_netlist.h"
28 #include "decoder_fifo.h"
30 #include "video_output.h"
32 #include "vdec_idct.h"
33 #include "video_decoder.h"
34 #include "vdec_motion.h"
36 #include "vpar_blocks.h"
37 #include "vpar_headers.h"
38 #include "video_fifo.h"
39 #include "vpar_synchro.h"
40 #include "video_parser.h"
45 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
46 macroblock_t * p_mb );
47 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar );
48 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
49 macroblock_t * p_mb );
50 typedef (void *) f_decode_block_t( vpar_thread_t *, macroblock_t *, int );
51 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
52 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
53 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
54 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b );
60 /*****************************************************************************
61 * pi_default_intra_quant : default quantization matrix
62 *****************************************************************************/
64 extern int pi_default_intra_quant =
66 8, 16, 19, 22, 26, 27, 29, 34,
67 16, 16, 22, 24, 27, 29, 34, 37,
68 19, 22, 26, 27, 29, 34, 34, 38,
69 22, 22, 26, 27, 29, 34, 37, 40,
70 22, 26, 27, 29, 32, 35, 40, 48,
71 26, 27, 29, 32, 35, 40, 48, 58,
72 26, 27, 29, 34, 38, 46, 56, 69,
73 27, 29, 35, 38, 46, 56, 69, 83
76 extern int pi_default_intra_quant =
78 2048, 5681, 6355, 6623, 6656, 5431, 4018, 2401,
79 5681, 7880, 10207, 10021, 9587, 8091, 6534, 3625,
80 6355, 10207, 11363, 10619, 9700, 8935, 6155, 3507,
81 6623, 9186, 10226, 9557, 8730, 8041, 6028, 3322,
82 5632, 9232, 9031, 8730, 8192, 7040, 5542, 3390,
83 5230, 7533, 7621, 7568, 7040, 6321, 5225, 3219,
84 3602, 5189, 5250, 5539, 5265, 5007, 4199, 2638,
85 1907, 2841, 3230, 3156, 3249, 3108, 2638, 1617
89 /*****************************************************************************
90 * pi_default_nonintra_quant : default quantization matrix
91 *****************************************************************************/
93 extern int pi_default_nonintra_quant =
95 16, 16, 16, 16, 16, 16, 16, 16,
96 16, 16, 16, 16, 16, 16, 16, 16,
97 16, 16, 16, 16, 16, 16, 16, 16,
98 16, 16, 16, 16, 16, 16, 16, 16,
99 16, 16, 16, 16, 16, 16, 16, 16,
100 16, 16, 16, 16, 16, 16, 16, 16,
101 16, 16, 16, 16, 16, 16, 16, 16,
102 16, 16, 16, 16, 16, 16, 16, 16
105 extern int pi_default_nonintra_quant =
107 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
108 5680, 7888, 7424, 6688, 5680, 4464, 3072, 1568,
109 5344, 7424, 6992, 6288, 5344, 4208, 2896, 1472,
110 4816, 6688, 6288, 5664, 4816, 3792, 2608, 1328,
111 4096, 5680, 5344, 4816, 4096, 3216, 2224, 1136,
112 3216, 4464, 4208, 3792, 3216, 2528, 1744, 880,
113 2224, 3072, 2896, 2608, 2224, 1744, 1200, 608,
114 1136, 1568, 1472, 1328, 1136, 880, 608, 304
118 /*****************************************************************************
119 * pi_scan : zig-zag and alternate scan patterns
120 *****************************************************************************/
121 extern int pi_scan[2][64] =
123 { /* Zig-Zag pattern */
124 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
125 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
126 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
127 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
129 { /* Alternate scan pattern */
130 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
131 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
132 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
133 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
138 * Initialization of lookup tables
141 /*****************************************************************************
142 * vpar_InitCrop : Initialize the crop table for saturation
143 * (ISO/IEC 13818-2 section 7.4.3)
144 *****************************************************************************/
145 #ifdef MPEG2_COMPLIANT
146 void vpar_InitCrop( vpar_thread_t * p_vpar )
150 p_vpar->pi_crop = p_vpar->pi_crop_buf + 32768;
152 for( i_dummy = -32768; i_dummy < -2048; i_dummy++ )
154 p_vpar->pi_crop[i_dummy] = -2048;
156 for( ; i_dummy < 2047; i_dummy++ )
158 p_vpar->pi_crop[i_dummy] = i_dummy;
160 for( ; i_dummy < 32767; i_dummy++ )
162 p_vpar->pi_crop[i_dummy] = 2047;
167 /*****************************************************************************
168 * InitMbAddrInc : Initialize the lookup table for mb_addr_inc *
169 *****************************************************************************/
171 void InitMbAddrInc( vpar_thread_t * p_vpar )
173 bzero( &p_vpar->mb_addr_inc, 4096*sizeof( int ) );
174 p_vpar->mb_addr_inc[8].i_value = MACROBLOCK_ESCAPE;
175 p_vpar->mb_addr_inc[15].i_value = MACROBLOCK_STUFFING;
176 p_vpar->mb_addr_inc[24].i_value = 33;
177 p_vpar->mb_addr_inc[25].i_value = 32;
178 p_vpar->mb_addr_inc[26].i_value = 31;
179 p_vpar->mb_addr_inc[27].i_value = 30;
180 p_vpar->mb_addr_inc[28].i_value = 29;
181 p_vpar->mb_addr_inc[29].i_value = 28;
182 p_vpar->mb_addr_inc[30].i_value = 27;
183 p_vpar->mb_addr_inc[31].i_value = 26;
184 p_vpar->mb_addr_inc[32].i_value = 25;
185 p_vpar->mb_addr_inc[33].i_value = 24;
186 p_vpar->mb_addr_inc[34].i_value = 23;
187 p_vpar->mb_addr_inc[35].i_value = 22;
188 p_vpar->mb_addr_inc[36].i_value = 21;
189 p_vpar->mb_addr_inc[38].i_value = 20;
190 p_vpar->mb_addr_inc[40].i_value = 19;
191 p_vpar->mb_addr_inc[42].i_value = 18;
192 p_vpar->mb_addr_inc[44].i_value = 17;
193 p_vpar->mb_addr_inc[46].i_value = 16;
194 p_vpar->mb_addr_inc[48].i_value = 15;
195 p_vpar->mb_addr_inc[56].i_value = 14;
196 p_vpar->mb_addr_inc[64].i_value = 13;
197 p_vpar->mb_addr_inc[72].i_value = 12;
198 p_vpar->mb_addr_inc[80].i_value = 11;
199 p_vpar->mb_addr_inc[88].i_value = 10;
200 p_vpar->mb_addr_inc[96].i_value = 9;
201 p_vpar->mb_addr_inc[112].i_value = 8;
202 p_vpar->mb_addr_inc[128].i_value = 7;
203 p_vpar->mb_addr_inc[192].i_value = 6;
204 p_vpar->mb_addr_inc[256].i_value = 5;
205 p_vpar->mb_addr_inc[384].i_value = 4;
206 p_vpar->mb_addr_inc[512].i_value = 3;
207 p_vpar->mb_addr_inc[768].i_value = 2;
208 p_vpar->mb_addr_inc[1024].i_value = 1;
209 /* Length of the variable length code */
210 p_vpar->mb_addr_inc[8].i_length = 11;
211 p_vpar->mb_addr_inc[15].i_length = 11;
212 p_vpar->mb_addr_inc[24].i_length = 11;
213 p_vpar->mb_addr_inc[25].i_length = 11;
214 p_vpar->mb_addr_inc[26].i_length = 11;
215 p_vpar->mb_addr_inc[27].i_length = 11;
216 p_vpar->mb_addr_inc[28].i_length = 11;
217 p_vpar->mb_addr_inc[29].i_length = 11;
218 p_vpar->mb_addr_inc[30].i_length = 11;
219 p_vpar->mb_addr_inc[31].i_length = 11;
220 p_vpar->mb_addr_inc[32].i_length = 11;
221 p_vpar->mb_addr_inc[33].i_length = 11;
222 p_vpar->mb_addr_inc[34].i_length = 11;
223 p_vpar->mb_addr_inc[35].i_length = 11;
224 p_vpar->mb_addr_inc[36].i_length = 10;
225 p_vpar->mb_addr_inc[38].i_length = 10;
226 p_vpar->mb_addr_inc[40].i_length = 10;
227 p_vpar->mb_addr_inc[42].i_length = 10;
228 p_vpar->mb_addr_inc[44].i_length = 10;
229 p_vpar->mb_addr_inc[46].i_length = 10;
230 p_vpar->mb_addr_inc[48].i_length = 8;
231 p_vpar->mb_addr_inc[56].i_length = 8;
232 p_vpar->mb_addr_inc[64].i_length = 8;
233 p_vpar->mb_addr_inc[72].i_length = 8;
234 p_vpar->mb_addr_inc[80].i_length = 8;
235 p_vpar->mb_addr_inc[88].i_length = 8;
236 p_vpar->mb_addr_inc[96].i_length = 7;
237 p_vpar->mb_addr_inc[112].i_length = 7;
238 p_vpar->mb_addr_inc[128].i_length = 5;
239 p_vpar->mb_addr_inc[192].i_length = 5;
240 p_vpar->mb_addr_inc[256].i_length = 4;
241 p_vpar->mb_addr_inc[384].i_length = 4;
242 p_vpar->mb_addr_inc[512].i_length = 3;
243 p_vpar->mb_addr_inc[768].i_length = 3;
244 p_vpar->mb_addr_inc[1024].i_length = 1;
248 * Macroblock parsing functions
251 /*****************************************************************************
252 * vpar_ParseMacroblock : Parse the next macroblock
253 *****************************************************************************/
254 void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address,
255 int i_mb_previous, int i_mb_base )
257 static f_addb_t ppf_addb_intra[2] = {vdec_AddBlock, vdec_CopyBlock};
258 static f_decode_block_t pppf_decode_block[2][2] =
259 { {vpar_DecodeMPEG1Non, vpar_DecodeMPEG1Intra},
260 {vpar_DecodeMPEG2Non, vpar_DecodeMPEG2Intra} };
261 static int pi_x[12] = {0,8,0,8,0,0,0,0,8,8,8,8};
262 static int pi_y[2][12] = { {0,0,8,8,0,0,8,8,0,0,8,8},
263 {0,0,1,1,0,0,1,1,0,0,1,1} };
264 static int pi_chroma_hor[4] = { 0, 1, 1, 0 };
265 static int pi_chroma_ver[4] = { 0, 1, 0, 0 };
267 int i_mb, i_b, i_mask;
273 *pi_mb_address += MacroblockAddressIncrement( p_vpar );
275 for( i_mb = i_mb_previous; i_mb < *pi_mb_address; i_mb++ )
277 /* Skipped macroblock (ISO/IEC 13818-2 7.6.6). */
278 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
279 static f_motion_t pf_motion_skipped[4] = {NULL, vdec_MotionField,
280 vdec_MotionField, vdec_MotionFrame};
282 /* Reset DC predictors (7.2.1). */
283 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
284 = p_vpar->slice.pi_dc_dct_pred[2]
285 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
287 if( p_vpar->picture.i_coding_type == P_CODING_TYPE )
289 /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
290 bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
293 if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + i_mb] =
294 vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
296 p_vpar->picture.b_error = 1;
297 intf_ErrMsg("vpar error: macroblock list is empty !");
301 InitMacroblock( p_vpar, p_mb );
303 /* No IDCT nor AddBlock. */
304 for( i_b = 0; i_b < 12; i_b++ )
306 p_mb->pf_idct[i_b] = vdec_DummyIDCT;
307 p_mb->pf_addb[i_b] = vdec_DummyBlock;
310 /* Motion type is picture structure. */
311 p_mb->pf_motion = pf_motion_skipped[p_vpar->picture.i_structure];
313 /* Predict from field of same parity. */
317 /* Get a macroblock structure. */
318 if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + *pi_mb_address] =
319 vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
321 p_vpar->picture.b_error = 1;
322 intf_ErrMsg("vpar error: macroblock list is empty !");
326 InitMacroblock( p_vpar, p_mb );
328 /* Parse off macroblock_modes structure. */
329 MacroblockModes( p_vpar, p_mb );
331 if( p_vpar->mb.i_mb_type & MB_QUANT )
333 LoadQuantizerScale( p_vpar );
336 if( p_vpar->mb.i_mb_type & MB_MOTION_FORWARD )
338 (*p_vpar->sequence.pf_decode_mv)( p_vpar, 0 );
341 if( p_vpar->mb.i_mb_type & MB_MOTION_BACKWARD )
343 (*p_vpar->sequence.pf_decode_mv)( p_vpar, 1 );
346 if( p_vpar->picture.b_concealment_mv && (p_vpar->mb.i_mb_type & MB_INTRA) )
348 DumpBits( &p_vpar->bit_stream, 1 );
351 if( p_vpar->mb.i_mb_type & MB_PATTERN )
353 (*p_vpar->sequence.pf_decode_pattern)( p_vpar );
357 int pi_coded_block_pattern[2] = {0,
358 (1 << 4+2*p_vpar->sequence.i_chroma_nb_blocks) - 1};
359 p_vpar->mb.i_coded_block_pattern = pi_coded_block_pattern
360 [p_vpar->mb.i_mb_type & MB_INTRA];
363 pf_addb = ppf_addb_intra[p_vpar->mb.i_mb_type & MB_INTRA];
366 * Effectively decode blocks.
369 i_mask = 1 << (3 + 2*p_vpar->sequence.i_chroma_nb_blocks);
372 p_data1 = p_mb->p_picture->p_y
373 + p_mb->i_l_x + p_mb->i_l_y*(p_vpar->sequence.i_width);
375 for( i_b = 0; i_b < 4; i_b++, i_mask >>= 1 )
377 if( p_vpar->mb.i_coded_block_pattern & i_mask )
379 memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
380 (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
381 [p_vpar->mb.i_mb_type & MB_INTRA])
382 ( p_vpar, p_mb, i_b );
384 /* decode_block has already set pf_idct and pi_sparse_pos. */
385 p_mb->pf_addb[i_b] = pf_addb;
387 /* Calculate block coordinates. */
388 p_mb->p_data[i_b] = p_data1
389 + pi_y[p_vpar->mb.b_dct_type][i_b]
390 * p_vpar->sequence.i_chroma_width;
394 /* Block not coded, so no IDCT, nor AddBlock */
395 p_mb->pf_addb[i_b] = vdec_DummyBlock;
396 p_mb->pf_idct[i_b] = vdec_DummyIDCT;
401 p_data1 = p_mb->p_picture->p_u
402 + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
403 + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
404 * (p_vpar->sequence.i_chroma_width);
405 p_data2 = p_mb->p_picture->p_v
406 + p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]
407 + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
408 * (p_vpar->sequence.i_chroma_width);
410 for( i_b = 4; i_b < 4 + 2*p_vpar->sequence.i_chroma_nb_blocks;
411 i_b++, i_mask >>= 1 )
413 elem_t * pp_data[2] = {p_data1, p_data2};
415 if( p_vpar->mb.i_coded_block_pattern & i_mask )
417 memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
418 (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
419 [p_vpar->mb.i_mb_type & MB_INTRA])
420 ( p_vpar, p_mb, i_b );
422 /* decode_block has already set pf_idct and pi_sparse_pos. */
423 p_mb->pf_addb[i_b] = pf_addb;
425 /* Calculate block coordinates. */
426 p_mb->p_data[i_b] = pp_data[i_b & 1]
427 + pi_y[p_vpar->mb.b_dct_type][i_b]
428 * p_vpar->sequence.i_chroma_width;
432 /* Block not coded, so no IDCT, nor AddBlock */
433 p_mb->pf_addb[i_b] = vdec_DummyBlock;
434 p_mb->pf_idct[i_b] = vdec_DummyIDCT;
438 if( !( p_vpar->mb.i_mb_type & MB_INTRA ) )
440 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
442 /* Reset DC predictors (7.2.1). */
443 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
444 = p_vpar->slice.pi_dc_dct_pred[2]
445 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
447 else if( !p_vpar->picture.b_concealment_mv )
449 /* Reset MV predictors. */
450 bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
453 if( (p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
454 !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
456 /* Special No-MC macroblock in P pictures (7.6.3.5). */
457 p_vpar->slice.pppi_pmv[0][0][0] = p_vpar->slice.pppi_pmv[0][0][1] =
458 p_vpar->slice.pppi_pmv[1][0][0] = p_vpar->slice.pppi_pmv[1][0][1] = 0;
460 /* motion type ?????? */
461 /* predict from field of same parity ????? */
465 /*****************************************************************************
466 * InitMacroblock : Initialize macroblock values
467 *****************************************************************************/
468 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
469 macroblock_t * p_mb )
471 p_mb->p_picture = p_vpar->picture.p_picture;
472 p_mb->i_structure = p_vpar->picture.i_structure;
473 p_mb->i_l_x = p_vpar->mb.i_l_x;
474 p_mb->i_l_y = p_vpar->mb.i_l_y;
475 p_mb->i_c_x = p_vpar->mb.i_c_x;
476 p_mb->i_c_y = p_vpar->mb.i_c_y;
477 p_mb->i_chroma_nb_blocks = p_vpar->sequence.i_chroma_nb_blocks;
479 p_mb->i_addb_l_stride = p_mb->i_l_stride = p_vpar->picture.i_l_stride;
480 p_mb->i_addb_c_stride = p_mb->i_c_stride = p_vpar->picture.i_c_stride;
482 /* Update macroblock real position. */
483 p_vpar->mb.i_l_x += 16;
484 p_vpar->mb.i_l_y += (p_vpar->mb.i_l_x / p_vpar->sequence.i_width)
485 * (2 - p_vpar->picture.b_frame_structure) * 16;
486 p_vpar->mb.i_l_x %= p_vpar->sequence.i_width;
488 p_vpar->mb.i_c_x += p_vpar->sequence.i_chroma_mb_width;
489 p_vpar->mb.i_c_y += (p_vpar->mb.i_c_x / p_vpar->sequence.i_chroma_width)
490 * (2 - p_vpar->picture.b_frame_structure)
491 * p_vpar->sequence.i_chroma_mb_height;
492 p_vpar->mb.i_c_x %= p_vpar->sequence.i_chroma_width;
495 /*****************************************************************************
496 * MacroblockAddressIncrement : Get the macroblock_address_increment field
497 *****************************************************************************/
498 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
500 /* Index in the lookup table mb_addr_inc */
501 int i_index = ShowBits( &p_vpar->bit_stream, 11 );
502 p_vpar->mb.i_addr_inc = 0;
503 /* Test the presence of the escape character */
504 while( i_index == 8 )
506 DumpBits( &p_vpar->bit_stream, 11 );
507 p_vpar->mb.i_addr_inc += 33;
508 i_index = ShowBits( &p_vpar->bit_stream, 11 );
510 /* Affect the value from the lookup table */
511 p_vpar->mb.i_addr_inc += p_vpar->mb_addr_inc[i_index].i_value;
512 /* Dump the good number of bits */
513 DumpBits( &p_vpar->bit_stream, p_vpar->mb_addr_inc[i_index].i_length );
516 /*****************************************************************************
517 * MacroblockModes : Get the macroblock_modes structure
518 *****************************************************************************/
519 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
520 macroblock_t * p_mb )
522 static f_motion_t pf_motion[2][4] =
523 { {NULL, vdec_FieldRecon, vdec_16x8Recon, vdec_DMVRecon},
524 {NULL, vdec_FieldRecon, vdec_FrameRecon, vdec_DMVRecon} };
525 static int ppi_mv_count[2][4] = { {0, 1, 2, 1}, {0, 2, 1, 1} };
526 static int ppi_mv_format[2][4] = { {0, 1, 1, 1}, {0, 1, 2, 1} };
528 /* Get macroblock_type. */
529 p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)
530 ( vpar_thread_t * p_vpar );
532 /* SCALABILITY : warning, we don't know if spatial_temporal_weight_code
533 * has to be dropped, take care if you use scalable streams. */
534 /* DumpBits( &p_vpar->bit_stream, 2 ); */
536 if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD))
537 || p_vpar->picture.b_frame_pred_frame_dct )
539 /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this
540 * is useless, but also harmless. */
541 p_vpar->mb.i_motion_type = MOTION_FRAME;
545 p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 );
548 p_mb->pf_motion = pf_motion[p_vpar->picture.b_frame_structure]
549 [p_vpar->mb.i_motion_type];
550 p_vpar->mb.i_mv_count = ppi_mv_count[p_vpar->picture.b_frame_structure]
551 [p_vpar->mb.i_motion_type];
552 p_vpar->mb.i_mv_format = ppi_mv_format[p_vpar->picture.b_frame_structure]
553 [p_vpar->mb.i_motion_type];
555 p_vpar->mb.b_dct_type = 0;
556 if( (p_vpar->picture.i_structure == FRAME_STRUCTURE) &&
557 (!p_vpar->picture.b_frame_pred_frame_dct) &&
558 (p_vpar->mb.i_mb_type & (MB_PATTERN|MB_INTRA)) )
560 if( p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 ) )
562 /* The DCT is coded on fields. Jump one line between each
564 p_mb->i_addb_l_stride <<= 1;
565 p_mb->i_addb_l_stride += 8;
566 /* With CHROMA_420, the DCT is necessarily frame-coded. */
567 if( p_vpar->picture.sequence.i_chroma_format != CHROMA_420 )
569 p_mb->i_addb_c_stride <<= 1;
570 p_mb->i_addb_c_stride += 8;
576 /*****************************************************************************
577 * vpar_IMBType : macroblock_type in I pictures
578 *****************************************************************************/
579 int vpar_IMBType( vpar_thread_t * p_vpar )
581 /* À pomper dans Berkeley */
584 /*****************************************************************************
585 * vpar_PMBType : macroblock_type in P pictures
586 *****************************************************************************/
587 int vpar_PMBType( vpar_thread_t * p_vpar )
589 /* À pomper dans Berkeley */
592 /*****************************************************************************
593 * vpar_BMBType : macroblock_type in B pictures
594 *****************************************************************************/
595 int vpar_BMBType( vpar_thread_t * p_vpar )
597 /* À pomper dans Berkeley */
600 /*****************************************************************************
601 * vpar_DMBType : macroblock_type in D pictures
602 *****************************************************************************/
603 int vpar_DMBType( vpar_thread_t * p_vpar )
605 /* À pomper dans Berkeley */
608 /*****************************************************************************
609 * vpar_CodedPattern420 : coded_block_pattern with 420 chroma
610 *****************************************************************************/
611 int vpar_CodedPattern420( vpar_thread_t * p_vpar )
613 /* À pomper dans Berkeley */
616 /*****************************************************************************
617 * vpar_CodedPattern422 : coded_block_pattern with 422 chroma
618 *****************************************************************************/
619 int vpar_CodedPattern422( vpar_thread_t * p_vpar )
621 /* À pomper dans Berkeley + attention ! y'a 2 bits en plus en MPEG2 */
624 /*****************************************************************************
625 * vpar_CodedPattern444 : coded_block_pattern with 444 chroma
626 *****************************************************************************/
627 int vpar_CodedPattern444( vpar_thread_t * p_vpar )
629 /* À pomper dans Berkeley + attention ! y'a 4 bits en plus en MPEG2 */
632 /*****************************************************************************
633 * vpar_DecodeMPEG1Non : decode MPEG-1 non-intra blocks
634 *****************************************************************************/
635 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
637 /* À pomper dans Berkeley. Pour toutes ces fonctions, il faut mettre
638 p_mb->pf_idct[i_b] à :
640 - vdec_SparseIDCT si la matrice n'a qu'un coefficient non nul.
641 Dans le deuxième cas, p_mb->pi_sparse_pos[i_b] contient le numéro
642 de ce coefficient. */
644 if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
646 /* Remove end_of_macroblock (always 1, prevents startcode emulation)
647 * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
648 DumpBits( &p_vpar->bit_stream, 1 );
652 /*****************************************************************************
653 * vpar_DecodeMPEG1Intra : decode MPEG-1 intra blocks
654 *****************************************************************************/
655 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
657 /* À pomper dans Berkeley. */
659 if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
661 /* Remove end_of_macroblock (always 1, prevents startcode emulation)
662 * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
663 DumpBits( &p_vpar->bit_stream, 1 );
667 /*****************************************************************************
668 * vpar_DecodeMPEG2Non : decode MPEG-2 non-intra blocks
669 *****************************************************************************/
670 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
672 /* À pomper dans Berkeley. Bien sûr les matrices seront différentes... */
675 /*****************************************************************************
676 * vpar_DecodeMPEG2Intra : decode MPEG-2 intra blocks
677 *****************************************************************************/
678 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
680 /* À pomper dans Berkeley. */