A modern Music Player Daemon based on Rockbox open source high quality audio player
tsiry-sandratraina.com
libadwaita
audio
rust
zig
deno
mpris
rockbox
mpd
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 */
45static 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
64const 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
77const 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
90uint8_t mpeg2_scan_norm[64] IDATA_ATTR;
91uint8_t mpeg2_scan_alt[64] IDATA_ATTR;
92
93void 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
155void 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
168static 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
177int 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
269static 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
327static 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
359static 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
378static 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
458int 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
563static 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
575static 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
599static 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
616void 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
674int 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
692void 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
700void 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
725int 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
791static 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
854static 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
891void 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
1077static int copyright_ext (mpeg2dec_t * mpeg2dec)
1078{
1079 (void)mpeg2dec;
1080 return 0;
1081}
1082
1083static 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
1106int 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
1134int 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
1142static 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
1172mpeg2_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
1240static 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
1254mpeg2_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}