diff options
Diffstat (limited to 'apps/plugins/mpegplayer/libmpeg2/header.c')
-rw-r--r-- | apps/plugins/mpegplayer/libmpeg2/header.c | 1287 |
1 files changed, 1287 insertions, 0 deletions
diff --git a/apps/plugins/mpegplayer/libmpeg2/header.c b/apps/plugins/mpegplayer/libmpeg2/header.c new file mode 100644 index 0000000000..b40193a338 --- /dev/null +++ b/apps/plugins/mpegplayer/libmpeg2/header.c | |||
@@ -0,0 +1,1287 @@ | |||
1 | /* | ||
2 | * header.c | ||
3 | * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> | ||
4 | * Copyright (C) 2003 Regis Duchesne <hpreg@zoy.org> | ||
5 | * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> | ||
6 | * | ||
7 | * This file is part of mpeg2dec, a free MPEG-2 video stream decoder. | ||
8 | * See http://libmpeg2.sourceforge.net/ for updates. | ||
9 | * | ||
10 | * mpeg2dec is free software; you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation; either version 2 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * mpeg2dec is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with this program; if not, write to the Free Software | ||
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
23 | * | ||
24 | * $Id$ | ||
25 | * libmpeg2 sync history: | ||
26 | * 2008-07-01 - CVS revision 1.101 | ||
27 | */ | ||
28 | |||
29 | #include "plugin.h" | ||
30 | |||
31 | #include "mpeg2dec_config.h" | ||
32 | |||
33 | #include "mpeg2.h" | ||
34 | #include "attributes.h" | ||
35 | #include "mpeg2_internal.h" | ||
36 | |||
37 | #define SEQ_EXT 2 | ||
38 | #define SEQ_DISPLAY_EXT 4 | ||
39 | #define QUANT_MATRIX_EXT 8 | ||
40 | #define COPYRIGHT_EXT 0x10 | ||
41 | #define PIC_DISPLAY_EXT 0x80 | ||
42 | #define PIC_CODING_EXT 0x100 | ||
43 | |||
44 | /* default intra quant matrix, in zig-zag order */ | ||
45 | static const uint8_t default_intra_quantizer_matrix[64] = | ||
46 | { | ||
47 | 8, | ||
48 | 16, 16, | ||
49 | 19, 16, 19, | ||
50 | 22, 22, 22, 22, | ||
51 | 22, 22, 26, 24, 26, | ||
52 | 27, 27, 27, 26, 26, 26, | ||
53 | 26, 27, 27, 27, 29, 29, 29, | ||
54 | 34, 34, 34, 29, 29, 29, 27, 27, | ||
55 | 29, 29, 32, 32, 34, 34, 37, | ||
56 | 38, 37, 35, 35, 34, 35, | ||
57 | 38, 38, 40, 40, 40, | ||
58 | 48, 48, 46, 46, | ||
59 | 56, 56, 58, | ||
60 | 69, 69, | ||
61 | 83 | ||
62 | }; | ||
63 | |||
64 | const uint8_t default_mpeg2_scan_norm[64] = | ||
65 | { | ||
66 | /* Zig-Zag scan pattern */ | ||
67 | 0, 1, 8, 16, 9, 2, 3, 10, | ||
68 | 17, 24, 32, 25, 18, 11, 4, 5, | ||
69 | 12, 19, 26, 33, 40, 48, 41, 34, | ||
70 | 27, 20, 13, 6, 7, 14, 21, 28, | ||
71 | 35, 42, 49, 56, 57, 50, 43, 36, | ||
72 | 29, 22, 15, 23, 30, 37, 44, 51, | ||
73 | 58, 59, 52, 45, 38, 31, 39, 46, | ||
74 | 53, 60, 61, 54, 47, 55, 62, 63 | ||
75 | }; | ||
76 | |||
77 | const uint8_t default_mpeg2_scan_alt[64] = | ||
78 | { | ||
79 | /* Alternate scan pattern */ | ||
80 | 0, 8, 16, 24, 1, 9, 2, 10, | ||
81 | 17, 25, 32, 40, 48, 56, 57, 49, | ||
82 | 41, 33, 26, 18, 3, 11, 4, 12, | ||
83 | 19, 27, 34, 42, 50, 58, 35, 43, | ||
84 | 51, 59, 20, 28, 5, 13, 6, 14, | ||
85 | 21, 29, 36, 44, 52, 60, 37, 45, | ||
86 | 53, 61, 22, 30, 7, 15, 23, 31, | ||
87 | 38, 46, 54, 62, 39, 47, 55, 63 | ||
88 | }; | ||
89 | |||
90 | uint8_t mpeg2_scan_norm[64] IDATA_ATTR; | ||
91 | uint8_t mpeg2_scan_alt[64] IDATA_ATTR; | ||
92 | |||
93 | void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec) | ||
94 | { | ||
95 | if (mpeg2dec->sequence.width != (unsigned)-1) | ||
96 | { | ||
97 | mpeg2dec->sequence.width = (unsigned)-1; | ||
98 | mpeg2_mem_reset(); /* Clean the memory slate */ | ||
99 | #if 0 | ||
100 | if (!mpeg2dec->custom_fbuf) | ||
101 | { | ||
102 | int i; | ||
103 | for (i = mpeg2dec->alloc_index_user; | ||
104 | i < mpeg2dec->alloc_index; i++) | ||
105 | { | ||
106 | mpeg2_free(mpeg2dec->fbuf_alloc[i].fbuf.buf[0]); | ||
107 | #if MPEG2_COLOR | ||
108 | mpeg2_free(mpeg2dec->fbuf_alloc[i].fbuf.buf[1]); | ||
109 | mpeg2_free(mpeg2dec->fbuf_alloc[i].fbuf.buf[2]); | ||
110 | #endif | ||
111 | } | ||
112 | } | ||
113 | |||
114 | if (mpeg2dec->convert_start) | ||
115 | { | ||
116 | int i; | ||
117 | for (i = 0; i < 3; i++) | ||
118 | { | ||
119 | mpeg2_free(mpeg2dec->yuv_buf[i][0]); | ||
120 | #if MPEG2_COLOR | ||
121 | mpeg2_free(mpeg2dec->yuv_buf[i][1]); | ||
122 | mpeg2_free(mpeg2dec->yuv_buf[i][2]); | ||
123 | #endif | ||
124 | } | ||
125 | } | ||
126 | |||
127 | if (mpeg2dec->decoder.convert_id) | ||
128 | { | ||
129 | mpeg2_free(mpeg2dec->decoder.convert_id); | ||
130 | } | ||
131 | #endif | ||
132 | } | ||
133 | |||
134 | mpeg2dec->decoder.coding_type = I_TYPE; | ||
135 | mpeg2dec->decoder.convert = NULL; | ||
136 | mpeg2dec->decoder.convert_id = NULL; | ||
137 | |||
138 | mpeg2dec->picture = mpeg2dec->pictures; | ||
139 | |||
140 | mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf; | ||
141 | mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf; | ||
142 | mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf; | ||
143 | |||
144 | mpeg2dec->first = 1; | ||
145 | mpeg2dec->alloc_index = 0; | ||
146 | mpeg2dec->alloc_index_user = 0; | ||
147 | mpeg2dec->first_decode_slice = 1; | ||
148 | mpeg2dec->nb_decode_slices = 0xb0 - 1; | ||
149 | mpeg2dec->convert = NULL; | ||
150 | mpeg2dec->convert_start = NULL; | ||
151 | mpeg2dec->custom_fbuf = 0; | ||
152 | mpeg2dec->yuv_index = 0; | ||
153 | } | ||
154 | |||
155 | void mpeg2_reset_info (mpeg2_info_t * info) | ||
156 | { | ||
157 | info->current_picture = | ||
158 | info->current_picture_2nd = NULL; | ||
159 | |||
160 | info->display_picture = | ||
161 | info->display_picture_2nd = NULL; | ||
162 | |||
163 | info->current_fbuf = | ||
164 | info->display_fbuf = | ||
165 | info->discard_fbuf = NULL; | ||
166 | } | ||
167 | |||
168 | static void info_user_data (mpeg2dec_t * mpeg2dec) | ||
169 | { | ||
170 | if (mpeg2dec->user_data_len) | ||
171 | { | ||
172 | mpeg2dec->info.user_data = mpeg2dec->chunk_buffer; | ||
173 | mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3; | ||
174 | } | ||
175 | } | ||
176 | |||
177 | int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec) | ||
178 | { | ||
179 | static const unsigned int frame_period[16] = | ||
180 | { | ||
181 | 0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000, | ||
182 | /* unofficial: xing 15 fps */ | ||
183 | 1800000, | ||
184 | /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */ | ||
185 | 5400000, 2700000, 2250000, 1800000, 0, 0 | ||
186 | }; | ||
187 | |||
188 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
189 | mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence; | ||
190 | int i; | ||
191 | |||
192 | if ((buffer[6] & 0x20) != 0x20) /* missing marker_bit */ | ||
193 | return 1; | ||
194 | |||
195 | i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2]; | ||
196 | |||
197 | if (!(sequence->display_width = sequence->picture_width = i >> 12)) | ||
198 | return 1; | ||
199 | |||
200 | if (!(sequence->display_height = sequence->picture_height = i & 0xfff)) | ||
201 | return 1; | ||
202 | |||
203 | sequence->width = (sequence->picture_width + 15) & ~15; | ||
204 | sequence->height = (sequence->picture_height + 15) & ~15; | ||
205 | sequence->chroma_width = sequence->width >> 1; | ||
206 | sequence->chroma_height = sequence->height >> 1; | ||
207 | |||
208 | sequence->flags = SEQ_FLAG_PROGRESSIVE_SEQUENCE | | ||
209 | SEQ_VIDEO_FORMAT_UNSPECIFIED; | ||
210 | |||
211 | sequence->pixel_width = buffer[3] >> 4; /* aspect ratio */ | ||
212 | sequence->frame_period = frame_period[buffer[3] & 15]; | ||
213 | |||
214 | sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6); | ||
215 | |||
216 | sequence->vbv_buffer_size = ((buffer[6]<<16) | (buffer[7]<<8)) & 0x1ff800; | ||
217 | |||
218 | if (buffer[7] & 4) | ||
219 | sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS; | ||
220 | |||
221 | mpeg2dec->copy_matrix = 3; | ||
222 | |||
223 | if (buffer[7] & 2) | ||
224 | { | ||
225 | for (i = 0; i < 64; i++) | ||
226 | { | ||
227 | mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = | ||
228 | (buffer[i+7] << 7) | (buffer[i+8] >> 1); | ||
229 | } | ||
230 | |||
231 | buffer += 64; | ||
232 | } | ||
233 | else | ||
234 | { | ||
235 | for (i = 0; i < 64; i++) | ||
236 | { | ||
237 | mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] = | ||
238 | default_intra_quantizer_matrix[i]; | ||
239 | } | ||
240 | } | ||
241 | |||
242 | if (buffer[7] & 1) | ||
243 | { | ||
244 | for (i = 0; i < 64; i++) | ||
245 | { | ||
246 | mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] = | ||
247 | buffer[i+8]; | ||
248 | } | ||
249 | } | ||
250 | else | ||
251 | { | ||
252 | rb->memset (mpeg2dec->new_quantizer_matrix[1], 16, 64); | ||
253 | } | ||
254 | |||
255 | sequence->profile_level_id = 0x80; | ||
256 | sequence->colour_primaries = 0; | ||
257 | sequence->transfer_characteristics = 0; | ||
258 | sequence->matrix_coefficients = 0; | ||
259 | |||
260 | mpeg2dec->ext_state = SEQ_EXT; | ||
261 | mpeg2dec->state = STATE_SEQUENCE; | ||
262 | |||
263 | mpeg2dec->display_offset_x = | ||
264 | mpeg2dec->display_offset_y = 0; | ||
265 | |||
266 | return 0; | ||
267 | } | ||
268 | |||
269 | static int sequence_ext (mpeg2dec_t * mpeg2dec) | ||
270 | { | ||
271 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
272 | mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence; | ||
273 | uint32_t flags; | ||
274 | |||
275 | if (!(buffer[3] & 1)) | ||
276 | return 1; | ||
277 | |||
278 | sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4); | ||
279 | |||
280 | sequence->picture_width += ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000; | ||
281 | sequence->display_width = sequence->picture_width; | ||
282 | |||
283 | sequence->picture_height += (buffer[2] << 7) & 0x3000; | ||
284 | sequence->display_height = sequence->picture_height; | ||
285 | |||
286 | sequence->width = (sequence->picture_width + 15) & ~15; | ||
287 | sequence->height = (sequence->picture_height + 15) & ~15; | ||
288 | |||
289 | flags = sequence->flags | SEQ_FLAG_MPEG2; | ||
290 | |||
291 | if (!(buffer[1] & 8)) | ||
292 | { | ||
293 | flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE; | ||
294 | sequence->height = (sequence->height + 31) & ~31; | ||
295 | } | ||
296 | |||
297 | if (buffer[5] & 0x80) | ||
298 | flags |= SEQ_FLAG_LOW_DELAY; | ||
299 | |||
300 | sequence->flags = flags; | ||
301 | sequence->chroma_width = sequence->width; | ||
302 | sequence->chroma_height = sequence->height; | ||
303 | |||
304 | switch (buffer[1] & 6) | ||
305 | { | ||
306 | case 0: /* invalid */ | ||
307 | return 1; | ||
308 | case 2: /* 4:2:0 */ | ||
309 | sequence->chroma_height >>= 1; | ||
310 | /* fallthrough */ | ||
311 | case 4: /* 4:2:2 */ | ||
312 | sequence->chroma_width >>= 1; | ||
313 | } | ||
314 | |||
315 | sequence->byte_rate += ((buffer[2]<<25) | (buffer[3]<<17)) & 0x3ffc0000; | ||
316 | |||
317 | sequence->vbv_buffer_size |= buffer[4] << 21; | ||
318 | |||
319 | sequence->frame_period = | ||
320 | sequence->frame_period * ((buffer[5]&31)+1) / (((buffer[5]>>2)&3)+1); | ||
321 | |||
322 | mpeg2dec->ext_state = SEQ_DISPLAY_EXT; | ||
323 | |||
324 | return 0; | ||
325 | } | ||
326 | |||
327 | static int sequence_display_ext (mpeg2dec_t * mpeg2dec) | ||
328 | { | ||
329 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
330 | mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence; | ||
331 | int x; | ||
332 | |||
333 | sequence->flags = (sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) | | ||
334 | ((buffer[0] << 4) & SEQ_MASK_VIDEO_FORMAT); | ||
335 | |||
336 | if (buffer[0] & 1) | ||
337 | { | ||
338 | sequence->flags |= SEQ_FLAG_COLOUR_DESCRIPTION; | ||
339 | sequence->colour_primaries = buffer[1]; | ||
340 | sequence->transfer_characteristics = buffer[2]; | ||
341 | sequence->matrix_coefficients = buffer[3]; | ||
342 | buffer += 3; | ||
343 | } | ||
344 | |||
345 | if (!(buffer[2] & 2)) /* missing marker_bit */ | ||
346 | return 1; | ||
347 | |||
348 | x = (buffer[1] << 6) | (buffer[2] >> 2); | ||
349 | if (x) | ||
350 | sequence->display_width = x; | ||
351 | |||
352 | x = ((buffer[2] & 1) << 13) | (buffer[3] << 5) | (buffer[4] >> 3); | ||
353 | if (x) | ||
354 | sequence->display_height = x; | ||
355 | |||
356 | return 0; | ||
357 | } | ||
358 | |||
359 | static inline void simplify (unsigned int * u, unsigned int * v) | ||
360 | { | ||
361 | unsigned int a, b, tmp; | ||
362 | |||
363 | a = *u; | ||
364 | b = *v; | ||
365 | |||
366 | /* find greatest common divisor */ | ||
367 | while (a) | ||
368 | { | ||
369 | tmp = a; | ||
370 | a = b % tmp; | ||
371 | b = tmp; | ||
372 | } | ||
373 | |||
374 | *u /= b; | ||
375 | *v /= b; | ||
376 | } | ||
377 | |||
378 | static inline void finalize_sequence (mpeg2_sequence_t * sequence) | ||
379 | { | ||
380 | int width; | ||
381 | int height; | ||
382 | |||
383 | sequence->byte_rate *= 50; | ||
384 | |||
385 | if (sequence->flags & SEQ_FLAG_MPEG2) | ||
386 | { | ||
387 | switch (sequence->pixel_width) | ||
388 | { | ||
389 | case 1: /* square pixels */ | ||
390 | sequence->pixel_width = | ||
391 | sequence->pixel_height = 1; | ||
392 | return; | ||
393 | case 2: /* 4:3 aspect ratio */ | ||
394 | width = 4; | ||
395 | height = 3; | ||
396 | break; | ||
397 | case 3: /* 16:9 aspect ratio */ | ||
398 | width = 16; | ||
399 | height = 9; | ||
400 | break; | ||
401 | case 4: /* 2.21:1 aspect ratio */ | ||
402 | width = 221; | ||
403 | height = 100; | ||
404 | break; | ||
405 | default: /* illegal */ | ||
406 | sequence->pixel_width = | ||
407 | sequence->pixel_height = 0; | ||
408 | return; | ||
409 | } | ||
410 | |||
411 | width *= sequence->display_height; | ||
412 | height *= sequence->display_width; | ||
413 | } | ||
414 | else | ||
415 | { | ||
416 | if (sequence->byte_rate == 50 * 0x3ffff) | ||
417 | sequence->byte_rate = 0; /* mpeg-1 VBR */ | ||
418 | |||
419 | switch (sequence->pixel_width) | ||
420 | { | ||
421 | case 0: | ||
422 | case 15: /* illegal */ | ||
423 | sequence->pixel_width = | ||
424 | sequence->pixel_height = 0; | ||
425 | return; | ||
426 | case 1: /* square pixels */ | ||
427 | sequence->pixel_width = | ||
428 | sequence->pixel_height = 1; | ||
429 | return; | ||
430 | case 3: /* 720x576 16:9 */ | ||
431 | sequence->pixel_width = 64; | ||
432 | sequence->pixel_height = 45; | ||
433 | return; | ||
434 | case 6: /* 720x480 16:9 */ | ||
435 | sequence->pixel_width = 32; | ||
436 | sequence->pixel_height = 27; | ||
437 | return; | ||
438 | case 8: /* BT.601 625 lines 4:3 */ | ||
439 | sequence->pixel_width = 59; | ||
440 | sequence->pixel_height = 54; | ||
441 | return; | ||
442 | case 12: /* BT.601 525 lines 4:3 */ | ||
443 | sequence->pixel_width = 10; | ||
444 | sequence->pixel_height = 11; | ||
445 | return; | ||
446 | default: | ||
447 | height = 88 * sequence->pixel_width + 1171; | ||
448 | width = 2000; | ||
449 | } | ||
450 | } | ||
451 | |||
452 | sequence->pixel_width = width; | ||
453 | sequence->pixel_height = height; | ||
454 | |||
455 | simplify(&sequence->pixel_width, &sequence->pixel_height); | ||
456 | } | ||
457 | |||
458 | int mpeg2_guess_aspect (const mpeg2_sequence_t * sequence, | ||
459 | unsigned int * pixel_width, | ||
460 | unsigned int * pixel_height) | ||
461 | { | ||
462 | static const struct | ||
463 | { | ||
464 | unsigned int width, height; | ||
465 | } video_modes[] = | ||
466 | { | ||
467 | {720, 576}, /* 625 lines, 13.5 MHz (D1, DV, DVB, DVD) */ | ||
468 | {704, 576}, /* 625 lines, 13.5 MHz (1/1 D1, DVB, DVD, 4CIF) */ | ||
469 | {544, 576}, /* 625 lines, 10.125 MHz (DVB, laserdisc) */ | ||
470 | {528, 576}, /* 625 lines, 10.125 MHz (3/4 D1, DVB, laserdisc) */ | ||
471 | {480, 576}, /* 625 lines, 9 MHz (2/3 D1, DVB, SVCD) */ | ||
472 | {352, 576}, /* 625 lines, 6.75 MHz (D2, 1/2 D1, CVD, DVB, DVD) */ | ||
473 | {352, 288}, /* 625 lines, 6.75 MHz, 1 field (D4, VCD, DVB, DVD, CIF) */ | ||
474 | {176, 144}, /* 625 lines, 3.375 MHz, half field (QCIF) */ | ||
475 | {720, 486}, /* 525 lines, 13.5 MHz (D1) */ | ||
476 | {704, 486}, /* 525 lines, 13.5 MHz */ | ||
477 | {720, 480}, /* 525 lines, 13.5 MHz (DV, DSS, DVD) */ | ||
478 | {704, 480}, /* 525 lines, 13.5 MHz (1/1 D1, ATSC, DVD) */ | ||
479 | {544, 480}, /* 525 lines. 10.125 MHz (DSS, laserdisc) */ | ||
480 | {528, 480}, /* 525 lines. 10.125 MHz (3/4 D1, laserdisc) */ | ||
481 | {480, 480}, /* 525 lines, 9 MHz (2/3 D1, SVCD) */ | ||
482 | {352, 480}, /* 525 lines, 6.75 MHz (D2, 1/2 D1, CVD, DVD) */ | ||
483 | {352, 240} /* 525 lines. 6.75 MHz, 1 field (D4, VCD, DSS, DVD) */ | ||
484 | }; | ||
485 | unsigned int width, height, pix_width, pix_height, i, DAR_16_9; | ||
486 | |||
487 | *pixel_width = sequence->pixel_width; | ||
488 | *pixel_height = sequence->pixel_height; | ||
489 | width = sequence->picture_width; | ||
490 | height = sequence->picture_height; | ||
491 | |||
492 | for (i = 0; i < sizeof (video_modes) / sizeof (video_modes[0]); i++) | ||
493 | { | ||
494 | if (width == video_modes[i].width && height == video_modes[i].height) | ||
495 | break; | ||
496 | } | ||
497 | |||
498 | if (i == ARRAYLEN(video_modes) || | ||
499 | (sequence->pixel_width == 1 && sequence->pixel_height == 1) || | ||
500 | width != sequence->display_width || height != sequence->display_height) | ||
501 | { | ||
502 | return 0; | ||
503 | } | ||
504 | |||
505 | for (pix_height = 1; height * pix_height < 480; pix_height <<= 1); | ||
506 | height *= pix_height; | ||
507 | |||
508 | for (pix_width = 1; width * pix_width <= 352; pix_width <<= 1); | ||
509 | width *= pix_width; | ||
510 | |||
511 | if (!(sequence->flags & SEQ_FLAG_MPEG2)) | ||
512 | { | ||
513 | static unsigned int mpeg1_check[2][2] = {{11, 54}, {27, 45}}; | ||
514 | DAR_16_9 = (sequence->pixel_height == 27 || | ||
515 | sequence->pixel_height == 45); | ||
516 | if (width < 704 || | ||
517 | sequence->pixel_height != mpeg1_check[DAR_16_9][height == 576]) | ||
518 | return 0; | ||
519 | } | ||
520 | else | ||
521 | { | ||
522 | DAR_16_9 = (3 * sequence->picture_width * sequence->pixel_width > | ||
523 | 4 * sequence->picture_height * sequence->pixel_height); | ||
524 | switch (width) | ||
525 | { | ||
526 | case 528: | ||
527 | case 544: | ||
528 | pix_width *= 4; | ||
529 | pix_height *= 3; | ||
530 | break; | ||
531 | case 480: | ||
532 | pix_width *= 3; | ||
533 | pix_height *= 2; | ||
534 | break; | ||
535 | } | ||
536 | } | ||
537 | |||
538 | if (DAR_16_9) | ||
539 | { | ||
540 | pix_width *= 4; | ||
541 | pix_height *= 3; | ||
542 | } | ||
543 | |||
544 | if (height == 576) | ||
545 | { | ||
546 | pix_width *= 59; | ||
547 | pix_height *= 54; | ||
548 | } | ||
549 | else | ||
550 | { | ||
551 | pix_width *= 10; | ||
552 | pix_height *= 11; | ||
553 | } | ||
554 | |||
555 | *pixel_width = pix_width; | ||
556 | *pixel_height = pix_height; | ||
557 | |||
558 | simplify (pixel_width, pixel_height); | ||
559 | |||
560 | return (height == 576) ? 1 : 2; | ||
561 | } | ||
562 | |||
563 | static void copy_matrix (mpeg2dec_t * mpeg2dec, int index) | ||
564 | { | ||
565 | if (rb->memcmp (mpeg2dec->quantizer_matrix[index], | ||
566 | mpeg2dec->new_quantizer_matrix[index], 64)) | ||
567 | { | ||
568 | rb->memcpy (mpeg2dec->quantizer_matrix[index], | ||
569 | mpeg2dec->new_quantizer_matrix[index], 64); | ||
570 | |||
571 | mpeg2dec->scaled[index] = -1; | ||
572 | } | ||
573 | } | ||
574 | |||
575 | static void finalize_matrix (mpeg2dec_t * mpeg2dec) | ||
576 | { | ||
577 | mpeg2_decoder_t *decoder = &mpeg2dec->decoder; | ||
578 | int i; | ||
579 | |||
580 | for (i = 0; i < 2; i++) | ||
581 | { | ||
582 | if (mpeg2dec->copy_matrix & (1 << i)) | ||
583 | copy_matrix (mpeg2dec, i); | ||
584 | |||
585 | if ((mpeg2dec->copy_matrix & (4 << i)) && | ||
586 | rb->memcmp(mpeg2dec->quantizer_matrix[i], | ||
587 | mpeg2dec->new_quantizer_matrix[i+2], 64)) | ||
588 | { | ||
589 | copy_matrix (mpeg2dec, i + 2); | ||
590 | decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2]; | ||
591 | } | ||
592 | else if (mpeg2dec->copy_matrix & (5 << i)) | ||
593 | { | ||
594 | decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i]; | ||
595 | } | ||
596 | } | ||
597 | } | ||
598 | |||
599 | static mpeg2_state_t invalid_end_action (mpeg2dec_t * mpeg2dec) | ||
600 | { | ||
601 | mpeg2_reset_info (&mpeg2dec->info); | ||
602 | |||
603 | mpeg2dec->info.gop = NULL; | ||
604 | |||
605 | info_user_data (mpeg2dec); | ||
606 | |||
607 | mpeg2_header_state_init (mpeg2dec); | ||
608 | |||
609 | mpeg2dec->sequence = mpeg2dec->new_sequence; | ||
610 | mpeg2dec->action = mpeg2_seek_header; | ||
611 | mpeg2dec->state = STATE_SEQUENCE; | ||
612 | |||
613 | return STATE_SEQUENCE; | ||
614 | } | ||
615 | |||
616 | void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec) | ||
617 | { | ||
618 | mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence; | ||
619 | mpeg2_decoder_t * decoder = &mpeg2dec->decoder; | ||
620 | |||
621 | finalize_sequence(sequence); | ||
622 | finalize_matrix(mpeg2dec); | ||
623 | |||
624 | decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2); | ||
625 | decoder->width = sequence->width; | ||
626 | decoder->height = sequence->height; | ||
627 | decoder->vertical_position_extension = sequence->picture_height > 2800; | ||
628 | decoder->chroma_format = (sequence->chroma_width == sequence->width) + | ||
629 | (sequence->chroma_height == sequence->height); | ||
630 | |||
631 | if (mpeg2dec->sequence.width != (unsigned)-1) | ||
632 | { | ||
633 | /* | ||
634 | * According to 6.1.1.6, repeat sequence headers should be | ||
635 | * identical to the original. However some encoders don't | ||
636 | * respect that and change various fields (including bitrate | ||
637 | * and aspect ratio) in the repeat sequence headers. So we | ||
638 | * choose to be as conservative as possible and only restart | ||
639 | * the decoder if the width, height, chroma_width, | ||
640 | * chroma_height or low_delay flag are modified. | ||
641 | */ | ||
642 | if (sequence->width != mpeg2dec->sequence.width || | ||
643 | sequence->height != mpeg2dec->sequence.height || | ||
644 | sequence->chroma_width != mpeg2dec->sequence.chroma_width || | ||
645 | sequence->chroma_height != mpeg2dec->sequence.chroma_height || | ||
646 | ((sequence->flags ^ mpeg2dec->sequence.flags) & | ||
647 | SEQ_FLAG_LOW_DELAY)) | ||
648 | { | ||
649 | decoder->stride_frame = sequence->width; | ||
650 | mpeg2_header_end (mpeg2dec); | ||
651 | mpeg2dec->action = invalid_end_action; | ||
652 | mpeg2dec->state = STATE_INVALID_END; | ||
653 | return; | ||
654 | } | ||
655 | |||
656 | mpeg2dec->state = rb->memcmp(&mpeg2dec->sequence, sequence, | ||
657 | sizeof (mpeg2_sequence_t)) ? | ||
658 | STATE_SEQUENCE_MODIFIED : | ||
659 | STATE_SEQUENCE_REPEATED; | ||
660 | } | ||
661 | else | ||
662 | { | ||
663 | decoder->stride_frame = sequence->width; | ||
664 | } | ||
665 | |||
666 | mpeg2dec->sequence = *sequence; | ||
667 | mpeg2_reset_info(&mpeg2dec->info); | ||
668 | mpeg2dec->info.sequence = &mpeg2dec->sequence; | ||
669 | mpeg2dec->info.gop = NULL; | ||
670 | |||
671 | info_user_data (mpeg2dec); | ||
672 | } | ||
673 | |||
674 | int mpeg2_header_gop (mpeg2dec_t * mpeg2dec) | ||
675 | { | ||
676 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
677 | mpeg2_gop_t * gop = &mpeg2dec->new_gop; | ||
678 | |||
679 | if (!(buffer[1] & 8)) | ||
680 | return 1; | ||
681 | |||
682 | gop->hours = (buffer[0] >> 2) & 31; | ||
683 | gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63; | ||
684 | gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63; | ||
685 | gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63; | ||
686 | gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6); | ||
687 | |||
688 | mpeg2dec->state = STATE_GOP; | ||
689 | return 0; | ||
690 | } | ||
691 | |||
692 | void mpeg2_header_gop_finalize (mpeg2dec_t * mpeg2dec) | ||
693 | { | ||
694 | mpeg2dec->gop = mpeg2dec->new_gop; | ||
695 | mpeg2_reset_info (&mpeg2dec->info); | ||
696 | mpeg2dec->info.gop = &mpeg2dec->gop; | ||
697 | info_user_data (mpeg2dec); | ||
698 | } | ||
699 | |||
700 | void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type) | ||
701 | { | ||
702 | int i; | ||
703 | |||
704 | for (i = 0; i < 3; i++) | ||
705 | { | ||
706 | if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf && | ||
707 | mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) | ||
708 | { | ||
709 | mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf; | ||
710 | mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0]; | ||
711 | |||
712 | if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) | ||
713 | { | ||
714 | if (b_type || mpeg2dec->convert) | ||
715 | mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0]; | ||
716 | |||
717 | mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0]; | ||
718 | } | ||
719 | |||
720 | break; | ||
721 | } | ||
722 | } | ||
723 | } | ||
724 | |||
725 | int mpeg2_header_picture (mpeg2dec_t * mpeg2dec) | ||
726 | { | ||
727 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
728 | mpeg2_picture_t * picture = &mpeg2dec->new_picture; | ||
729 | mpeg2_decoder_t * decoder = &mpeg2dec->decoder; | ||
730 | int type; | ||
731 | |||
732 | mpeg2dec->state = (mpeg2dec->state != STATE_SLICE_1ST) ? | ||
733 | STATE_PICTURE : STATE_PICTURE_2ND; | ||
734 | mpeg2dec->ext_state = PIC_CODING_EXT; | ||
735 | |||
736 | picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6); | ||
737 | |||
738 | type = (buffer [1] >> 3) & 7; | ||
739 | |||
740 | if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) | ||
741 | { | ||
742 | /* forward_f_code and backward_f_code - used in mpeg1 only */ | ||
743 | decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1; | ||
744 | decoder->f_motion.f_code[0] = | ||
745 | (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1; | ||
746 | decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1; | ||
747 | decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1; | ||
748 | } | ||
749 | |||
750 | picture->flags = PIC_FLAG_PROGRESSIVE_FRAME | type; | ||
751 | picture->tag = picture->tag2 = 0; | ||
752 | |||
753 | if (mpeg2dec->num_tags) | ||
754 | { | ||
755 | if (mpeg2dec->bytes_since_tag >= mpeg2dec->chunk_ptr - buffer + 4) | ||
756 | { | ||
757 | mpeg2dec->num_tags = 0; | ||
758 | picture->tag = mpeg2dec->tag_current; | ||
759 | picture->tag2 = mpeg2dec->tag2_current; | ||
760 | picture->flags |= PIC_FLAG_TAGS; | ||
761 | } | ||
762 | else if (mpeg2dec->num_tags > 1) | ||
763 | { | ||
764 | mpeg2dec->num_tags = 1; | ||
765 | picture->tag = mpeg2dec->tag_previous; | ||
766 | picture->tag2 = mpeg2dec->tag2_previous; | ||
767 | picture->flags |= PIC_FLAG_TAGS; | ||
768 | } | ||
769 | } | ||
770 | |||
771 | picture->nb_fields = 2; | ||
772 | picture->display_offset[0].x = picture->display_offset[1].x = | ||
773 | picture->display_offset[2].x = mpeg2dec->display_offset_x; | ||
774 | |||
775 | picture->display_offset[0].y = picture->display_offset[1].y = | ||
776 | picture->display_offset[2].y = mpeg2dec->display_offset_y; | ||
777 | |||
778 | /* XXXXXX decode extra_information_picture as well */ | ||
779 | |||
780 | mpeg2dec->q_scale_type = 0; | ||
781 | decoder->intra_dc_precision = 7; | ||
782 | decoder->frame_pred_frame_dct = 1; | ||
783 | decoder->concealment_motion_vectors = 0; | ||
784 | decoder->scan = mpeg2_scan_norm; | ||
785 | decoder->picture_structure = FRAME_PICTURE; | ||
786 | mpeg2dec->copy_matrix = 0; | ||
787 | |||
788 | return 0; | ||
789 | } | ||
790 | |||
791 | static int picture_coding_ext (mpeg2dec_t * mpeg2dec) | ||
792 | { | ||
793 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
794 | mpeg2_picture_t * picture = &mpeg2dec->new_picture; | ||
795 | mpeg2_decoder_t * decoder = &mpeg2dec->decoder; | ||
796 | uint32_t flags; | ||
797 | |||
798 | /* pre subtract 1 for use later in compute_motion_vector */ | ||
799 | decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1; | ||
800 | decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1; | ||
801 | decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1; | ||
802 | decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1; | ||
803 | |||
804 | flags = picture->flags; | ||
805 | |||
806 | decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3); | ||
807 | decoder->picture_structure = buffer[2] & 3; | ||
808 | |||
809 | switch (decoder->picture_structure) | ||
810 | { | ||
811 | case TOP_FIELD: | ||
812 | flags |= PIC_FLAG_TOP_FIELD_FIRST; | ||
813 | case BOTTOM_FIELD: | ||
814 | picture->nb_fields = 1; | ||
815 | break; | ||
816 | case FRAME_PICTURE: | ||
817 | if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) | ||
818 | { | ||
819 | picture->nb_fields = (buffer[3] & 2) ? 3 : 2; | ||
820 | flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0; | ||
821 | } | ||
822 | else | ||
823 | { | ||
824 | picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2; | ||
825 | } | ||
826 | break; | ||
827 | default: | ||
828 | return 1; | ||
829 | } | ||
830 | |||
831 | decoder->top_field_first = buffer[3] >> 7; | ||
832 | decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1; | ||
833 | decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1; | ||
834 | mpeg2dec->q_scale_type = buffer[3] & 16; | ||
835 | decoder->intra_vlc_format = (buffer[3] >> 3) & 1; | ||
836 | decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm; | ||
837 | |||
838 | if (!(buffer[4] & 0x80)) | ||
839 | flags &= ~PIC_FLAG_PROGRESSIVE_FRAME; | ||
840 | |||
841 | if (buffer[4] & 0x40) | ||
842 | { | ||
843 | flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) & | ||
844 | PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY; | ||
845 | } | ||
846 | |||
847 | picture->flags = flags; | ||
848 | |||
849 | mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT; | ||
850 | |||
851 | return 0; | ||
852 | } | ||
853 | |||
854 | static int picture_display_ext (mpeg2dec_t * mpeg2dec) | ||
855 | { | ||
856 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
857 | mpeg2_picture_t * picture = &mpeg2dec->new_picture; | ||
858 | int i, nb_pos; | ||
859 | |||
860 | nb_pos = picture->nb_fields; | ||
861 | |||
862 | if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) | ||
863 | nb_pos >>= 1; | ||
864 | |||
865 | for (i = 0; i < nb_pos; i++) | ||
866 | { | ||
867 | int x, y; | ||
868 | |||
869 | x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) | | ||
870 | (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i); | ||
871 | |||
872 | y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) | | ||
873 | (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i); | ||
874 | |||
875 | if (! (x & y & 1)) | ||
876 | return 1; | ||
877 | |||
878 | picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1; | ||
879 | picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1; | ||
880 | } | ||
881 | |||
882 | for (; i < 3; i++) | ||
883 | { | ||
884 | picture->display_offset[i].x = mpeg2dec->display_offset_x; | ||
885 | picture->display_offset[i].y = mpeg2dec->display_offset_y; | ||
886 | } | ||
887 | |||
888 | return 0; | ||
889 | } | ||
890 | |||
891 | void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec) | ||
892 | { | ||
893 | mpeg2_decoder_t * decoder = &mpeg2dec->decoder; | ||
894 | int old_type_b = decoder->coding_type == B_TYPE; | ||
895 | int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY; | ||
896 | |||
897 | finalize_matrix (mpeg2dec); | ||
898 | decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE; | ||
899 | |||
900 | if (mpeg2dec->state == STATE_PICTURE) | ||
901 | { | ||
902 | mpeg2_picture_t * picture; | ||
903 | mpeg2_picture_t * other; | ||
904 | |||
905 | decoder->second_field = 0; | ||
906 | |||
907 | picture = other = mpeg2dec->pictures; | ||
908 | |||
909 | if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2)) | ||
910 | picture += 2; | ||
911 | else | ||
912 | other += 2; | ||
913 | |||
914 | mpeg2dec->picture = picture; | ||
915 | *picture = mpeg2dec->new_picture; | ||
916 | |||
917 | if (!old_type_b) | ||
918 | { | ||
919 | mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1]; | ||
920 | mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0]; | ||
921 | } | ||
922 | |||
923 | mpeg2dec->fbuf[0] = NULL; | ||
924 | mpeg2_reset_info (&mpeg2dec->info); | ||
925 | mpeg2dec->info.current_picture = picture; | ||
926 | mpeg2dec->info.display_picture = picture; | ||
927 | |||
928 | if (decoder->coding_type != B_TYPE) | ||
929 | { | ||
930 | if (!low_delay) | ||
931 | { | ||
932 | if (mpeg2dec->first) | ||
933 | { | ||
934 | mpeg2dec->info.display_picture = NULL; | ||
935 | mpeg2dec->first = 0; | ||
936 | } | ||
937 | else | ||
938 | { | ||
939 | mpeg2dec->info.display_picture = other; | ||
940 | |||
941 | if (other->nb_fields == 1) | ||
942 | mpeg2dec->info.display_picture_2nd = other + 1; | ||
943 | |||
944 | mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1]; | ||
945 | } | ||
946 | } | ||
947 | |||
948 | if (!low_delay + !mpeg2dec->convert) | ||
949 | { | ||
950 | mpeg2dec->info.discard_fbuf = | ||
951 | mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert]; | ||
952 | } | ||
953 | } | ||
954 | |||
955 | if (mpeg2dec->convert) | ||
956 | { | ||
957 | mpeg2_convert_init_t convert_init; | ||
958 | |||
959 | if (!mpeg2dec->convert_start) | ||
960 | { | ||
961 | mpeg2dec->decoder.convert_id = | ||
962 | mpeg2_malloc (mpeg2dec->convert_id_size, | ||
963 | MPEG2_ALLOC_CONVERT_ID); | ||
964 | |||
965 | mpeg2dec->convert (MPEG2_CONVERT_START, | ||
966 | mpeg2dec->decoder.convert_id, | ||
967 | &mpeg2dec->sequence, | ||
968 | mpeg2dec->convert_stride, | ||
969 | mpeg2dec->convert_arg, &convert_init); | ||
970 | |||
971 | mpeg2dec->convert_start = convert_init.start; | ||
972 | mpeg2dec->decoder.convert = convert_init.copy; | ||
973 | |||
974 | int y_size = decoder->stride_frame * mpeg2dec->sequence.height; | ||
975 | |||
976 | mpeg2dec->yuv_buf[0][0] = | ||
977 | (uint8_t *) mpeg2_malloc(y_size, MPEG2_ALLOC_YUV); | ||
978 | #if MPEG2_COLOR | ||
979 | int uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format); | ||
980 | |||
981 | mpeg2dec->yuv_buf[0][1] = | ||
982 | (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV); | ||
983 | mpeg2dec->yuv_buf[0][2] = | ||
984 | (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV); | ||
985 | #endif | ||
986 | |||
987 | mpeg2dec->yuv_buf[1][0] = | ||
988 | (uint8_t *) mpeg2_malloc(y_size, MPEG2_ALLOC_YUV); | ||
989 | #if MPEG2_COLOR | ||
990 | mpeg2dec->yuv_buf[1][1] = | ||
991 | (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV); | ||
992 | mpeg2dec->yuv_buf[1][2] = | ||
993 | (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV); | ||
994 | #endif | ||
995 | y_size = decoder->stride_frame * 32; | ||
996 | |||
997 | mpeg2dec->yuv_buf[2][0] = | ||
998 | (uint8_t *) mpeg2_malloc(y_size, MPEG2_ALLOC_YUV); | ||
999 | #if MPEG2_COLOR | ||
1000 | uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format); | ||
1001 | |||
1002 | mpeg2dec->yuv_buf[2][1] = | ||
1003 | (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV); | ||
1004 | mpeg2dec->yuv_buf[2][2] = | ||
1005 | (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV); | ||
1006 | #endif | ||
1007 | } | ||
1008 | |||
1009 | if (!mpeg2dec->custom_fbuf) | ||
1010 | { | ||
1011 | while (mpeg2dec->alloc_index < 3) | ||
1012 | { | ||
1013 | mpeg2_fbuf_t * fbuf; | ||
1014 | |||
1015 | fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf; | ||
1016 | fbuf->id = NULL; | ||
1017 | |||
1018 | fbuf->buf[0] = | ||
1019 | (uint8_t *) mpeg2_malloc (convert_init.buf_size[0], | ||
1020 | MPEG2_ALLOC_CONVERTED); | ||
1021 | #if MPEG2_COLOR | ||
1022 | fbuf->buf[1] = | ||
1023 | (uint8_t *) mpeg2_malloc (convert_init.buf_size[1], | ||
1024 | MPEG2_ALLOC_CONVERTED); | ||
1025 | fbuf->buf[2] = | ||
1026 | (uint8_t *) mpeg2_malloc (convert_init.buf_size[2], | ||
1027 | MPEG2_ALLOC_CONVERTED); | ||
1028 | #endif | ||
1029 | } | ||
1030 | |||
1031 | mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE)); | ||
1032 | } | ||
1033 | } | ||
1034 | else if (!mpeg2dec->custom_fbuf) | ||
1035 | { | ||
1036 | while (mpeg2dec->alloc_index < 3) | ||
1037 | { | ||
1038 | mpeg2_fbuf_t * fbuf; | ||
1039 | |||
1040 | fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf; | ||
1041 | |||
1042 | fbuf->id = NULL; | ||
1043 | |||
1044 | int y_size = decoder->stride_frame * mpeg2dec->sequence.height; | ||
1045 | |||
1046 | fbuf->buf[0] = (uint8_t *) mpeg2_malloc (y_size, | ||
1047 | MPEG2_ALLOC_YUV); | ||
1048 | #if MPEG2_COLOR | ||
1049 | int uv_size = y_size >> (2 - decoder->chroma_format); | ||
1050 | |||
1051 | fbuf->buf[1] = (uint8_t *) mpeg2_malloc (uv_size, | ||
1052 | MPEG2_ALLOC_YUV); | ||
1053 | fbuf->buf[2] = (uint8_t *) mpeg2_malloc (uv_size, | ||
1054 | MPEG2_ALLOC_YUV); | ||
1055 | #endif | ||
1056 | } | ||
1057 | |||
1058 | mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE)); | ||
1059 | } | ||
1060 | } | ||
1061 | else | ||
1062 | { | ||
1063 | decoder->second_field = 1; | ||
1064 | mpeg2dec->picture++; /* second field picture */ | ||
1065 | |||
1066 | *(mpeg2dec->picture) = mpeg2dec->new_picture; | ||
1067 | |||
1068 | mpeg2dec->info.current_picture_2nd = mpeg2dec->picture; | ||
1069 | |||
1070 | if (low_delay || decoder->coding_type == B_TYPE) | ||
1071 | mpeg2dec->info.display_picture_2nd = mpeg2dec->picture; | ||
1072 | } | ||
1073 | |||
1074 | info_user_data (mpeg2dec); | ||
1075 | } | ||
1076 | |||
1077 | static int copyright_ext (mpeg2dec_t * mpeg2dec) | ||
1078 | { | ||
1079 | (void)mpeg2dec; | ||
1080 | return 0; | ||
1081 | } | ||
1082 | |||
1083 | static int quant_matrix_ext (mpeg2dec_t * mpeg2dec) | ||
1084 | { | ||
1085 | uint8_t * buffer = mpeg2dec->chunk_start; | ||
1086 | int i, j; | ||
1087 | |||
1088 | for (i = 0; i < 4; i++) | ||
1089 | { | ||
1090 | if (buffer[0] & (8 >> i)) | ||
1091 | { | ||
1092 | for (j = 0; j < 64; j++) | ||
1093 | { | ||
1094 | mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] = | ||
1095 | (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i)); | ||
1096 | } | ||
1097 | |||
1098 | mpeg2dec->copy_matrix |= 1 << i; | ||
1099 | buffer += 64; | ||
1100 | } | ||
1101 | } | ||
1102 | |||
1103 | return 0; | ||
1104 | } | ||
1105 | |||
1106 | int mpeg2_header_extension (mpeg2dec_t * mpeg2dec) | ||
1107 | { | ||
1108 | static int (* const parser[9]) (mpeg2dec_t *) = | ||
1109 | { | ||
1110 | NULL, | ||
1111 | sequence_ext, | ||
1112 | sequence_display_ext, | ||
1113 | quant_matrix_ext, | ||
1114 | copyright_ext, | ||
1115 | NULL, | ||
1116 | NULL, | ||
1117 | picture_display_ext, | ||
1118 | picture_coding_ext | ||
1119 | }; | ||
1120 | |||
1121 | int ext, ext_bit; | ||
1122 | |||
1123 | ext = mpeg2dec->chunk_start[0] >> 4; | ||
1124 | ext_bit = 1 << ext; | ||
1125 | |||
1126 | if (!(mpeg2dec->ext_state & ext_bit)) | ||
1127 | return 0; /* ignore illegal extensions */ | ||
1128 | |||
1129 | mpeg2dec->ext_state &= ~ext_bit; | ||
1130 | |||
1131 | return parser[ext] (mpeg2dec); | ||
1132 | } | ||
1133 | |||
1134 | int mpeg2_header_user_data (mpeg2dec_t * mpeg2dec) | ||
1135 | { | ||
1136 | mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start; | ||
1137 | mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1; | ||
1138 | |||
1139 | return 0; | ||
1140 | } | ||
1141 | |||
1142 | static void prescale (mpeg2dec_t * mpeg2dec, int index) | ||
1143 | { | ||
1144 | static const int non_linear_scale[32] = | ||
1145 | { | ||
1146 | 0, 1, 2, 3, 4, 5, 6, 7, | ||
1147 | 8, 10, 12, 14, 16, 18, 20, 22, | ||
1148 | 24, 28, 32, 36, 40, 44, 48, 52, | ||
1149 | 56, 64, 72, 80, 88, 96, 104, 112 | ||
1150 | }; | ||
1151 | |||
1152 | int i, j, k; | ||
1153 | mpeg2_decoder_t * decoder = &mpeg2dec->decoder; | ||
1154 | |||
1155 | if (mpeg2dec->scaled[index] != mpeg2dec->q_scale_type) | ||
1156 | { | ||
1157 | mpeg2dec->scaled[index] = mpeg2dec->q_scale_type; | ||
1158 | |||
1159 | for (i = 0; i < 32; i++) | ||
1160 | { | ||
1161 | k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1); | ||
1162 | |||
1163 | for (j = 0; j < 64; j++) | ||
1164 | { | ||
1165 | decoder->quantizer_prescale[index][i][j] = | ||
1166 | k * mpeg2dec->quantizer_matrix[index][j]; | ||
1167 | } | ||
1168 | } | ||
1169 | } | ||
1170 | } | ||
1171 | |||
1172 | mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec) | ||
1173 | { | ||
1174 | mpeg2_decoder_t * decoder = &mpeg2dec->decoder; | ||
1175 | |||
1176 | mpeg2dec->info.user_data = NULL; | ||
1177 | mpeg2dec->info.user_data_len = 0; | ||
1178 | mpeg2dec->state = (mpeg2dec->picture->nb_fields > 1 || | ||
1179 | mpeg2dec->state == STATE_PICTURE_2ND) ? | ||
1180 | STATE_SLICE : STATE_SLICE_1ST; | ||
1181 | |||
1182 | if (mpeg2dec->decoder.coding_type != D_TYPE) | ||
1183 | { | ||
1184 | prescale (mpeg2dec, 0); | ||
1185 | |||
1186 | if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2]) | ||
1187 | prescale (mpeg2dec, 2); | ||
1188 | |||
1189 | if (mpeg2dec->decoder.coding_type != I_TYPE) | ||
1190 | { | ||
1191 | prescale (mpeg2dec, 1); | ||
1192 | |||
1193 | if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3]) | ||
1194 | prescale (mpeg2dec, 3); | ||
1195 | } | ||
1196 | } | ||
1197 | |||
1198 | if (!(mpeg2dec->nb_decode_slices)) | ||
1199 | { | ||
1200 | mpeg2dec->picture->flags |= PIC_FLAG_SKIP; | ||
1201 | } | ||
1202 | else if (mpeg2dec->convert_start) | ||
1203 | { | ||
1204 | mpeg2dec->convert_start (decoder->convert_id, mpeg2dec->fbuf[0], | ||
1205 | mpeg2dec->picture, mpeg2dec->info.gop); | ||
1206 | |||
1207 | if (mpeg2dec->decoder.coding_type == B_TYPE) | ||
1208 | { | ||
1209 | mpeg2_init_fbuf (&mpeg2dec->decoder, mpeg2dec->yuv_buf[2], | ||
1210 | mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1], | ||
1211 | mpeg2dec->yuv_buf[mpeg2dec->yuv_index]); | ||
1212 | } | ||
1213 | else | ||
1214 | { | ||
1215 | mpeg2_init_fbuf (&mpeg2dec->decoder, | ||
1216 | mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1], | ||
1217 | mpeg2dec->yuv_buf[mpeg2dec->yuv_index], | ||
1218 | mpeg2dec->yuv_buf[mpeg2dec->yuv_index]); | ||
1219 | |||
1220 | if (mpeg2dec->state == STATE_SLICE) | ||
1221 | mpeg2dec->yuv_index ^= 1; | ||
1222 | } | ||
1223 | } | ||
1224 | else | ||
1225 | { | ||
1226 | int b_type; | ||
1227 | |||
1228 | b_type = (mpeg2dec->decoder.coding_type == B_TYPE); | ||
1229 | |||
1230 | mpeg2_init_fbuf (&mpeg2dec->decoder, mpeg2dec->fbuf[0]->buf, | ||
1231 | mpeg2dec->fbuf[b_type + 1]->buf, | ||
1232 | mpeg2dec->fbuf[b_type]->buf); | ||
1233 | } | ||
1234 | |||
1235 | mpeg2dec->action = NULL; | ||
1236 | |||
1237 | return STATE_INTERNAL_NORETURN; | ||
1238 | } | ||
1239 | |||
1240 | static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec) | ||
1241 | { | ||
1242 | mpeg2_reset_info (&mpeg2dec->info); | ||
1243 | |||
1244 | mpeg2dec->info.sequence = NULL; | ||
1245 | mpeg2dec->info.gop = NULL; | ||
1246 | |||
1247 | mpeg2_header_state_init (mpeg2dec); | ||
1248 | |||
1249 | mpeg2dec->action = mpeg2_seek_header; | ||
1250 | |||
1251 | return mpeg2_seek_header (mpeg2dec); | ||
1252 | } | ||
1253 | |||
1254 | mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec) | ||
1255 | { | ||
1256 | mpeg2_picture_t * picture; | ||
1257 | int b_type; | ||
1258 | |||
1259 | b_type = (mpeg2dec->decoder.coding_type == B_TYPE); | ||
1260 | picture = mpeg2dec->pictures; | ||
1261 | |||
1262 | if ((mpeg2dec->picture >= picture + 2) ^ b_type) | ||
1263 | picture = mpeg2dec->pictures + 2; | ||
1264 | |||
1265 | mpeg2_reset_info (&mpeg2dec->info); | ||
1266 | |||
1267 | if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) | ||
1268 | { | ||
1269 | mpeg2dec->info.display_picture = picture; | ||
1270 | |||
1271 | if (picture->nb_fields == 1) | ||
1272 | mpeg2dec->info.display_picture_2nd = picture + 1; | ||
1273 | |||
1274 | mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type]; | ||
1275 | |||
1276 | if (!mpeg2dec->convert) | ||
1277 | mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1]; | ||
1278 | } | ||
1279 | else if (!mpeg2dec->convert) | ||
1280 | { | ||
1281 | mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type]; | ||
1282 | } | ||
1283 | |||
1284 | mpeg2dec->action = seek_sequence; | ||
1285 | |||
1286 | return STATE_END; | ||
1287 | } | ||