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 );
57 * Initialisation tables
59 lookup_t pl_coded_pattern_init_table[512] =
60 { {MB_ERROR, 0}, {MB_ERROR, 0}, {39, 9}, {27, 9}, {59, 9}, {55, 9}, {47, 9}, {31, 9},
61 {58, 8}, {58, 8}, {54, 8}, {54, 8}, {46, 8}, {46, 8}, {30, 8}, {30, 8},
62 {57, 8}, {57, 8}, {53, 8}, {53, 8}, {45, 8}, {45, 8}, {29, 8}, {29, 8},
63 {38, 8}, {38, 8}, {26, 8}, {26, 8}, {37, 8}, {37, 8}, {25, 8}, {25, 8},
64 {43, 8}, {43, 8}, {23, 8}, {23, 8}, {51, 8}, {51, 8}, {15, 8}, {15, 8},
65 {42, 8}, {42, 8}, {22, 8}, {22, 8}, {50, 8}, {50, 8}, {14, 8}, {14, 8},
66 {41, 8}, {41, 8}, {21, 8}, {21, 8}, {49, 8}, {49, 8}, {13, 8}, {13, 8},
67 {35, 8}, {35, 8}, {19, 8}, {19, 8}, {11, 8}, {11, 8}, {7, 8}, {7, 8},
68 {34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
69 {10, 7}, {10, 7}, {10, 7}, {10, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7},
70 {33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
71 {9, 7}, {9, 7}, {9, 7}, {9, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7},
72 {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6},
73 {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6},
74 {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6},
75 {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6},
76 {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
77 {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
78 {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5},
79 {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5},
80 {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
81 {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
82 {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5},
83 {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5},
84 {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
85 {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
86 {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
87 {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
88 {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
89 {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
90 {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
91 {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
92 {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
93 {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
94 {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
95 {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
96 {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
97 {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
98 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
99 {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
100 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
101 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
102 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
103 {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
104 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
105 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
106 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
107 {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
108 {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
109 {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
110 {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
111 {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
112 {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
113 {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
114 {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
115 {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
116 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
117 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
118 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
119 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
120 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
121 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
122 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
123 {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3} };
127 * Initialization of lookup tables
130 /*****************************************************************************
131 * vpar_InitCrop : Initialize the crop table for saturation
132 * (ISO/IEC 13818-2 section 7.4.3)
133 *****************************************************************************/
134 #if defined(MPEG2_COMPLIANT) && !defined(VDEC_DFT)
135 void vpar_InitCrop( vpar_thread_t * p_vpar )
139 p_vpar->pi_crop = p_vpar->pi_crop_buf + 32768;
141 for( i_dummy = -32768; i_dummy < -2048; i_dummy++ )
143 p_vpar->pi_crop[i_dummy] = -2048;
145 for( ; i_dummy < 2047; i_dummy++ )
147 p_vpar->pi_crop[i_dummy] = i_dummy;
149 for( ; i_dummy < 32767; i_dummy++ )
151 p_vpar->pi_crop[i_dummy] = 2047;
156 /*****************************************************************************
157 * InitMbAddrInc : Initialize the lookup table for mb_addr_inc *
158 *****************************************************************************/
160 /* Fonction for filling up the lookup table for mb_addr_inc */
161 void __inline__ FillMbAddrIncTable( vpar_thread_t * p_vpar,
162 int i_start, int i_end, int i_step,
163 int * pi_value, int i_length )
165 int i_dummy, i_dummy2;
166 for( i_dummy = i_start ; i_dummy < i_end ; i_dummy += i_step )
167 for( i_dummy2 = 0 ; i_dummy2 < i_step ; i_dummy2 ++ )
169 p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].i_value = * pi_value;
170 p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].i_length = i_length;
175 /* Fonction that initialize the table using the last one */
176 void InitMbAddrInc( vpar_thread_t * p_vpar )
180 for( i_dummy = 0 ; i_dummy < 8 ; i_dummy++ )
182 p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR;
183 p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0;
186 p_vpar->pl_mb_addr_inc[8].i_value = MB_ADDRINC_ESCAPE;
187 p_vpar->pl_mb_addr_inc[8].i_length = 11;
189 for( i_dummy = 9 ; i_dummy < 15 ; i_dummy ++ )
191 p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR;
192 p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0;
195 p_vpar->pl_mb_addr_inc[15].i_value = MB_ADDRINC_STUFFING;
196 p_vpar->pl_mb_addr_inc[15].i_length = 11;
198 for( i_dummy = 16; i_dummy < 24; i_dummy++ )
200 p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR;
201 p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0;
203 pi_value = (int *) malloc( sizeof( int ) );
205 FillMbAddrIncTable( p_vpar, 1024, 2048, 1024, pi_value, 1 );
206 FillMbAddrIncTable( p_vpar, 512, 1024, 256, pi_value, 3 );
207 FillMbAddrIncTable( p_vpar, 256, 512, 128, pi_value, 4 );
208 FillMbAddrIncTable( p_vpar, 128, 256, 64, pi_value, 5 );
209 FillMbAddrIncTable( p_vpar, 96, 128, 16, pi_value, 7 );
210 FillMbAddrIncTable( p_vpar, 48, 96, 8, pi_value, 8 );
211 FillMbAddrIncTable( p_vpar, 36, 48, 2, pi_value, 10 );
212 FillMbAddrIncTable( p_vpar, 24, 36, 1, pi_value, 11 );
214 /*****************************************************************************
215 * InitDCT : Initialize tables giving the length of the dct coefficient
217 *****************************************************************************/
219 void InitDCTTables( vpar_thread_t * p_vpar )
222 /* Tables are cut in two parts to reduce memory occupation */
224 /* Table B-12, dct_dc_size_luminance, codes 00xxx ... 11110 */
225 p_vpar->pppl_dct_dc_size[0][0] =
226 { {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
227 {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
228 {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
229 {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {MB_ERROR, 0}
232 /* Table B-12, dct_dc_size_luminance, codes 111110xxx ... 111111111 */
233 p_vpar->pppl_dct_dc_lum_size[1][0] =
234 { {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6},
235 {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10,9}, {11,9}
236 {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0},
237 {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0},
238 {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0},
239 {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}, {MB_ERROR, 0}
242 /* Table B-13, dct_dc_size_chrominance, codes 00xxx ... 11110 */
243 p_vpar->pppl_dct_dc_chrom_size[0][1] =
244 { {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
245 {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
246 {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
247 {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {MB_ERROR, 0}
250 /* Table B-13, dct_dc_size_chrominance, codes 111110xxxx ... 1111111111 */
251 p_vpar->pppl_dct_dc_size[1][1] =
252 { {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
253 {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
254 {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7},
255 {8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10,10}, {11,10}
260 /*****************************************************************************
261 * Init*MBType : Initialize lookup table for the Macroblock type
262 * ***************************************************************************/
264 /* Fonction for filling up the tables */
265 static void __inline__ FillMBType( vpar_thread_t * p_vpar,
274 for( i_dummy = i_start ; i_dummy < i_end ; i_dummy++ )
276 p_vpar->pl_mb_type[i_mb_type][i_dummy].i_value = i_value;
277 p_vpar->pl_mb_type[i_mb_type][i_dummy].i_length = i_length;
281 /* Fonction that fills the table for P MB_Type */
282 void InitPMBType( vpar_thread_t * p_vpar )
284 FillMBType( p_vpar, 0, 32, 64, MB_MOTION_FORWARD|MB_PATTERN, 1 );
285 FillMBType( p_vpar, 0, 16, 32, MB_PATTERN, 2 );
286 FillMBType( p_vpar, 0, 8, 16, MB_MOTION_FORWARD, 3 );
287 FillMBType( p_vpar, 0, 6, 8, MB_INTRA, 5 );
288 FillMBType( p_vpar, 0, 4, 6, MB_QUANT|MB_MOTION_FORWARD|MB_PATTERN, 5 );
289 FillMBType( p_vpar, 0, 2, 4, MB_QUANT|MB_PATTERN, 5 );
290 p_vpar->pl_mb_type[0][1].i_value = MB_QUANT|MB_INTRA;
291 p_vpar->pl_mb_type[0][1].i_length = 6;
292 p_vpar->pl_mb_type[0][0].i_value = MB_ERROR;
293 p_vpar->pl_mb_type[0][0].i_length = 0;
296 /* Fonction that fills the table for B MB_Type */
297 void InitBMBType( vpar_thread_t * p_vpar )
299 FillMBType( p_vpar, 1, 48, 64, MB_MOTION_FORWARD
300 |MB_MOTION_BACKWARD|MB_PATTERN, 2 );
301 FillMBType( p_vpar, 1, 32, 48, MB_MOTION_FORWARD|MB_MOTION_BACKWARD, 2 );
302 FillMBType( p_vpar, 1, 24, 32, MB_MOTION_BACKWARD|MB_PATTERN, 3 );
303 FillMBType( p_vpar, 1, 16, 24, MB_MOTION_BACKWARD, 3 );
304 FillMBType( p_vpar, 1, 12, 16, MB_MOTION_FORWARD|MB_PATTERN, 4 );
305 FillMBType( p_vpar, 1, 8, 12, MB_MOTION_FORWARD, 4 );
306 FillMBType( p_vpar, 1, 6, 8, MB_INTRA, 5 );
307 FillMBType( p_vpar, 1, 4, 6, MB_QUANT|MB_MOTION_FORWARD
308 |MB_MOTION_BACKWARD|MB_PATTERN, 5 );
309 p_vpar->pl_mb_type[1][3].i_value = MB_QUANT|MB_MOTION_FORWARD|MB_PATTERN;
310 p_vpar->pl_mb_type[1][3].i_length = 6;
311 p_vpar->pl_mb_type[1][2].i_value = MB_QUANT|MB_MOTION_BACKWARD|MB_PATTERN;
312 p_vpar->pl_mb_type[1][2].i_length = 6;
313 p_vpar->pl_mb_type[1][1].i_value = MB_QUANT|MB_INTRA;
314 p_vpar->pl_mb_type[1][1].i_length = 6;
315 p_vpar->pl_mb_type[1][0].i_value =MB_ERROR;
316 p_vpar->pl_mb_type[1][0].i_length = 0;
319 /*****************************************************************************
320 * InitCodedPattern : Initialize the lookup table for decoding
321 * coded block pattern
322 *****************************************************************************/
323 void InitCodedPattern( vpar_thread_t * p_vpar )
325 memcpy( p_vpar->pl_coded_pattern, pl_coded_pattern_init_table ,
326 sizeof(pl_coded_pattern_init_table) );
330 * Macroblock parsing functions
333 /*****************************************************************************
334 * vpar_ParseMacroblock : Parse the next macroblock
335 *****************************************************************************/
336 void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address,
337 int i_mb_previous, int i_mb_base )
339 static f_addb_t ppf_addb_intra[2] = {vdec_AddBlock, vdec_CopyBlock};
340 static f_decode_block_t pppf_decode_block[2][2] =
341 { {vpar_DecodeMPEG1Non, vpar_DecodeMPEG1Intra},
342 {vpar_DecodeMPEG2Non, vpar_DecodeMPEG2Intra} };
343 static int pi_x[12] = {0,8,0,8,0,0,0,0,8,8,8,8};
344 static int pi_y[2][12] = { {0,0,8,8,0,0,8,8,0,0,8,8},
345 {0,0,1,1,0,0,1,1,0,0,1,1} };
346 static int pi_chroma_hor[4] = { 0, 1, 1, 0 };
347 static int pi_chroma_ver[4] = { 0, 1, 0, 0 };
349 int i_mb, i_b, i_mask;
355 *pi_mb_address += MacroblockAddressIncrement( p_vpar );
357 for( i_mb = i_mb_previous; i_mb < *pi_mb_address; i_mb++ )
359 /* Skipped macroblock (ISO/IEC 13818-2 7.6.6). */
360 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
361 static f_motion_t pf_motion_skipped[4] = {NULL, vdec_MotionField,
362 vdec_MotionField, vdec_MotionFrame};
364 /* Reset DC predictors (7.2.1). */
365 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
366 = p_vpar->slice.pi_dc_dct_pred[2]
367 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
369 if( p_vpar->picture.i_coding_type == P_CODING_TYPE )
371 /* Reset motion vector predictors (ISO/IEC 13818-2 7.6.3.4). */
372 bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
375 if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + i_mb] =
376 vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
378 p_vpar->picture.b_error = 1;
379 intf_ErrMsg("vpar error: macroblock list is empty !");
383 InitMacroblock( p_vpar, p_mb );
385 /* No IDCT nor AddBlock. */
386 for( i_b = 0; i_b < 12; i_b++ )
388 p_mb->pf_idct[i_b] = vdec_DummyIDCT;
389 p_mb->pf_addb[i_b] = vdec_DummyBlock;
392 /* Motion type is picture structure. */
393 p_mb->pf_motion = pf_motion_skipped[p_vpar->picture.i_structure];
395 /* Set the field we use for motion compensation */
396 p_mb->ppi_field_select[0][0] = p_mb->ppi_field_select[0][1]
397 = ( p_vpar->picture.i_current_structure == BOTTOM_FIELD );
399 /* Predict from field of same parity. */
403 /* Get a macroblock structure. */
404 if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + *pi_mb_address] =
405 vpar_NewMacroblock( &p_vpar->vfifo )) == NULL )
407 p_vpar->picture.b_error = 1;
408 intf_ErrMsg("vpar error: macroblock list is empty !");
412 InitMacroblock( p_vpar, p_mb );
414 /* Parse off macroblock_modes structure. */
415 MacroblockModes( p_vpar, p_mb );
417 if( p_vpar->mb.i_mb_type & MB_QUANT )
419 LoadQuantizerScale( p_vpar );
422 if( p_vpar->mb.i_mb_type & MB_MOTION_FORWARD )
424 (*p_vpar->sequence.pf_decode_mv)( p_vpar, p_mb, 0 );
427 if( p_vpar->mb.i_mb_type & MB_MOTION_BACKWARD )
429 (*p_vpar->sequence.pf_decode_mv)( p_vpar, p_mb, 1 );
432 if( p_vpar->picture.b_concealment_mv && (p_vpar->mb.i_mb_type & MB_INTRA) )
434 DumpBits( &p_vpar->bit_stream, 1 );
437 if( p_vpar->mb.i_mb_type & MB_PATTERN )
439 (*p_vpar->sequence.pf_decode_pattern)( p_vpar );
443 int pi_coded_block_pattern[2] = {0,
444 (1 << 4+2*p_vpar->sequence.i_chroma_nb_blocks) - 1};
445 p_vpar->mb.i_coded_block_pattern = pi_coded_block_pattern
446 [p_vpar->mb.i_mb_type & MB_INTRA];
449 pf_addb = ppf_addb_intra[p_vpar->mb.i_mb_type & MB_INTRA];
452 * Effectively decode blocks.
455 i_mask = 1 << (3 + 2*p_vpar->sequence.i_chroma_nb_blocks);
458 p_data1 = (elem_t*) p_mb->p_picture->p_y;
459 // + p_mb->i_l_x + p_mb->i_l_y*(p_vpar->sequence.i_width);
461 for( i_b = 0 ; i_b < 4 ; i_b++, i_mask >>= 1 )
463 if( p_vpar->mb.i_coded_block_pattern & i_mask )
465 memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
466 (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
467 [p_vpar->mb.i_mb_type & MB_INTRA])
468 ( p_vpar, p_mb, i_b );
470 /* decode_block has already set pf_idct and pi_sparse_pos. */
471 p_mb->pf_addb[i_b] = pf_addb;
473 /* Calculate block coordinates. */
474 p_mb->p_data[i_b] = p_data1
475 + pi_y[p_vpar->mb.b_dct_type][i_b]
476 * p_vpar->sequence.i_chroma_width;
480 /* Block not coded, so no IDCT, nor AddBlock */
481 p_mb->pf_addb[i_b] = vdec_DummyBlock;
482 p_mb->pf_idct[i_b] = vdec_DummyIDCT;
487 p_data1 = (elem_t*) p_mb->p_picture->p_u
488 + (p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format])
489 + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
490 * (p_vpar->sequence.i_chroma_width);
491 p_data2 = (elem_t*) p_mb->p_picture->p_v
492 + (p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format])
493 + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format])
494 * (p_vpar->sequence.i_chroma_width);
496 for( i_b = 4; i_b < 4 + 2*p_vpar->sequence.i_chroma_nb_blocks;
497 i_b++, i_mask >>= 1 )
499 elem_t * pp_data[2] = {p_data1, p_data2};
501 if( p_vpar->mb.i_coded_block_pattern & i_mask )
503 memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) );
504 (*pppf_decode_block[p_vpar->sequence.b_mpeg2]
505 [p_vpar->mb.i_mb_type & MB_INTRA])
506 ( p_vpar, p_mb, i_b );
508 /* decode_block has already set pf_idct and pi_sparse_pos. */
509 p_mb->pf_addb[i_b] = pf_addb;
511 /* Calculate block coordinates. */
512 p_mb->p_data[i_b] = pp_data[i_b & 1]
513 + pi_y[p_vpar->mb.b_dct_type][i_b]
514 * p_vpar->sequence.i_chroma_width;
518 /* Block not coded, so no IDCT, nor AddBlock */
519 p_mb->pf_addb[i_b] = vdec_DummyBlock;
520 p_mb->pf_idct[i_b] = vdec_DummyIDCT;
524 if( !( p_vpar->mb.i_mb_type & MB_INTRA ) )
526 static int pi_dc_dct_reinit[4] = {128,256,512,1024};
528 /* Reset DC predictors (7.2.1). */
529 p_vpar->slice.pi_dc_dct_pred[0] = p_vpar->slice.pi_dc_dct_pred[1]
530 = p_vpar->slice.pi_dc_dct_pred[2]
531 = pi_dc_dct_reinit[p_vpar->picture.i_intra_dc_precision];
533 else if( !p_vpar->picture.b_concealment_mv )
535 /* Reset MV predictors. */
536 bzero( p_vpar->slice.pppi_pmv, 8*sizeof(int) );
540 /*****************************************************************************
541 * InitMacroblock : Initialize macroblock values
542 *****************************************************************************/
543 static __inline__ void InitMacroblock( vpar_thread_t * p_vpar,
544 macroblock_t * p_mb )
546 static f_chroma_motion_t pf_chroma_motion[4] =
547 { NULL, vdec_Motion420, vdec_Motion422, vdec_Motion444 };
549 p_mb->p_picture = p_vpar->picture.p_picture;
550 p_mb->i_structure = p_vpar->picture.i_structure;
551 p_mb->i_l_x = p_vpar->mb.i_l_x;
552 p_mb->i_l_y = p_vpar->mb.i_l_y;
553 p_mb->i_c_x = p_vpar->mb.i_c_x;
554 p_mb->i_c_y = p_vpar->mb.i_c_y;
555 p_mb->i_chroma_nb_blocks = p_vpar->sequence.i_chroma_nb_blocks;
556 p_mb->pf_chroma_motion = pf_chroma_motion[p_vpar->sequence.i_chroma_format];
558 p_mb->p_forward = p_vpar->sequence.p_forward;
559 p_mb->p_backward = p_vpar->sequence.p_backward;
561 p_mb->i_addb_l_stride = p_mb->i_l_stride = p_vpar->picture.i_l_stride;
562 p_mb->i_addb_c_stride = p_mb->i_c_stride = p_vpar->picture.i_c_stride;
564 /* Update macroblock real position. */
565 p_vpar->mb.i_l_x += 16;
566 p_vpar->mb.i_l_y += (p_vpar->mb.i_l_x / p_vpar->sequence.i_width)
567 * (2 - p_vpar->picture.b_frame_structure) * 16;
568 p_vpar->mb.i_l_x %= p_vpar->sequence.i_width;
570 p_vpar->mb.i_c_x += p_vpar->sequence.i_chroma_mb_width;
571 p_vpar->mb.i_c_y += (p_vpar->mb.i_c_x / p_vpar->sequence.i_chroma_width)
572 * (2 - p_vpar->picture.b_frame_structure)
573 * p_vpar->sequence.i_chroma_mb_height;
574 p_vpar->mb.i_c_x %= p_vpar->sequence.i_chroma_width;
577 /*****************************************************************************
578 * MacroblockAddressIncrement : Get the macroblock_address_increment field
579 *****************************************************************************/
580 static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
582 /* Index in the lookup table mb_addr_inc */
583 int i_index = ShowBits( &p_vpar->bit_stream, 11 );
584 p_vpar->mb.i_addr_inc = 0;
585 /* Test the presence of the escape character */
586 while( i_index == 8 )
588 DumpBits( &p_vpar->bit_stream, 11 );
589 p_vpar->mb.i_addr_inc += 33;
590 i_index = ShowBits( &p_vpar->bit_stream, 11 );
592 /* Affect the value from the lookup table */
593 p_vpar->mb.i_addr_inc += p_vpar->pl_mb_addr_inc[i_index].i_value;
594 /* Dump the good number of bits */
595 DumpBits( &p_vpar->bit_stream, p_vpar->pl_mb_addr_inc[i_index].i_length );
598 /*****************************************************************************
599 * MacroblockModes : Get the macroblock_modes structure
600 *****************************************************************************/
601 static __inline__ void MacroblockModes( vpar_thread_t * p_vpar,
602 macroblock_t * p_mb )
604 static f_motion_t pf_motion[2][4] =
605 { {NULL, vdec_FieldRecon, vdec_16x8Recon, vdec_DMVRecon},
606 {NULL, vdec_FieldRecon, vdec_FrameRecon, vdec_DMVRecon} };
607 static int ppi_mv_count[2][4] = { {0, 1, 2, 1}, {0, 2, 1, 1} };
608 static int ppi_mv_format[2][4] = { {0, 1, 1, 1}, {0, 1, 2, 1} };
610 /* Get macroblock_type. */
611 p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)( p_vpar );
613 /* SCALABILITY : warning, we don't know if spatial_temporal_weight_code
614 * has to be dropped, take care if you use scalable streams. */
615 /* DumpBits( &p_vpar->bit_stream, 2 ); */
617 if( (p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
618 !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) )
620 /* Special No-MC macroblock in P pictures (7.6.3.5). */
621 memset( p_vpar->slice.pppi_pmv, 0, 8*sizeof(int) );
622 memset( p_mb->pppi_motion_vectors, 0, 8*sizeof(int) );
624 p_vpar->mb.i_motion_type = MOTION_FRAME;
625 p_mb->ppi_field_select[0][0] = ( p_vpar->picture.i_current_structure == BOTTOM_FIELD );
627 else if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD))
628 || p_vpar->picture.b_frame_pred_frame_dct )
630 /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this
631 * is useless, but also harmless. */
632 p_vpar->mb.i_motion_type = MOTION_FRAME;
636 p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 );
639 if( p_vpar->mb.i_mb_type & MB_INTRA )
641 /* For the intra macroblocks, we use an empty motion
642 * compensation function */
643 p_mb->pf_motion = vdec_DummyRecon;
647 p_mb->pf_motion = pf_motion[p_vpar->picture.b_frame_structure]
648 [p_vpar->mb.i_motion_type];
650 p_vpar->mb.i_mv_count = ppi_mv_count[p_vpar->picture.b_frame_structure]
651 [p_vpar->mb.i_motion_type];
652 p_vpar->mb.i_mv_format = ppi_mv_format[p_vpar->picture.b_frame_structure]
653 [p_vpar->mb.i_motion_type];
655 p_vpar->mb.b_dct_type = 0;
656 if( (p_vpar->picture.i_structure == FRAME_STRUCTURE) &&
657 (!p_vpar->picture.b_frame_pred_frame_dct) &&
658 (p_vpar->mb.i_mb_type & (MB_PATTERN|MB_INTRA)) )
660 if( p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 ) )
662 /* The DCT is coded on fields. Jump one line between each
664 p_mb->i_addb_l_stride <<= 1;
665 p_mb->i_addb_l_stride += 8;
666 /* With CHROMA_420, the DCT is necessarily frame-coded. */
667 if( p_vpar->sequence.i_chroma_format != CHROMA_420 )
669 p_mb->i_addb_c_stride <<= 1;
670 p_mb->i_addb_c_stride += 8;
675 p_vpar->mb.b_dmv = p_vpar->mb.i_motion_type == MOTION_DMV;
678 /*****************************************************************************
679 * vpar_IMBType : macroblock_type in I pictures
680 *****************************************************************************/
681 int vpar_IMBType( vpar_thread_t * p_vpar )
683 /* Take two bits for testing */
684 int i_type = ShowBits( &p_vpar->bit_stream, 2 );
685 /* Lookup table for macroblock_type */
686 static lookup_t pl_mb_Itype[4] = { {MB_ERROR, 0},
687 {MB_QUANT|MB_INTRA, 2},
690 /* Dump the good number of bits */
691 DumpBits( &p_vpar->bit_stream, pl_mb_Itype[i_type].i_length );
692 return pl_mb_Itype[i_type].i_value;
695 /*****************************************************************************
696 * vpar_PMBType : macroblock_type in P pictures
697 *****************************************************************************/
698 int vpar_PMBType( vpar_thread_t * p_vpar )
700 /* Testing on 6 bits */
701 int i_type = ShowBits( &p_vpar->bit_stream, 6 );
702 /* Dump the good number of bits */
703 DumpBits( &p_vpar->bit_stream, p_vpar->pl_mb_type[0][i_type].i_length );
704 /* return the value from the lookup table for P type */
705 return p_vpar->pl_mb_type[0][i_type].i_value;
708 /*****************************************************************************
709 * vpar_BMBType : macroblock_type in B pictures
710 *****************************************************************************/
711 int vpar_BMBType( vpar_thread_t * p_vpar )
713 /* Testing on 6 bits */
714 int i_type = ShowBits( &p_vpar->bit_stream, 6 );
715 /* Dump the good number of bits */
716 DumpBits( &p_vpar->bit_stream, p_vpar->pl_mb_type[1][i_type].i_length );
717 /* return the value from the lookup table for B type */
718 return p_vpar->pl_mb_type[1][i_type].i_value;
721 /*****************************************************************************
722 * vpar_DMBType : macroblock_type in D pictures
723 *****************************************************************************/
724 int vpar_DMBType( vpar_thread_t * p_vpar )
727 int i_type = GetBits( &p_vpar->bit_stream, 1 );
729 static int pi_mb_Dtype[2] = { MB_ERROR, 1 };
730 return pi_mb_Dtype[i_type];
733 /*****************************************************************************
734 * vpar_CodedPattern420 : coded_block_pattern with 420 chroma
735 *****************************************************************************/
736 int vpar_CodedPattern420( vpar_thread_t * p_vpar )
738 int i_vlc = ShowBits( &p_vpar->bit_stream, 9 );
739 DumpBits( &p_vpar->bit_stream, p_vpar->pl_coded_pattern[i_vlc].i_length );
740 return p_vpar->pl_coded_pattern[i_vlc].i_value;
743 /*****************************************************************************
744 * vpar_CodedPattern422 : coded_block_pattern with 422 chroma
745 *****************************************************************************/
746 int vpar_CodedPattern422( vpar_thread_t * p_vpar )
748 /* À pomper dans Berkeley + attention ! y'a 2 bits en plus en MPEG2 */
751 /*****************************************************************************
752 * vpar_CodedPattern444 : coded_block_pattern with 444 chroma
753 *****************************************************************************/
754 int vpar_CodedPattern444( vpar_thread_t * p_vpar )
756 /* À pomper dans Berkeley + attention ! y'a 4 bits en plus en MPEG2 */
759 /*****************************************************************************
760 * vpar_DecodeMPEG1Non : decode MPEG-1 non-intra blocks
761 *****************************************************************************/
762 static void vpar_DecodeMPEG1Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
764 /* À pomper dans Berkeley. Pour toutes ces fonctions, il faut mettre
765 p_mb->pf_idct[i_b] à :
767 - vdec_SparseIDCT si la matrice n'a qu'un coefficient non nul.
768 Dans le deuxième cas, p_mb->pi_sparse_pos[i_b] contient le numéro
769 de ce coefficient. */
771 if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
773 /* Remove end_of_macroblock (always 1, prevents startcode emulation)
774 * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
775 DumpBits( &p_vpar->bit_stream, 1 );
779 /*****************************************************************************
780 * vpar_DecodeMPEG1Intra : decode MPEG-1 intra blocks
781 *****************************************************************************/
782 static void vpar_DecodeMPEG1Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
784 /* À pomper dans Berkeley. */
786 if( p_vpar->picture.i_coding_type == D_CODING_TYPE )
788 /* Remove end_of_macroblock (always 1, prevents startcode emulation)
789 * ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
790 DumpBits( &p_vpar->bit_stream, 1 );
794 /*****************************************************************************
795 * vpar_DecodeMPEG2Non : decode MPEG-2 non-intra blocks
796 *****************************************************************************/
797 static void vpar_DecodeMPEG2Non( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
799 /* À pomper dans Berkeley. Bien sûr les matrices seront différentes... */
802 /*****************************************************************************
803 * vpar_DecodeMPEG2Intra : decode MPEG-2 intra blocks
804 *****************************************************************************/
805 static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, int i_b )
807 /* Lookup Table for the chromatic component */
808 static int pi_cc_index[12] = { 0, 0, 0, 0, 1, 2, 1, 2, 1, 2 };
809 int i_cc = pi_cc_index[i_b];
810 /* Determine whether it is luminance or not (chrominance) */
811 int i_type = ( i_cc + 1 ) / 2;
813 /* Decoding of the DC intra coefficient */
814 /* The nb of bits to parse depends on i_type */
815 int i_code = ShowBits( &p_vpar->bit_stream, 9 + i_type );
816 /* To reduce memory occupation, there are two lookup tables
817 * See InitDCT above */
818 int i_code5 = i_code >> 4;
819 /* Shall we lookup in the first or in the second table ? */
820 int i_select = ( i_code5 - 1 ) / 31;
821 /* Offset value for looking in the second table */
822 int i_offset = 0x1f0 + ( i_type * 0x1f0 );
823 int i_pos = i_code5 * ( ! i_select ) +
824 ( i_code - i_offset ) * i_select;
827 i_dct_dc_size = p_vpar->pppl_dct_dc_size[i_select][i_type][i_pos].i_value;
828 /* Dump the variable length code */
829 DumpBits( &p_vpar->bit_stream,
830 p_vpar->pppl_dct_dc_size[i_select][i_type][i_pos].i_length );
831 i_dct_dc_diff = GetBits( &p_vpar->bit_stream, i_dct_dc_size );
832 p_vpar->slice.pi_dc_dct_pred[i_cc] += i_dct_dc_diff;
834 /* Decoding of the AC coefficients */