1 /* Gstreamer
2 * Copyright (C) <2011> Intel
3 * Copyright (C) <2011> Collabora Ltd.
4 * Copyright (C) <2011> Thibault Saunier <thibault.saunier@collabora.com>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 */
21 /**
22 * SECTION:gstvc1parser
23 * @title: GstVc1Parser
24 * @short_description: Convenience library for parsing vc1 video
25 * bitstream.
26 *
27 * For more details about the structures, look at the
28 * smpte specifications (S421m-2006.pdf).
29 *
30 */
31
32 #ifdef HAVE_CONFIG_H
33 # include "config.h"
34 #endif
35
36 #include "gstvc1parser.h"
37 #include "parserutils.h"
38 #include <gst/base/gstbytereader.h>
39 #include <gst/base/gstbytewriter.h>
40 #include <gst/base/gstbitreader.h>
41 #include <string.h>
42
43 #ifndef GST_DISABLE_GST_DEBUG
44
45 #define GST_CAT_DEFAULT ensure_debug_category()
46
47 static GstDebugCategory *
ensure_debug_category(void)48 ensure_debug_category (void)
49 {
50 static gsize cat_gonce = 0;
51
52 if (g_once_init_enter (&cat_gonce)) {
53 gsize cat_done;
54
55 cat_done = (gsize) _gst_debug_category_new ("codecparsers_vc1", 0,
56 "VC1 codec parsing library");
57
58 g_once_init_leave (&cat_gonce, cat_done);
59 }
60
61 return (GstDebugCategory *) cat_gonce;
62 }
63
64 #else
65
66 #define ensure_debug_category() /* NOOP */
67
68 #endif /* GST_DISABLE_GST_DEBUG */
69
70 static const guint8 vc1_pquant_table[3][32] = {
71 { /* Implicit quantizer */
72 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12,
73 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31},
74 { /* Explicit quantizer, pquantizer uniform */
75 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
76 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
77 { /* Explicit quantizer, pquantizer non-uniform */
78 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
79 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31}
80 };
81
82 static const guint8 vc1_mvmode_table[2][5] = {
83 /* Table 47: P Picture High rate (PQUANT <= 12) MVMODE code table */
84 {
85 GST_VC1_MVMODE_1MV,
86 GST_VC1_MVMODE_MIXED_MV,
87 GST_VC1_MVMODE_1MV_HPEL,
88 GST_VC1_MVMODE_INTENSITY_COMP,
89 GST_VC1_MVMODE_1MV_HPEL_BILINEAR},
90 /* Table 46: P Picture Low rate (PQUANT > 12) MVMODE code table */
91 {
92 GST_VC1_MVMODE_1MV_HPEL_BILINEAR,
93 GST_VC1_MVMODE_1MV,
94 GST_VC1_MVMODE_1MV_HPEL,
95 GST_VC1_MVMODE_INTENSITY_COMP,
96 GST_VC1_MVMODE_MIXED_MV}
97 };
98
99 static const guint8 vc1_mvmode2_table[2][4] = {
100 /* Table 50: P Picture High rate (PQUANT <= 12) MVMODE2 code table */
101 {
102 GST_VC1_MVMODE_1MV,
103 GST_VC1_MVMODE_MIXED_MV,
104 GST_VC1_MVMODE_1MV_HPEL,
105 GST_VC1_MVMODE_1MV_HPEL_BILINEAR},
106 /* Table 49: P Picture Low rate (PQUANT > 12) MVMODE2 code table */
107 {
108 GST_VC1_MVMODE_1MV_HPEL_BILINEAR,
109 GST_VC1_MVMODE_1MV,
110 GST_VC1_MVMODE_1MV_HPEL,
111 GST_VC1_MVMODE_MIXED_MV}
112 };
113
114 /* Table 40: BFRACTION VLC Table */
115 static const VLCTable vc1_bfraction_vlc_table[] = {
116 {GST_VC1_BFRACTION_BASIS / 2, 0x00, 3},
117 {GST_VC1_BFRACTION_BASIS / 3, 0x01, 3},
118 {(GST_VC1_BFRACTION_BASIS * 2) / 3, 0x02, 3},
119 {GST_VC1_BFRACTION_BASIS / 4, 0x02, 3},
120 {(GST_VC1_BFRACTION_BASIS * 3) / 4, 0x04, 3},
121 {GST_VC1_BFRACTION_BASIS / 5, 0x05, 3},
122 {(GST_VC1_BFRACTION_BASIS * 2) / 5, 0x06, 3},
123 {(GST_VC1_BFRACTION_BASIS * 3) / 5, 0x70, 7},
124 {(GST_VC1_BFRACTION_BASIS * 4) / 5, 0x71, 7},
125 {GST_VC1_BFRACTION_BASIS / 6, 0x72, 7},
126 {(GST_VC1_BFRACTION_BASIS * 5) / 6, 0x73, 7},
127 {GST_VC1_BFRACTION_BASIS / 7, 0x74, 7},
128 {(GST_VC1_BFRACTION_BASIS * 2) / 7, 0x75, 7},
129 {(GST_VC1_BFRACTION_BASIS * 3) / 7, 0x76, 7},
130 {(GST_VC1_BFRACTION_BASIS * 4) / 7, 0x77, 7},
131 {(GST_VC1_BFRACTION_BASIS * 5) / 7, 0x78, 7},
132 {(GST_VC1_BFRACTION_BASIS * 6) / 7, 0x79, 7},
133 {GST_VC1_BFRACTION_BASIS / 8, 0x7a, 7},
134 {(GST_VC1_BFRACTION_BASIS * 3) / 8, 0x7b, 7},
135 {(GST_VC1_BFRACTION_BASIS * 5) / 8, 0x7c, 7},
136 {(GST_VC1_BFRACTION_BASIS * 7) / 8, 0x7d, 7},
137 {GST_VC1_BFRACTION_RESERVED, 0x7e, 7},
138 {GST_VC1_BFRACTION_PTYPE_BI, 0x7f, 7}
139 };
140
141 /* Imode types */
142 enum
143 {
144 IMODE_RAW,
145 IMODE_NORM2,
146 IMODE_DIFF2,
147 IMODE_NORM6,
148 IMODE_DIFF6,
149 IMODE_ROWSKIP,
150 IMODE_COLSKIP
151 };
152
153 /* Table 69: IMODE VLC Codetable */
154 static const VLCTable vc1_imode_vlc_table[] = {
155 {IMODE_NORM2, 0x02, 2},
156 {IMODE_NORM6, 0x03, 2},
157 {IMODE_ROWSKIP, 0x02, 3},
158 {IMODE_COLSKIP, 0x03, 3},
159 {IMODE_DIFF2, 0x01, 3},
160 {IMODE_DIFF6, 0x01, 4},
161 {IMODE_RAW, 0x00, 4}
162 };
163
164 /* Table 80: Norm-2/Diff-2 Code Table */
165 static const VLCTable vc1_norm2_vlc_table[4] = {
166 {0, 0, 1},
167 {2, 4, 3},
168 {1, 5, 3},
169 {3, 3, 2}
170 };
171
172 /* Table 81: Code table for 3x2 and 2x3 tiles */
173 static const VLCTable vc1_norm6_vlc_table[64] = {
174 {0, 1, 1},
175 {1, 2, 4},
176 {2, 3, 4},
177 {3, 0, 8},
178 {4, 4, 4},
179 {5, 1, 8},
180 {6, 2, 8},
181 {7, (2 << 5) | 7, 10},
182 {8, 5, 4},
183 {9, 3, 8},
184 {10, 4, 8},
185 {11, (2 << 5) | 11, 10},
186 {12, 5, 8},
187 {13, (2 << 5) | 13, 10},
188 {14, (2 << 5) | 14, 10},
189 {15, (3 << 8) | 14, 13},
190 {16, 6, 4},
191 {17, 6, 8},
192 {18, 7, 8},
193 {19, (2 << 5) | 19, 10},
194 {20, 8, 8},
195 {21, (2 << 5) | 21, 10},
196 {22, (2 << 5) | 22, 10},
197 {23, (3 << 8) | 13, 13},
198 {24, 9, 8},
199 {25, (2 << 5) | 25, 10},
200 {26, (2 << 5) | 26, 10},
201 {27, (3 << 8) | 12, 13},
202 {28, (2 << 5) | 28, 10},
203 {29, (3 << 8) | 11, 13},
204 {30, (3 << 8) | 10, 13},
205 {31, (3 << 4) | 7, 9},
206 {32, 7, 4},
207 {33, 10, 8},
208 {34, 11, 8},
209 {35, (2 << 5) | 3, 10},
210 {36, 12, 8},
211 {37, (2 << 5) | 5, 10},
212 {38, (2 << 5) | 6, 10},
213 {39, (3 << 8) | 9, 13},
214 {40, 13, 8},
215 {41, (2 << 5) | 9, 10},
216 {42, (2 << 5) | 10, 10},
217 {43, (3 << 8) | 8, 13},
218 {44, (2 << 5) | 12, 10},
219 {45, (3 << 8) | 7, 13},
220 {46, (3 << 8) | 6, 13},
221 {47, (3 << 4) | 6, 9},
222 {48, 14, 8},
223 {49, (2 << 5) | 17, 10},
224 {50, (2 << 5) | 18, 10},
225 {51, (3 << 8) | 5, 13},
226 {52, (2 << 5) | 20, 10},
227 {53, (3 << 8) | 4, 13},
228 {54, (3 << 8) | 3, 13},
229 {55, (3 << 4) | 5, 9},
230 {56, (2 << 5) | 24, 10},
231 {57, (3 << 8) | 2, 13},
232 {58, (3 << 8) | 1, 13},
233 {59, (3 << 4) | 4, 9},
234 {60, (3 << 8) | 0, 13},
235 {61, (3 << 4) | 3, 9},
236 {62, (3 << 4) | 2, 9},
237 {63, (3 << 1) | 1, 6}
238 };
239
240 /* SMPTE 421M Table 7 */
241 typedef struct
242 {
243 gint par_n, par_d;
244 } PAR;
245
246 static const PAR aspect_ratios[] = {
247 {0, 0},
248 {1, 1},
249 {12, 11},
250 {10, 11},
251 {16, 11},
252 {40, 33},
253 {24, 11},
254 {20, 11},
255 {32, 11},
256 {80, 33},
257 {18, 11},
258 {15, 11},
259 {64, 33},
260 {160, 99},
261 {0, 0},
262 {0, 0}
263 };
264
265 /* SMPTE 421M Table 8 */
266 static const guint framerates_n[] = {
267 0,
268 24 * 1000,
269 25 * 1000,
270 30 * 1000,
271 50 * 1000,
272 60 * 1000,
273 48 * 1000,
274 72 * 1000
275 };
276
277 /* SMPTE 421M Table 9 */
278 static const guint framerates_d[] = {
279 0,
280 1000,
281 1001
282 };
283
284
285 static inline gboolean
decode_colskip(GstBitReader * br,guint8 * data,guint width,guint height,guint stride,guint invert)286 decode_colskip (GstBitReader * br, guint8 * data, guint width, guint height,
287 guint stride, guint invert)
288 {
289 guint x, y;
290 guint8 colskip, v;
291
292 GST_DEBUG ("Parsing colskip");
293
294 invert &= 1;
295 for (x = 0; x < width; x++) {
296 READ_UINT8 (br, colskip, 1);
297
298 if (data) {
299 if (colskip) {
300 for (y = 0; y < height; y++) {
301 READ_UINT8 (br, v, 1);
302 data[y * stride] = v ^ invert;
303 }
304 } else {
305 for (y = 0; y < height; y++)
306 data[y * stride] = invert;
307 }
308 data++;
309 } else if (colskip)
310 SKIP (br, height);
311 }
312
313 return TRUE;
314
315 failed:
316 GST_WARNING ("Failed to parse colskip");
317
318 return FALSE;
319 }
320
321 static inline gboolean
decode_rowskip(GstBitReader * br,guint8 * data,guint width,guint height,guint stride,guint invert)322 decode_rowskip (GstBitReader * br, guint8 * data, guint width, guint height,
323 guint stride, guint invert)
324 {
325 guint x, y;
326 guint8 rowskip, v;
327
328 GST_DEBUG ("Parsing rowskip");
329
330 invert &= 1;
331 for (y = 0; y < height; y++) {
332 READ_UINT8 (br, rowskip, 1);
333
334 if (data) {
335 if (!rowskip)
336 memset (data, invert, width);
337 else {
338 for (x = 0; x < width; x++) {
339 READ_UINT8 (br, v, 1);
340 data[x] = v ^ invert;
341 }
342 }
343 data += stride;
344 } else if (rowskip)
345 SKIP (br, width);
346 }
347
348 return TRUE;
349
350 failed:
351 GST_WARNING ("Failed to parse rowskip");
352
353 return FALSE;
354 }
355
356 static inline gint8
decode012(GstBitReader * br)357 decode012 (GstBitReader * br)
358 {
359 guint8 n;
360
361 READ_UINT8 (br, n, 1);
362
363 if (n == 0)
364 return 0;
365
366 READ_UINT8 (br, n, 1);
367
368 return n + 1;
369
370 failed:
371 GST_WARNING ("Could not decode 0 1 2 returning -1");
372
373 return -1;
374 }
375
376 static inline guint
calculate_nb_pan_scan_win(GstVC1AdvancedSeqHdr * advseqhdr,GstVC1PicAdvanced * pic)377 calculate_nb_pan_scan_win (GstVC1AdvancedSeqHdr * advseqhdr,
378 GstVC1PicAdvanced * pic)
379 {
380 if (advseqhdr->interlace && !advseqhdr->psf) {
381 if (advseqhdr->pulldown)
382 return pic->rff + 2;
383
384 return 2;
385
386 } else {
387 if (advseqhdr->pulldown)
388 return pic->rptfrm + 1;
389
390 return 1;
391 }
392 }
393
394 static gboolean
decode_refdist(GstBitReader * br,guint16 * value)395 decode_refdist (GstBitReader * br, guint16 * value)
396 {
397 guint16 tmp;
398 gint i = 2;
399
400 if (!gst_bit_reader_peek_bits_uint16 (br, &tmp, i))
401 goto failed;
402
403 if (tmp < 0x03) {
404 READ_UINT16 (br, *value, i);
405
406 return TRUE;
407 }
408
409 do {
410 i++;
411
412 if (!gst_bit_reader_peek_bits_uint16 (br, &tmp, i))
413 goto failed;
414
415 if (!(tmp >> i)) {
416 READ_UINT16 (br, *value, i);
417
418 return TRUE;
419 }
420 } while (i < 16);
421
422
423 failed:
424 {
425 GST_WARNING ("Could not decode end 0 returning");
426
427 return FALSE;
428 }
429 }
430
431 /*** bitplanes decoding ***/
432 static gboolean
bitplane_decoding(GstBitReader * br,guint8 * data,GstVC1SeqHdr * seqhdr,guint8 * is_raw)433 bitplane_decoding (GstBitReader * br, guint8 * data,
434 GstVC1SeqHdr * seqhdr, guint8 * is_raw)
435 {
436 const guint width = seqhdr->mb_width;
437 const guint height = seqhdr->mb_height;
438 const guint stride = seqhdr->mb_stride;
439 guint imode, invert, invert_mask;
440 guint x, y, v, o;
441 guint8 *pdata = data;
442
443 *is_raw = FALSE;
444
445 GET_BITS (br, 1, &invert);
446 invert_mask = -invert;
447
448 if (!decode_vlc (br, &imode, vc1_imode_vlc_table,
449 G_N_ELEMENTS (vc1_imode_vlc_table)))
450 goto failed;
451
452 switch (imode) {
453 case IMODE_RAW:
454
455 GST_DEBUG ("Parsing IMODE_RAW");
456
457 *is_raw = TRUE;
458 return TRUE;
459
460 case IMODE_DIFF2:
461 invert_mask = 0;
462 /* fall-through */
463 case IMODE_NORM2:
464 invert_mask &= 3;
465
466 GST_DEBUG ("Parsing IMODE_DIFF2 or IMODE_NORM2 biplane");
467
468 x = 0;
469 o = (height * width) & 1;
470 if (o) {
471 GET_BITS (br, 1, &v);
472 if (pdata) {
473 *pdata++ = (v ^ invert_mask) & 1;
474 if (++x == width) {
475 x = 0;
476 pdata += stride - width;
477 }
478 }
479 }
480
481 for (y = o; y < height * width; y += 2) {
482 if (!decode_vlc (br, &v, vc1_norm2_vlc_table,
483 G_N_ELEMENTS (vc1_norm2_vlc_table)))
484 goto failed;
485 if (pdata) {
486 v ^= invert_mask;
487 *pdata++ = v >> 1;
488 if (++x == width) {
489 x = 0;
490 pdata += stride - width;
491 }
492 *pdata++ = v & 1;
493 if (++x == width) {
494 x = 0;
495 pdata += stride - width;
496 }
497 }
498 }
499 break;
500
501 case IMODE_DIFF6:
502 invert_mask = 0;
503 /* fall-through */
504 case IMODE_NORM6:
505
506 GST_DEBUG ("Parsing IMODE_DIFF6 or IMODE_NORM6 biplane");
507
508 if (!(height % 3) && (width % 3)) { /* decode 2x3 "vertical" tiles */
509 for (y = 0; y < height; y += 3) {
510 for (x = width & 1; x < width; x += 2) {
511 if (!decode_vlc (br, &v, vc1_norm6_vlc_table,
512 G_N_ELEMENTS (vc1_norm6_vlc_table)))
513 goto failed;
514
515 if (pdata) {
516 v ^= invert_mask;
517 pdata[x + 0] = v & 1;
518 pdata[x + 1] = (v >> 1) & 1;
519 pdata[x + 0 + stride] = (v >> 2) & 1;
520 pdata[x + 1 + stride] = (v >> 3) & 1;
521 pdata[x + 0 + stride * 2] = (v >> 4) & 1;
522 pdata[x + 1 + stride * 2] = (v >> 5) & 1;
523 }
524 }
525 if (pdata)
526 pdata += 3 * stride;
527 }
528
529 x = width & 1;
530 y = 0;
531 } else { /* decode 3x2 "horizontal" tiles */
532
533 if (pdata)
534 pdata += (height & 1) * stride;
535 for (y = height & 1; y < height; y += 2) {
536 for (x = width % 3; x < width; x += 3) {
537 if (!decode_vlc (br, &v, vc1_norm6_vlc_table,
538 G_N_ELEMENTS (vc1_norm6_vlc_table)))
539 goto failed;
540
541 if (pdata) {
542 v ^= invert_mask;
543 pdata[x + 0] = v & 1;
544 pdata[x + 1] = (v >> 1) & 1;
545 pdata[x + 2] = (v >> 2) & 1;
546 pdata[x + 0 + stride] = (v >> 3) & 1;
547 pdata[x + 1 + stride] = (v >> 4) & 1;
548 pdata[x + 2 + stride] = (v >> 5) & 1;
549 }
550 }
551 if (pdata)
552 pdata += 2 * stride;
553 }
554
555 x = width % 3;
556 y = height & 1;
557 }
558
559 if (x) {
560 if (data)
561 pdata = data;
562 if (!decode_colskip (br, pdata, x, height, stride, invert_mask))
563 goto failed;
564 }
565
566 if (y) {
567 if (data)
568 pdata = data + x;
569 if (!decode_rowskip (br, pdata, width - x, y, stride, invert_mask))
570 goto failed;
571 }
572 break;
573 case IMODE_ROWSKIP:
574
575 GST_DEBUG ("Parsing IMODE_ROWSKIP biplane");
576
577 if (!decode_rowskip (br, data, width, height, stride, invert_mask))
578 goto failed;
579 break;
580 case IMODE_COLSKIP:
581
582 GST_DEBUG ("Parsing IMODE_COLSKIP biplane");
583
584 if (!decode_colskip (br, data, width, height, stride, invert_mask))
585 goto failed;
586 break;
587 }
588
589 if (!data)
590 return TRUE;
591
592 /* Applying diff operator */
593 if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) {
594 pdata = data;
595 pdata[0] ^= invert;
596
597 for (x = 1; x < width; x++)
598 pdata[x] ^= pdata[x - 1];
599
600 for (y = 1; y < height; y++) {
601 pdata[stride] ^= pdata[0];
602
603 for (x = 1; x < width; x++) {
604 if (pdata[stride + x - 1] != pdata[x])
605 pdata[stride + x] ^= invert;
606 else
607 pdata[stride + x] ^= pdata[stride + x - 1];
608 }
609 pdata += stride;
610 }
611 }
612
613 return TRUE;
614
615 failed:
616 GST_WARNING ("Failed to decode bitplane");
617
618 return FALSE;
619 }
620
621 static gboolean
parse_vopdquant(GstBitReader * br,GstVC1FrameHdr * framehdr,guint8 dquant)622 parse_vopdquant (GstBitReader * br, GstVC1FrameHdr * framehdr, guint8 dquant)
623 {
624 GstVC1VopDquant *vopdquant = &framehdr->vopdquant;
625
626 GST_DEBUG ("Parsing vopdquant");
627
628 vopdquant->dqbilevel = 0;
629
630 if (dquant == 2) {
631 vopdquant->dquantfrm = 0;
632
633 READ_UINT8 (br, vopdquant->pqdiff, 3);
634
635 if (vopdquant->pqdiff != 7)
636 vopdquant->altpquant = framehdr->pquant + vopdquant->pqdiff + 1;
637 else {
638 READ_UINT8 (br, vopdquant->abspq, 5);
639 vopdquant->altpquant = vopdquant->abspq;
640 }
641 } else {
642 READ_UINT8 (br, vopdquant->dquantfrm, 1);
643 GST_DEBUG (" %u DquantFrm %u", gst_bit_reader_get_pos (br),
644 vopdquant->dquantfrm);
645
646 if (vopdquant->dquantfrm) {
647 READ_UINT8 (br, vopdquant->dqprofile, 2);
648
649 switch (vopdquant->dqprofile) {
650 case GST_VC1_DQPROFILE_SINGLE_EDGE:
651 case GST_VC1_DQPROFILE_DOUBLE_EDGES:
652 READ_UINT8 (br, vopdquant->dqbedge, 2);
653 break;
654
655 case GST_VC1_DQPROFILE_ALL_MBS:
656 READ_UINT8 (br, vopdquant->dqbilevel, 1);
657 break;
658 }
659
660 if (vopdquant->dqbilevel
661 || vopdquant->dqprofile != GST_VC1_DQPROFILE_ALL_MBS) {
662 {
663 READ_UINT8 (br, vopdquant->pqdiff, 3);
664
665 if (vopdquant->pqdiff != 7)
666 vopdquant->altpquant = framehdr->pquant + vopdquant->pqdiff + 1;
667 else {
668 READ_UINT8 (br, vopdquant->abspq, 5);
669 vopdquant->altpquant = vopdquant->abspq;
670 }
671 }
672 }
673 }
674 }
675
676 return TRUE;
677
678 failed:
679 GST_WARNING ("Failed to parse vopdquant");
680
681 return FALSE;
682 }
683
684 static inline gint
scan_for_start_codes(const guint8 * data,guint size)685 scan_for_start_codes (const guint8 * data, guint size)
686 {
687 GstByteReader br;
688 gst_byte_reader_init (&br, data, size);
689
690 /* NALU not empty, so we can at least expect 1 (even 2) bytes following sc */
691 return gst_byte_reader_masked_scan_uint32 (&br, 0xffffff00, 0x00000100,
692 0, size);
693 }
694
695 static inline gint
get_unary(GstBitReader * br,gint stop,gint len)696 get_unary (GstBitReader * br, gint stop, gint len)
697 {
698 int i;
699 guint8 current = 0xff;
700
701 for (i = 0; i < len; i++) {
702 current = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
703 if (current == stop)
704 return i;
705 }
706
707 return i;
708 }
709
710 static inline void
calculate_framerate_bitrate(guint8 frmrtq_postproc,guint8 bitrtq_postproc,guint * framerate,guint * bitrate)711 calculate_framerate_bitrate (guint8 frmrtq_postproc, guint8 bitrtq_postproc,
712 guint * framerate, guint * bitrate)
713 {
714 if (frmrtq_postproc == 0 && bitrtq_postproc == 31) {
715 *framerate = 0;
716 *bitrate = 0;
717 } else if (frmrtq_postproc == 0 && bitrtq_postproc == 30) {
718 *framerate = 2;
719 *bitrate = 1952;
720 } else if (frmrtq_postproc == 1 && bitrtq_postproc == 31) {
721 *framerate = 6;
722 *bitrate = 2016;
723 } else {
724 if (frmrtq_postproc == 7) {
725 *framerate = 30;
726 } else {
727 *framerate = 2 + (frmrtq_postproc * 4);
728 }
729 if (bitrtq_postproc == 31) {
730 *bitrate = 2016;
731 } else {
732 *bitrate = 32 + (bitrtq_postproc * 64);
733 }
734 }
735 }
736
737 static inline void
calculate_mb_size(GstVC1SeqHdr * seqhdr,guint width,guint height)738 calculate_mb_size (GstVC1SeqHdr * seqhdr, guint width, guint height)
739 {
740 seqhdr->mb_width = (width + 15) >> 4;
741 seqhdr->mb_height = (height + 15) >> 4;
742 seqhdr->mb_stride = seqhdr->mb_width + 1;
743 }
744
745 static GstVC1ParserResult
parse_hrd_param_flag(GstBitReader * br,GstVC1HrdParam * hrd_param)746 parse_hrd_param_flag (GstBitReader * br, GstVC1HrdParam * hrd_param)
747 {
748 guint i;
749
750 GST_DEBUG ("Parsing Hrd param flag");
751
752
753 if (gst_bit_reader_get_remaining (br) < 13)
754 goto failed;
755
756 hrd_param->hrd_num_leaky_buckets =
757 gst_bit_reader_get_bits_uint8_unchecked (br, 5);
758 hrd_param->bit_rate_exponent =
759 gst_bit_reader_get_bits_uint8_unchecked (br, 4);
760 hrd_param->buffer_size_exponent =
761 gst_bit_reader_get_bits_uint8_unchecked (br, 4);
762
763 if (gst_bit_reader_get_remaining (br) <
764 (32 * hrd_param->hrd_num_leaky_buckets))
765 goto failed;
766
767 for (i = 0; i < hrd_param->hrd_num_leaky_buckets; i++) {
768 hrd_param->hrd_rate[i] = gst_bit_reader_get_bits_uint16_unchecked (br, 16);
769 hrd_param->hrd_buffer[i] =
770 gst_bit_reader_get_bits_uint16_unchecked (br, 16);
771 }
772
773 return GST_VC1_PARSER_OK;
774
775 failed:
776 GST_WARNING ("Failed to parse hrd param flag");
777
778 return GST_VC1_PARSER_ERROR;
779 }
780
781 static GstVC1ParserResult
parse_sequence_header_advanced(GstVC1SeqHdr * seqhdr,GstBitReader * br)782 parse_sequence_header_advanced (GstVC1SeqHdr * seqhdr, GstBitReader * br)
783 {
784 GstVC1AdvancedSeqHdr *advanced = &seqhdr->advanced;
785 guint8 tmp;
786
787 GST_DEBUG ("Parsing sequence header in advanced mode");
788
789 READ_UINT8 (br, tmp, 3);
790 advanced->level = tmp;
791 advanced->par_n = 0;
792 advanced->par_d = 0;
793 advanced->fps_n = 0;
794 advanced->fps_d = 0;
795
796 READ_UINT8 (br, advanced->colordiff_format, 2);
797 READ_UINT8 (br, advanced->frmrtq_postproc, 3);
798 READ_UINT8 (br, advanced->bitrtq_postproc, 5);
799
800 calculate_framerate_bitrate (advanced->frmrtq_postproc,
801 advanced->bitrtq_postproc, &advanced->framerate, &advanced->bitrate);
802
803 GST_DEBUG ("level %u, colordiff_format %u , frmrtq_postproc %u,"
804 " bitrtq_postproc %u", advanced->level, advanced->colordiff_format,
805 advanced->frmrtq_postproc, advanced->bitrtq_postproc);
806
807 if (gst_bit_reader_get_remaining (br) < 32)
808 goto failed;
809
810 advanced->postprocflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
811 advanced->max_coded_width = gst_bit_reader_get_bits_uint16_unchecked (br, 12);
812 advanced->max_coded_height =
813 gst_bit_reader_get_bits_uint16_unchecked (br, 12);
814 advanced->max_coded_width = (advanced->max_coded_width + 1) << 1;
815 advanced->max_coded_height = (advanced->max_coded_height + 1) << 1;
816 calculate_mb_size (seqhdr, advanced->max_coded_width,
817 advanced->max_coded_height);
818 advanced->pulldown = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
819 advanced->interlace = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
820 advanced->tfcntrflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
821 advanced->finterpflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
822
823 GST_DEBUG ("postprocflag %u, max_coded_width %u, max_coded_height %u,"
824 "pulldown %u, interlace %u, tfcntrflag %u, finterpflag %u",
825 advanced->postprocflag, advanced->max_coded_width,
826 advanced->max_coded_height, advanced->pulldown,
827 advanced->interlace, advanced->tfcntrflag, advanced->finterpflag);
828
829 /* Skipping reserved bit */
830 gst_bit_reader_skip_unchecked (br, 1);
831
832 advanced->psf = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
833 advanced->display_ext = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
834 if (advanced->display_ext) {
835 READ_UINT16 (br, advanced->disp_horiz_size, 14);
836 READ_UINT16 (br, advanced->disp_vert_size, 14);
837
838 advanced->disp_horiz_size++;
839 advanced->disp_vert_size++;
840
841 READ_UINT8 (br, advanced->aspect_ratio_flag, 1);
842
843 if (advanced->aspect_ratio_flag) {
844 READ_UINT8 (br, advanced->aspect_ratio, 4);
845
846 if (advanced->aspect_ratio == 15) {
847 /* Aspect Width (6.1.14.3.2) and Aspect Height (6.1.14.3.3)
848 * syntax elements hold a binary encoding of sizes ranging
849 * from 1 to 256 */
850 READ_UINT8 (br, advanced->aspect_horiz_size, 8);
851 READ_UINT8 (br, advanced->aspect_vert_size, 8);
852 advanced->par_n = 1 + advanced->aspect_horiz_size;
853 advanced->par_d = 1 + advanced->aspect_vert_size;
854 } else {
855 advanced->par_n = aspect_ratios[advanced->aspect_ratio].par_n;
856 advanced->par_d = aspect_ratios[advanced->aspect_ratio].par_d;
857 }
858 }
859 READ_UINT8 (br, advanced->framerate_flag, 1);
860 if (advanced->framerate_flag) {
861 READ_UINT8 (br, advanced->framerateind, 1);
862
863 if (!advanced->framerateind) {
864 READ_UINT8 (br, advanced->frameratenr, 8);
865 READ_UINT8 (br, advanced->frameratedr, 4);
866 } else {
867 READ_UINT16 (br, advanced->framerateexp, 16);
868 }
869 if (advanced->frameratenr > 0 &&
870 advanced->frameratenr < 8 &&
871 advanced->frameratedr > 0 && advanced->frameratedr < 3) {
872 advanced->fps_n = framerates_n[advanced->frameratenr];
873 advanced->fps_d = framerates_d[advanced->frameratedr];
874 } else {
875 advanced->fps_n = advanced->framerateexp + 1;
876 advanced->fps_d = 32;
877 }
878 }
879 READ_UINT8 (br, advanced->color_format_flag, 1);
880
881 if (advanced->color_format_flag) {
882 if (gst_bit_reader_get_remaining (br) < 24)
883 goto failed;
884
885 advanced->color_prim = gst_bit_reader_get_bits_uint8_unchecked (br, 8);
886 advanced->transfer_char = gst_bit_reader_get_bits_uint8_unchecked (br, 8);
887 advanced->matrix_coef = gst_bit_reader_get_bits_uint8_unchecked (br, 8);
888 }
889 }
890 READ_UINT8 (br, advanced->hrd_param_flag, 1);
891 if (advanced->hrd_param_flag)
892 return parse_hrd_param_flag (br, &advanced->hrd_param);
893
894 return GST_VC1_PARSER_OK;
895
896 failed:
897 GST_WARNING ("Failed to parse advanced headers");
898
899 return GST_VC1_PARSER_ERROR;
900 }
901
902 static GstVC1ParserResult
parse_frame_header_advanced(GstBitReader * br,GstVC1FrameHdr * framehdr,GstVC1SeqHdr * seqhdr,GstVC1BitPlanes * bitplanes,gboolean field2)903 parse_frame_header_advanced (GstBitReader * br, GstVC1FrameHdr * framehdr,
904 GstVC1SeqHdr * seqhdr, GstVC1BitPlanes * bitplanes, gboolean field2)
905 {
906 GstVC1AdvancedSeqHdr *advhdr = &seqhdr->advanced;
907 GstVC1PicAdvanced *pic = &framehdr->pic.advanced;
908 GstVC1EntryPointHdr *entrypthdr = &advhdr->entrypoint;
909 guint8 mvmodeidx;
910
911 GST_DEBUG ("Parsing Frame header advanced %u", advhdr->interlace);
912
913 /* Set the conveninence fields */
914 framehdr->profile = seqhdr->profile;
915 framehdr->dquant = entrypthdr->dquant;
916
917 if (advhdr->interlace) {
918 gint8 fcm = decode012 (br);
919
920 if (fcm < 0)
921 goto failed;
922
923 pic->fcm = (guint8) fcm;
924 } else
925 pic->fcm = GST_VC1_FRAME_PROGRESSIVE;
926
927 if (pic->fcm == GST_VC1_FIELD_INTERLACE) {
928 READ_UINT8 (br, pic->fptype, 3);
929 if (field2) {
930 switch (pic->fptype) {
931 case 0x00:
932 case 0x02:
933 framehdr->ptype = GST_VC1_PICTURE_TYPE_I;
934 break;
935 case 0x01:
936 case 0x03:
937 framehdr->ptype = GST_VC1_PICTURE_TYPE_P;
938 break;
939 case 0x04:
940 case 0x06:
941 framehdr->ptype = GST_VC1_PICTURE_TYPE_B;
942 break;
943 case 0x05:
944 case 0x07:
945 framehdr->ptype = GST_VC1_PICTURE_TYPE_BI;
946 break;
947 }
948 } else {
949 switch (pic->fptype) {
950 case 0x00:
951 case 0x01:
952 framehdr->ptype = GST_VC1_PICTURE_TYPE_I;
953 break;
954 case 0x02:
955 case 0x03:
956 framehdr->ptype = GST_VC1_PICTURE_TYPE_P;
957 break;
958 case 0x04:
959 case 0x05:
960 framehdr->ptype = GST_VC1_PICTURE_TYPE_B;
961 break;
962 case 0x06:
963 case 0x07:
964 framehdr->ptype = GST_VC1_PICTURE_TYPE_BI;
965 break;
966 }
967 }
968 } else
969 framehdr->ptype = (guint8) get_unary (br, 0, 4);
970
971 if (advhdr->tfcntrflag) {
972 READ_UINT8 (br, pic->tfcntr, 8);
973 GST_DEBUG ("tfcntr %u", pic->tfcntr);
974 }
975
976 if (advhdr->pulldown) {
977 if (!advhdr->interlace || advhdr->psf) {
978
979 READ_UINT8 (br, pic->rptfrm, 2);
980 GST_DEBUG ("rptfrm %u", pic->rptfrm);
981
982 } else {
983
984 READ_UINT8 (br, pic->tff, 1);
985 READ_UINT8 (br, pic->rff, 1);
986 GST_DEBUG ("tff %u, rff %u", pic->tff, pic->rff);
987 }
988 }
989
990 if (entrypthdr->panscan_flag) {
991 READ_UINT8 (br, pic->ps_present, 1);
992
993 if (pic->ps_present) {
994 guint i, nb_pan_scan_win = calculate_nb_pan_scan_win (advhdr, pic);
995
996 if (gst_bit_reader_get_remaining (br) < 64 * nb_pan_scan_win)
997 goto failed;
998
999 for (i = 0; i < nb_pan_scan_win; i++) {
1000 pic->ps_hoffset = gst_bit_reader_get_bits_uint32_unchecked (br, 18);
1001 pic->ps_voffset = gst_bit_reader_get_bits_uint32_unchecked (br, 18);
1002 pic->ps_width = gst_bit_reader_get_bits_uint16_unchecked (br, 14);
1003 pic->ps_height = gst_bit_reader_get_bits_uint16_unchecked (br, 14);
1004 }
1005 }
1006 }
1007
1008 if (framehdr->ptype == GST_VC1_PICTURE_TYPE_SKIPPED)
1009 return GST_VC1_PARSER_OK;
1010
1011 READ_UINT8 (br, pic->rndctrl, 1);
1012
1013 if (advhdr->interlace) {
1014 READ_UINT8 (br, pic->uvsamp, 1);
1015 GST_DEBUG ("uvsamp %u", pic->uvsamp);
1016 if (pic->fcm == GST_VC1_FIELD_INTERLACE && entrypthdr->refdist_flag &&
1017 pic->fptype < 4)
1018 decode_refdist (br, &pic->refdist);
1019 else
1020 pic->refdist = 0;
1021 }
1022
1023 if (advhdr->finterpflag) {
1024 READ_UINT8 (br, framehdr->interpfrm, 1);
1025 GST_DEBUG ("interpfrm %u", framehdr->interpfrm);
1026 }
1027
1028 if ((pic->fcm != GST_VC1_FIELD_INTERLACE &&
1029 framehdr->ptype == GST_VC1_PICTURE_TYPE_B) ||
1030 (pic->fcm == GST_VC1_FIELD_INTERLACE && (pic->fptype > 4))) {
1031
1032 guint bfraction;
1033
1034 if (!decode_vlc (br, &bfraction, vc1_bfraction_vlc_table,
1035 G_N_ELEMENTS (vc1_bfraction_vlc_table)))
1036 goto failed;
1037
1038 pic->bfraction = bfraction;
1039 GST_DEBUG ("bfraction %u", pic->bfraction);
1040
1041 if (pic->bfraction == GST_VC1_BFRACTION_PTYPE_BI) {
1042 framehdr->ptype = GST_VC1_PICTURE_TYPE_BI;
1043 }
1044
1045 }
1046
1047 READ_UINT8 (br, framehdr->pqindex, 5);
1048 if (!framehdr->pqindex)
1049 goto failed;
1050
1051 /* compute pquant */
1052 if (entrypthdr->quantizer == GST_VC1_QUANTIZER_IMPLICITLY)
1053 framehdr->pquant = vc1_pquant_table[0][framehdr->pqindex];
1054 else
1055 framehdr->pquant = vc1_pquant_table[1][framehdr->pqindex];
1056
1057 framehdr->pquantizer = 1;
1058 if (entrypthdr->quantizer == GST_VC1_QUANTIZER_IMPLICITLY)
1059 framehdr->pquantizer = framehdr->pqindex < 9;
1060 if (entrypthdr->quantizer == GST_VC1_QUANTIZER_NON_UNIFORM)
1061 framehdr->pquantizer = 0;
1062
1063 if (framehdr->pqindex <= 8)
1064 READ_UINT8 (br, framehdr->halfqp, 1);
1065 else
1066 framehdr->halfqp = 0;
1067
1068 if (entrypthdr->quantizer == GST_VC1_QUANTIZER_EXPLICITLY) {
1069 READ_UINT8 (br, framehdr->pquantizer, 1);
1070 }
1071
1072 if (advhdr->postprocflag)
1073 READ_UINT8 (br, pic->postproc, 2);
1074
1075 GST_DEBUG ("Parsing %u picture, pqindex %u, pquant %u pquantizer %u"
1076 "halfqp %u", framehdr->ptype, framehdr->pqindex, framehdr->pquant,
1077 framehdr->pquantizer, framehdr->halfqp);
1078
1079 switch (framehdr->ptype) {
1080 case GST_VC1_PICTURE_TYPE_I:
1081 case GST_VC1_PICTURE_TYPE_BI:
1082 if (pic->fcm == GST_VC1_FRAME_INTERLACE) {
1083 if (!bitplane_decoding (br, bitplanes ? bitplanes->fieldtx : NULL,
1084 seqhdr, &pic->fieldtx))
1085 goto failed;
1086 }
1087
1088 if (!bitplane_decoding (br, bitplanes ? bitplanes->acpred : NULL,
1089 seqhdr, &pic->acpred))
1090 goto failed;
1091
1092 if (entrypthdr->overlap && framehdr->pquant <= 8) {
1093 pic->condover = decode012 (br);
1094
1095 if (pic->condover == (guint8) - 1)
1096 goto failed;
1097
1098 else if (pic->condover == GST_VC1_CONDOVER_SELECT) {
1099 if (!bitplane_decoding (br, bitplanes ? bitplanes->overflags : NULL,
1100 seqhdr, &pic->overflags))
1101 goto failed;
1102
1103 GST_DEBUG ("overflags %u", pic->overflags);
1104 }
1105 }
1106
1107 framehdr->transacfrm = get_unary (br, 0, 2);
1108 pic->transacfrm2 = get_unary (br, 0, 2);
1109 READ_UINT8 (br, framehdr->transdctab, 1);
1110
1111 if (framehdr->dquant)
1112 parse_vopdquant (br, framehdr, framehdr->dquant);
1113
1114 GST_DEBUG
1115 ("acpred %u, condover %u, transacfrm %u, transacfrm2 %u, transdctab %u",
1116 pic->acpred, pic->condover, framehdr->transacfrm, pic->transacfrm2,
1117 framehdr->transdctab);
1118 break;
1119
1120 case GST_VC1_PICTURE_TYPE_B:
1121 if (entrypthdr->extended_mv)
1122 pic->mvrange = get_unary (br, 0, 3);
1123 else
1124 pic->mvrange = 0;
1125
1126 if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) {
1127 if (entrypthdr->extended_dmv)
1128 pic->dmvrange = get_unary (br, 0, 3);
1129 }
1130
1131 if (pic->fcm == GST_VC1_FRAME_INTERLACE)
1132 READ_UINT8 (br, pic->intcomp, 1);
1133 else
1134 READ_UINT8 (br, pic->mvmode, 1);
1135
1136 if (pic->fcm == GST_VC1_FIELD_INTERLACE) {
1137
1138 if (!bitplane_decoding (br, bitplanes ? bitplanes->forwardmb : NULL,
1139 seqhdr, &pic->forwardmb))
1140 goto failed;
1141
1142 } else {
1143 if (!bitplane_decoding (br, bitplanes ? bitplanes->directmb : NULL,
1144 seqhdr, &pic->directmb))
1145 goto failed;
1146
1147 if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL,
1148 seqhdr, &pic->skipmb))
1149 goto failed;
1150 }
1151
1152 if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) {
1153 if (gst_bit_reader_get_remaining (br) < 7)
1154 goto failed;
1155
1156 pic->mbmodetab = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1157 pic->imvtab = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1158 pic->icbptab = gst_bit_reader_get_bits_uint8_unchecked (br, 3);
1159
1160 if (pic->fcm == GST_VC1_FRAME_INTERLACE)
1161 READ_UINT8 (br, pic->mvbptab2, 2);
1162
1163 if (pic->fcm == GST_VC1_FRAME_INTERLACE ||
1164 (pic->fcm == GST_VC1_FIELD_INTERLACE
1165 && pic->mvmode == GST_VC1_MVMODE_MIXED_MV))
1166 READ_UINT8 (br, pic->mvbptab4, 2);
1167
1168 } else {
1169 READ_UINT8 (br, pic->mvtab, 2);
1170 READ_UINT8 (br, pic->cbptab, 2);
1171 }
1172
1173 if (framehdr->dquant) {
1174 parse_vopdquant (br, framehdr, framehdr->dquant);
1175 }
1176
1177 if (entrypthdr->vstransform) {
1178 READ_UINT8 (br, pic->ttmbf, 1);
1179
1180 if (pic->ttmbf) {
1181 READ_UINT8 (br, pic->ttfrm, 2);
1182 }
1183 }
1184
1185 framehdr->transacfrm = get_unary (br, 0, 2);
1186 READ_UINT8 (br, framehdr->transdctab, 1);
1187
1188 GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u,"
1189 "cbptab %u directmb %u skipmb %u", framehdr->transacfrm,
1190 framehdr->transdctab, pic->mvmode, pic->mvtab, pic->cbptab,
1191 pic->directmb, pic->skipmb);
1192
1193 break;
1194 case GST_VC1_PICTURE_TYPE_P:
1195 if (pic->fcm == GST_VC1_FIELD_INTERLACE) {
1196 READ_UINT8 (br, pic->numref, 1);
1197
1198 if (pic->numref)
1199 READ_UINT8 (br, pic->reffield, 1);
1200 }
1201
1202 if (entrypthdr->extended_mv)
1203 pic->mvrange = get_unary (br, 0, 3);
1204 else
1205 pic->mvrange = 0;
1206
1207 if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) {
1208 if (entrypthdr->extended_dmv)
1209 pic->dmvrange = get_unary (br, 0, 3);
1210 }
1211
1212 if (pic->fcm == GST_VC1_FRAME_INTERLACE) {
1213 READ_UINT8 (br, pic->mvswitch4, 1);
1214 READ_UINT8 (br, pic->intcomp, 1);
1215
1216 if (pic->intcomp) {
1217 READ_UINT8 (br, pic->lumscale, 6);
1218 READ_UINT8 (br, pic->lumshift, 6);
1219 }
1220 } else {
1221
1222 mvmodeidx = framehdr->pquant > 12;
1223 pic->mvmode = vc1_mvmode_table[mvmodeidx][get_unary (br, 1, 4)];
1224
1225 if (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP) {
1226 pic->mvmode2 = vc1_mvmode2_table[mvmodeidx][get_unary (br, 1, 3)];
1227
1228 if (pic->fcm == GST_VC1_FIELD_INTERLACE)
1229 pic->intcompfield = decode012 (br);
1230
1231 READ_UINT8 (br, pic->lumscale, 6);
1232 READ_UINT8 (br, pic->lumshift, 6);
1233 GST_DEBUG ("lumscale %u lumshift %u", pic->lumscale, pic->lumshift);
1234
1235 if (pic->fcm == GST_VC1_FIELD_INTERLACE && pic->intcompfield) {
1236 READ_UINT8 (br, pic->lumscale2, 6);
1237 READ_UINT8 (br, pic->lumshift2, 6);
1238 }
1239 }
1240
1241 if (pic->fcm == GST_VC1_FRAME_PROGRESSIVE) {
1242 if (pic->mvmode == GST_VC1_MVMODE_MIXED_MV ||
1243 (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP &&
1244 pic->mvmode2 == GST_VC1_MVMODE_MIXED_MV)) {
1245
1246 if (!bitplane_decoding (br, bitplanes ? bitplanes->mvtypemb : NULL,
1247 seqhdr, &pic->mvtypemb))
1248 goto failed;
1249
1250 GST_DEBUG ("mvtypemb %u", pic->mvtypemb);
1251 }
1252 }
1253 }
1254
1255 if (pic->fcm != GST_VC1_FIELD_INTERLACE) {
1256 if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL,
1257 seqhdr, &pic->skipmb))
1258 goto failed;
1259 }
1260
1261 if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) {
1262 if (gst_bit_reader_get_remaining (br) < 7)
1263 goto failed;
1264
1265 pic->mbmodetab = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1266 pic->imvtab = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1267 pic->icbptab = gst_bit_reader_get_bits_uint8_unchecked (br, 3);
1268
1269 if (pic->fcm != GST_VC1_FIELD_INTERLACE) {
1270 READ_UINT8 (br, pic->mvbptab2, 2);
1271
1272 if (pic->mvswitch4)
1273 READ_UINT8 (br, pic->mvbptab4, 2);
1274
1275 } else if (pic->mvmode == GST_VC1_MVMODE_MIXED_MV)
1276 READ_UINT8 (br, pic->mvbptab4, 2);
1277
1278 } else {
1279 if (gst_bit_reader_get_remaining (br) < 4)
1280 goto failed;
1281 pic->mvtab = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1282 pic->cbptab = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1283 }
1284
1285 if (framehdr->dquant) {
1286 parse_vopdquant (br, framehdr, framehdr->dquant);
1287 }
1288
1289 if (entrypthdr->vstransform) {
1290 READ_UINT8 (br, pic->ttmbf, 1);
1291
1292 if (pic->ttmbf) {
1293 READ_UINT8 (br, pic->ttfrm, 2);
1294 }
1295 }
1296
1297 framehdr->transacfrm = get_unary (br, 0, 2);
1298 READ_UINT8 (br, framehdr->transdctab, 1);
1299
1300 GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u,"
1301 "cbptab %u skipmb %u", framehdr->transacfrm, framehdr->transdctab,
1302 pic->mvmode, pic->mvtab, pic->cbptab, pic->skipmb);
1303
1304 break;
1305
1306 default:
1307 goto failed;
1308 break;
1309 }
1310
1311 return GST_VC1_PARSER_OK;
1312
1313 failed:
1314 GST_WARNING ("Failed to parse frame header");
1315
1316 return GST_VC1_PARSER_ERROR;
1317 }
1318
1319 static GstVC1ParserResult
parse_frame_header(GstBitReader * br,GstVC1FrameHdr * framehdr,GstVC1SeqHdr * seqhdr,GstVC1BitPlanes * bitplanes)1320 parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr,
1321 GstVC1SeqHdr * seqhdr, GstVC1BitPlanes * bitplanes)
1322 {
1323 guint8 mvmodeidx, tmp;
1324 GstVC1PicSimpleMain *pic = &framehdr->pic.simple;
1325 GstVC1SeqStructC *structc = &seqhdr->struct_c;
1326
1327 GST_DEBUG ("Parsing frame header in simple or main mode");
1328
1329 /* Set the conveninence fields */
1330 framehdr->profile = seqhdr->profile;
1331 framehdr->dquant = structc->dquant;
1332
1333 framehdr->interpfrm = 0;
1334 if (structc->finterpflag)
1335 READ_UINT8 (br, framehdr->interpfrm, 1);
1336
1337 READ_UINT8 (br, pic->frmcnt, 2);
1338
1339 pic->rangeredfrm = 0;
1340 if (structc->rangered) {
1341 READ_UINT8 (br, pic->rangeredfrm, 1);
1342 }
1343
1344 /* Figuring out the picture type */
1345 READ_UINT8 (br, tmp, 1);
1346 framehdr->ptype = tmp;
1347
1348 if (structc->maxbframes) {
1349 if (!framehdr->ptype) {
1350 READ_UINT8 (br, tmp, 1);
1351
1352 if (tmp)
1353 framehdr->ptype = GST_VC1_PICTURE_TYPE_I;
1354 else
1355 framehdr->ptype = GST_VC1_PICTURE_TYPE_B;
1356
1357 } else
1358 framehdr->ptype = GST_VC1_PICTURE_TYPE_P;
1359
1360 } else {
1361 if (framehdr->ptype)
1362 framehdr->ptype = GST_VC1_PICTURE_TYPE_P;
1363 else
1364 framehdr->ptype = GST_VC1_PICTURE_TYPE_I;
1365 }
1366
1367
1368 if (framehdr->ptype == GST_VC1_PICTURE_TYPE_B) {
1369 guint bfraction;
1370 if (!decode_vlc (br, &bfraction, vc1_bfraction_vlc_table,
1371 G_N_ELEMENTS (vc1_bfraction_vlc_table)))
1372 goto failed;
1373
1374 pic->bfraction = bfraction;
1375 GST_DEBUG ("bfraction %d", pic->bfraction);
1376
1377 if (pic->bfraction == GST_VC1_BFRACTION_PTYPE_BI) {
1378 framehdr->ptype = GST_VC1_PICTURE_TYPE_BI;
1379 }
1380 }
1381
1382 if (framehdr->ptype == GST_VC1_PICTURE_TYPE_I ||
1383 framehdr->ptype == GST_VC1_PICTURE_TYPE_BI)
1384 READ_UINT8 (br, pic->bf, 7);
1385
1386 READ_UINT8 (br, framehdr->pqindex, 5);
1387 if (!framehdr->pqindex)
1388 return GST_VC1_PARSER_ERROR;
1389
1390 GST_DEBUG ("pqindex %u", framehdr->pqindex);
1391
1392 /* compute pquant */
1393 if (structc->quantizer == GST_VC1_QUANTIZER_IMPLICITLY)
1394 framehdr->pquant = vc1_pquant_table[0][framehdr->pqindex];
1395 else
1396 framehdr->pquant = vc1_pquant_table[1][framehdr->pqindex];
1397
1398 GST_DEBUG ("pquant %u", framehdr->pquant);
1399
1400 if (framehdr->pqindex <= 8)
1401 READ_UINT8 (br, framehdr->halfqp, 1);
1402 else
1403 framehdr->halfqp = 0;
1404
1405 /* Set pquantizer */
1406 framehdr->pquantizer = 1;
1407 if (structc->quantizer == GST_VC1_QUANTIZER_IMPLICITLY)
1408 framehdr->pquantizer = framehdr->pqindex < 9;
1409 else if (structc->quantizer == GST_VC1_QUANTIZER_NON_UNIFORM)
1410 framehdr->pquantizer = 0;
1411
1412 if (structc->quantizer == GST_VC1_QUANTIZER_EXPLICITLY)
1413 READ_UINT8 (br, framehdr->pquantizer, 1);
1414
1415 if (structc->extended_mv == 1) {
1416 pic->mvrange = get_unary (br, 0, 3);
1417 GST_DEBUG ("mvrange %u", pic->mvrange);
1418 }
1419
1420 if (structc->multires && (framehdr->ptype == GST_VC1_PICTURE_TYPE_P ||
1421 framehdr->ptype == GST_VC1_PICTURE_TYPE_I)) {
1422 READ_UINT8 (br, pic->respic, 2);
1423 GST_DEBUG ("Respic %u", pic->respic);
1424 }
1425
1426 GST_DEBUG ("Parsing %u Frame, pquantizer %u, halfqp %u, rangeredfrm %u, "
1427 "interpfrm %u", framehdr->ptype, framehdr->pquantizer, framehdr->halfqp,
1428 pic->rangeredfrm, framehdr->interpfrm);
1429
1430 switch (framehdr->ptype) {
1431 case GST_VC1_PICTURE_TYPE_I:
1432 case GST_VC1_PICTURE_TYPE_BI:
1433 framehdr->transacfrm = get_unary (br, 0, 2);
1434 pic->transacfrm2 = get_unary (br, 0, 2);
1435 READ_UINT8 (br, framehdr->transdctab, 1);
1436
1437 GST_DEBUG ("transacfrm %u, transacfrm2 %u, transdctab %u",
1438 framehdr->transacfrm, pic->transacfrm2, framehdr->transdctab);
1439 break;
1440
1441 case GST_VC1_PICTURE_TYPE_P:
1442 mvmodeidx = framehdr->pquant > 12;
1443 pic->mvmode = vc1_mvmode_table[mvmodeidx][get_unary (br, 1, 4)];
1444
1445 if (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP) {
1446 pic->mvmode2 = vc1_mvmode2_table[mvmodeidx][get_unary (br, 1, 3)];
1447 READ_UINT8 (br, pic->lumscale, 6);
1448 READ_UINT8 (br, pic->lumshift, 6);
1449 GST_DEBUG ("lumscale %u lumshift %u", pic->lumscale, pic->lumshift);
1450 }
1451
1452 if (pic->mvmode == GST_VC1_MVMODE_MIXED_MV ||
1453 (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP &&
1454 pic->mvmode2 == GST_VC1_MVMODE_MIXED_MV)) {
1455 if (!bitplane_decoding (br, bitplanes ? bitplanes->mvtypemb : NULL,
1456 seqhdr, &pic->mvtypemb))
1457 goto failed;
1458 GST_DEBUG ("mvtypemb %u", pic->mvtypemb);
1459 }
1460 if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL,
1461 seqhdr, &pic->skipmb))
1462 goto failed;
1463
1464 READ_UINT8 (br, pic->mvtab, 2);
1465 READ_UINT8 (br, pic->cbptab, 2);
1466
1467 if (framehdr->dquant) {
1468 parse_vopdquant (br, framehdr, framehdr->dquant);
1469 }
1470
1471 if (structc->vstransform) {
1472 READ_UINT8 (br, pic->ttmbf, 1);
1473 GST_DEBUG ("ttmbf %u", pic->ttmbf);
1474
1475 if (pic->ttmbf) {
1476 READ_UINT8 (br, pic->ttfrm, 2);
1477 GST_DEBUG ("ttfrm %u", pic->ttfrm);
1478 }
1479 }
1480
1481 framehdr->transacfrm = get_unary (br, 0, 2);
1482 READ_UINT8 (br, framehdr->transdctab, 1);
1483
1484 GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u,"
1485 "cbptab %u skipmb %u", framehdr->transacfrm, framehdr->transdctab,
1486 pic->mvmode, pic->mvtab, pic->cbptab, pic->skipmb);
1487 break;
1488
1489 case GST_VC1_PICTURE_TYPE_B:
1490 READ_UINT8 (br, pic->mvmode, 1);
1491 if (!bitplane_decoding (br, bitplanes ? bitplanes->directmb : NULL,
1492 seqhdr, &pic->directmb))
1493 goto failed;
1494
1495 if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL,
1496 seqhdr, &pic->skipmb))
1497 goto failed;
1498
1499 READ_UINT8 (br, pic->mvtab, 2);
1500 READ_UINT8 (br, pic->cbptab, 2);
1501
1502 if (framehdr->dquant)
1503 parse_vopdquant (br, framehdr, framehdr->dquant);
1504
1505 if (structc->vstransform) {
1506 READ_UINT8 (br, pic->ttmbf, 1);
1507
1508 if (pic->ttmbf) {
1509 READ_UINT8 (br, pic->ttfrm, 2);
1510 }
1511 }
1512
1513 framehdr->transacfrm = get_unary (br, 0, 2);
1514 READ_UINT8 (br, framehdr->transdctab, 1);
1515
1516 GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u,"
1517 "cbptab %u directmb %u skipmb %u", framehdr->transacfrm,
1518 framehdr->transdctab, pic->mvmode, pic->mvtab, pic->cbptab,
1519 pic->directmb, pic->skipmb);
1520
1521 break;
1522
1523 default:
1524 goto failed;
1525 break;
1526 }
1527
1528 return GST_VC1_PARSER_OK;
1529
1530 failed:
1531 GST_WARNING ("Failed to parse Simple picture header");
1532
1533 return GST_VC1_PARSER_ERROR;
1534 }
1535
1536 static GstVC1ParserResult
parse_sequence_header_struct_a(GstBitReader * br,GstVC1SeqStructA * structa)1537 parse_sequence_header_struct_a (GstBitReader * br, GstVC1SeqStructA * structa)
1538 {
1539 if (gst_bit_reader_get_remaining (br) < 64) {
1540 GST_WARNING ("Failed to parse struct A");
1541
1542 return GST_VC1_PARSER_ERROR;
1543 }
1544
1545 structa->vert_size = gst_bit_reader_get_bits_uint32_unchecked (br, 32);
1546 structa->horiz_size = gst_bit_reader_get_bits_uint32_unchecked (br, 32);
1547
1548 return GST_VC1_PARSER_OK;
1549 }
1550
1551 static GstVC1ParserResult
parse_sequence_header_struct_b(GstBitReader * br,GstVC1SeqStructB * structb)1552 parse_sequence_header_struct_b (GstBitReader * br, GstVC1SeqStructB * structb)
1553 {
1554 if (gst_bit_reader_get_remaining (br) < 96) {
1555 GST_WARNING ("Failed to parse sequence header");
1556
1557 return GST_VC1_PARSER_ERROR;
1558 }
1559
1560 structb->level = gst_bit_reader_get_bits_uint8_unchecked (br, 3);
1561 structb->cbr = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1562
1563 /* res4 */
1564 gst_bit_reader_skip_unchecked (br, 4);
1565
1566 structb->hrd_buffer = gst_bit_reader_get_bits_uint32_unchecked (br, 24);
1567 structb->hrd_rate = gst_bit_reader_get_bits_uint32_unchecked (br, 32);
1568 structb->framerate = gst_bit_reader_get_bits_uint32_unchecked (br, 32);
1569
1570 return GST_VC1_PARSER_OK;
1571 }
1572
1573 static GstVC1ParserResult
parse_sequence_header_struct_c(GstBitReader * br,GstVC1SeqStructC * structc)1574 parse_sequence_header_struct_c (GstBitReader * br, GstVC1SeqStructC * structc)
1575 {
1576 guint8 old_interlaced_mode, tmp;
1577
1578 READ_UINT8 (br, tmp, 2);
1579 structc->profile = tmp;
1580
1581 if (structc->profile == GST_VC1_PROFILE_ADVANCED)
1582 return GST_VC1_PARSER_OK;
1583
1584 GST_DEBUG ("Parsing sequence header in simple or main mode");
1585
1586 if (gst_bit_reader_get_remaining (br) < 29)
1587 goto failed;
1588
1589 /* Reserved bits */
1590 old_interlaced_mode = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1591 if (old_interlaced_mode)
1592 GST_WARNING ("Old interlaced mode used");
1593
1594 structc->wmvp = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1595 if (structc->wmvp)
1596 GST_DEBUG ("WMVP mode");
1597
1598 structc->frmrtq_postproc = gst_bit_reader_get_bits_uint8_unchecked (br, 3);
1599 structc->bitrtq_postproc = gst_bit_reader_get_bits_uint8_unchecked (br, 5);
1600 structc->loop_filter = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1601
1602 calculate_framerate_bitrate (structc->frmrtq_postproc,
1603 structc->bitrtq_postproc, &structc->framerate, &structc->bitrate);
1604
1605 /* Skipping reserved3 bit */
1606 gst_bit_reader_skip_unchecked (br, 1);
1607
1608 structc->multires = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1609
1610 /* Skipping reserved4 bit */
1611 gst_bit_reader_skip_unchecked (br, 1);
1612
1613 structc->fastuvmc = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1614 structc->extended_mv = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1615 structc->dquant = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1616 structc->vstransform = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1617
1618 /* Skipping reserved5 bit */
1619 gst_bit_reader_skip_unchecked (br, 1);
1620
1621 structc->overlap = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1622 structc->syncmarker = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1623 structc->rangered = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1624 structc->maxbframes = gst_bit_reader_get_bits_uint8_unchecked (br, 3);
1625 structc->quantizer = gst_bit_reader_get_bits_uint8_unchecked (br, 2);
1626 structc->finterpflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1627
1628 GST_DEBUG ("frmrtq_postproc %u, bitrtq_postproc %u, loop_filter %u, "
1629 "multires %u, fastuvmc %u, extended_mv %u, dquant %u, vstransform %u, "
1630 "overlap %u, syncmarker %u, rangered %u, maxbframes %u, quantizer %u, "
1631 "finterpflag %u", structc->frmrtq_postproc, structc->bitrtq_postproc,
1632 structc->loop_filter, structc->multires, structc->fastuvmc,
1633 structc->extended_mv, structc->dquant, structc->vstransform,
1634 structc->overlap, structc->syncmarker, structc->rangered,
1635 structc->maxbframes, structc->quantizer, structc->finterpflag);
1636
1637 if (structc->wmvp) {
1638 if (gst_bit_reader_get_remaining (br) < 29)
1639 goto failed;
1640
1641 structc->coded_width = gst_bit_reader_get_bits_uint16_unchecked (br, 11);
1642 structc->coded_height = gst_bit_reader_get_bits_uint16_unchecked (br, 11);
1643 structc->framerate = gst_bit_reader_get_bits_uint8_unchecked (br, 5);
1644 gst_bit_reader_skip_unchecked (br, 1);
1645 structc->slice_code = gst_bit_reader_get_bits_uint8_unchecked (br, 1);
1646
1647 GST_DEBUG ("coded_width %u, coded_height %u, framerate %u slice_code %u",
1648 structc->coded_width, structc->coded_height, structc->framerate,
1649 structc->slice_code);
1650 }
1651
1652 return GST_VC1_PARSER_OK;
1653
1654 failed:
1655 GST_WARNING ("Failed to struct C");
1656
1657 return GST_VC1_PARSER_ERROR;
1658 }
1659
1660 /**** API ****/
1661 /**
1662 * gst_vc1_identify_next_bdu:
1663 * @data: The data to parse
1664 * @size: the size of @data
1665 * @bdu: (out): The #GstVC1BDU where to store parsed bdu headers
1666 *
1667 * Parses @data and fills @bdu fields
1668 *
1669 * Returns: a #GstVC1ParserResult
1670 */
1671 GstVC1ParserResult
gst_vc1_identify_next_bdu(const guint8 * data,gsize size,GstVC1BDU * bdu)1672 gst_vc1_identify_next_bdu (const guint8 * data, gsize size, GstVC1BDU * bdu)
1673 {
1674 gint off1, off2;
1675
1676 g_return_val_if_fail (bdu != NULL, GST_VC1_PARSER_ERROR);
1677
1678 if (size < 4) {
1679 GST_DEBUG ("Can't parse, buffer has too small size %" G_GSIZE_FORMAT, size);
1680 return GST_VC1_PARSER_ERROR;
1681 }
1682
1683 off1 = scan_for_start_codes (data, size);
1684
1685 if (off1 < 0) {
1686 GST_DEBUG ("No start code prefix in this buffer");
1687 return GST_VC1_PARSER_NO_BDU;
1688 }
1689
1690 bdu->sc_offset = off1;
1691
1692 bdu->offset = off1 + 4;
1693 bdu->data = (guint8 *) data;
1694 bdu->type = (GstVC1StartCode) (data[bdu->offset - 1]);
1695
1696 if (bdu->type == GST_VC1_END_OF_SEQ) {
1697 GST_DEBUG ("End-of-Seq BDU found");
1698 bdu->size = 0;
1699 return GST_VC1_PARSER_OK;
1700 }
1701
1702 off2 = scan_for_start_codes (data + bdu->offset, size - bdu->offset);
1703 if (off2 < 0) {
1704 GST_DEBUG ("Bdu start %d, No end found", bdu->offset);
1705
1706 return GST_VC1_PARSER_NO_BDU_END;
1707 }
1708
1709 if (off2 > 0 && data[bdu->offset + off2 - 1] == 00)
1710 off2--;
1711
1712 bdu->size = off2;
1713
1714 GST_DEBUG ("Complete bdu found. Off: %d, Size: %d", bdu->offset, bdu->size);
1715 return GST_VC1_PARSER_OK;
1716 }
1717
1718 /**
1719 * gst_vc1_parse_sequence_layer:
1720 * @data: The data to parse
1721 * @size: the size of @data
1722 * @seqlayer: The #GstVC1SeqLayer to set.
1723 *
1724 * Parses @data, and fills @seqlayer fields.
1725 *
1726 * Returns: a #GstVC1ParserResult
1727 */
1728 GstVC1ParserResult
gst_vc1_parse_sequence_layer(const guint8 * data,gsize size,GstVC1SeqLayer * seqlayer)1729 gst_vc1_parse_sequence_layer (const guint8 * data, gsize size,
1730 GstVC1SeqLayer * seqlayer)
1731 {
1732 guint32 tmp;
1733 guint8 tmp8;
1734 guint8 structA[8] = { 0, };
1735 guint8 structB[12] = { 0, };
1736 GstBitReader br;
1737 GstByteReader byter = GST_BYTE_READER_INIT (data, size);
1738 GstByteWriter bytew;
1739
1740 g_return_val_if_fail (seqlayer != NULL, GST_VC1_PARSER_ERROR);
1741
1742 /* Thanks to the specification, structA and structB fields are defined
1743 * as unisgned integer msb first.
1744 * But in sequence-layer there are serialized in little-endian byte order,
1745 * so we must take care of their endianness before using bit reader */
1746
1747 if (!gst_byte_reader_get_uint24_le (&byter, &seqlayer->numframes))
1748 goto failed;
1749
1750 if (!gst_byte_reader_get_uint8 (&byter, &tmp8))
1751 goto failed;
1752
1753 if (tmp8 != 0xC5)
1754 goto failed;
1755
1756 /* 0x00000004 */
1757 if (!gst_byte_reader_get_uint32_le (&byter, &tmp))
1758 goto failed;
1759
1760 if (tmp != 0x04)
1761 goto failed;
1762
1763 /* As an exception, structC is serialized in big-endian byte order so
1764 * no endianness issue here but we should at least have 4 bytes */
1765 if (gst_byte_reader_get_remaining (&byter) < 4)
1766 goto failed;
1767
1768 gst_bit_reader_init (&br, data + gst_byte_reader_get_pos (&byter), 4);
1769 if (parse_sequence_header_struct_c (&br, &seqlayer->struct_c) ==
1770 GST_VC1_PARSER_ERROR)
1771 goto failed;
1772
1773 gst_byte_reader_skip (&byter, 4);
1774
1775 /* structA */
1776 gst_byte_writer_init_with_data (&bytew, structA, 8, TRUE);
1777 gst_byte_reader_get_uint32_le (&byter, &tmp);
1778 gst_byte_writer_put_uint32_be (&bytew, tmp);
1779 gst_byte_reader_get_uint32_le (&byter, &tmp);
1780 gst_byte_writer_put_uint32_be (&bytew, tmp);
1781
1782 gst_bit_reader_init (&br, structA, 8);
1783 if (parse_sequence_header_struct_a (&br, &seqlayer->struct_a) ==
1784 GST_VC1_PARSER_ERROR)
1785 goto failed;
1786
1787 /* 0x0000000C */
1788 if (!gst_byte_reader_get_uint32_le (&byter, &tmp))
1789 goto failed;
1790
1791 if (tmp != 0x0C)
1792 goto failed;
1793
1794 /* structB */
1795 gst_byte_writer_reset (&bytew);
1796 gst_byte_writer_init_with_data (&bytew, structB, 12, TRUE);
1797 gst_byte_reader_get_uint32_le (&byter, &tmp);
1798 gst_byte_writer_put_uint32_be (&bytew, tmp);
1799 gst_byte_reader_get_uint32_le (&byter, &tmp);
1800 gst_byte_writer_put_uint32_be (&bytew, tmp);
1801 gst_byte_reader_get_uint32_le (&byter, &tmp);
1802 gst_byte_writer_put_uint32_be (&bytew, tmp);
1803
1804 gst_bit_reader_init (&br, structB, 12);
1805 if (parse_sequence_header_struct_b (&br, &seqlayer->struct_b) ==
1806 GST_VC1_PARSER_ERROR)
1807 goto failed;
1808
1809 return GST_VC1_PARSER_OK;
1810
1811 failed:
1812 GST_WARNING ("Failed to parse sequence layer");
1813
1814 return GST_VC1_PARSER_ERROR;
1815 }
1816
1817 /**
1818 * gst_vc1_parse_sequence_header_struct_a:
1819 * @data: The data to parse
1820 * @size: the size of @data
1821 * @structa: The #GstVC1SeqStructA to set.
1822 *
1823 * Parses @data, and fills @structa fields.
1824 *
1825 * Returns: a #GstVC1ParserResult
1826 */
1827 GstVC1ParserResult
gst_vc1_parse_sequence_header_struct_a(const guint8 * data,gsize size,GstVC1SeqStructA * structa)1828 gst_vc1_parse_sequence_header_struct_a (const guint8 * data,
1829 gsize size, GstVC1SeqStructA * structa)
1830 {
1831 GstBitReader br = GST_BIT_READER_INIT (data, size);
1832
1833 g_return_val_if_fail (structa != NULL, GST_VC1_PARSER_ERROR);
1834
1835 return parse_sequence_header_struct_a (&br, structa);
1836 }
1837
1838 /**
1839 * gst_vc1_parse_sequence_header_struct_b:
1840 * @data: The data to parse
1841 * @size: the size of @data
1842 * @structb: The #GstVC1SeqStructB to set.
1843 *
1844 * Parses @data, and fills @structb fields.
1845 *
1846 * Returns: a #GstVC1ParserResult
1847 */
1848 GstVC1ParserResult
gst_vc1_parse_sequence_header_struct_b(const guint8 * data,gsize size,GstVC1SeqStructB * structb)1849 gst_vc1_parse_sequence_header_struct_b (const guint8 * data,
1850 gsize size, GstVC1SeqStructB * structb)
1851 {
1852 GstBitReader br = GST_BIT_READER_INIT (data, size);
1853
1854 g_return_val_if_fail (structb != NULL, GST_VC1_PARSER_ERROR);
1855
1856 return parse_sequence_header_struct_b (&br, structb);
1857 }
1858
1859 /**
1860 * gst_vc1_parse_sequence_header_struct_c:
1861 * @data: The data to parse
1862 * @size: the size of @data
1863 * @structc: The #GstVC1SeqStructC to set.
1864 *
1865 * Parses @data, and fills @structc fields.
1866 *
1867 * Returns: a #GstVC1ParserResult
1868 */
1869 GstVC1ParserResult
gst_vc1_parse_sequence_header_struct_c(const guint8 * data,gsize size,GstVC1SeqStructC * structc)1870 gst_vc1_parse_sequence_header_struct_c (const guint8 * data, gsize size,
1871 GstVC1SeqStructC * structc)
1872 {
1873 GstBitReader br = GST_BIT_READER_INIT (data, size);
1874
1875 g_return_val_if_fail (structc != NULL, GST_VC1_PARSER_ERROR);
1876
1877 return parse_sequence_header_struct_c (&br, structc);
1878 }
1879
1880 /**
1881 * gst_vc1_parse_sequence_header:
1882 * @data: The data to parse
1883 * @size: the size of @data
1884 * @seqhdr: The #GstVC1SeqHdr to set.
1885 *
1886 * Parses @data, and fills @seqhdr fields.
1887 *
1888 * Returns: a #GstVC1ParserResult
1889 */
1890 GstVC1ParserResult
gst_vc1_parse_sequence_header(const guint8 * data,gsize size,GstVC1SeqHdr * seqhdr)1891 gst_vc1_parse_sequence_header (const guint8 * data, gsize size,
1892 GstVC1SeqHdr * seqhdr)
1893 {
1894 GstBitReader br = GST_BIT_READER_INIT (data, size);
1895
1896 g_return_val_if_fail (seqhdr != NULL, GST_VC1_PARSER_ERROR);
1897
1898 if (parse_sequence_header_struct_c (&br, &seqhdr->struct_c) ==
1899 GST_VC1_PARSER_ERROR)
1900 goto failed;
1901
1902 /* Convenience field */
1903 seqhdr->profile = seqhdr->struct_c.profile;
1904
1905 if (seqhdr->profile == GST_VC1_PROFILE_ADVANCED)
1906 return parse_sequence_header_advanced (seqhdr, &br);
1907
1908 /* Compute MB height and width */
1909 calculate_mb_size (seqhdr, seqhdr->struct_c.coded_width,
1910 seqhdr->struct_c.coded_height);
1911
1912 return GST_VC1_PARSER_OK;
1913
1914 failed:
1915 GST_WARNING ("Failed to parse sequence header");
1916
1917 return GST_VC1_PARSER_ERROR;
1918 }
1919
1920 /**
1921 * gst_vc1_parse_entry_point_header:
1922 * @data: The data to parse
1923 * @size: the size of @data
1924 * @entrypoint: (out): The #GstVC1EntryPointHdr to set.
1925 * @seqhdr: The #GstVC1SeqHdr currently being parsed
1926 *
1927 * Parses @data, and sets @entrypoint fields.
1928 *
1929 * Returns: a #GstVC1EntryPointHdr
1930 */
1931 GstVC1ParserResult
gst_vc1_parse_entry_point_header(const guint8 * data,gsize size,GstVC1EntryPointHdr * entrypoint,GstVC1SeqHdr * seqhdr)1932 gst_vc1_parse_entry_point_header (const guint8 * data, gsize size,
1933 GstVC1EntryPointHdr * entrypoint, GstVC1SeqHdr * seqhdr)
1934 {
1935 GstBitReader br;
1936 guint8 i;
1937 GstVC1AdvancedSeqHdr *advanced = &seqhdr->advanced;
1938
1939 g_return_val_if_fail (entrypoint != NULL, GST_VC1_PARSER_ERROR);
1940
1941 gst_bit_reader_init (&br, data, size);
1942
1943 if (gst_bit_reader_get_remaining (&br) < 13)
1944 goto failed;
1945
1946 entrypoint->broken_link = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1947 entrypoint->closed_entry = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1948 entrypoint->panscan_flag = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1949 entrypoint->refdist_flag = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1950 entrypoint->loopfilter = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1951 entrypoint->fastuvmc = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1952 entrypoint->extended_mv = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1953 entrypoint->dquant = gst_bit_reader_get_bits_uint8_unchecked (&br, 2);
1954 entrypoint->vstransform = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1955 entrypoint->overlap = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
1956 entrypoint->quantizer = gst_bit_reader_get_bits_uint8_unchecked (&br, 2);
1957
1958 if (advanced->hrd_param_flag) {
1959 if (seqhdr->advanced.hrd_param.hrd_num_leaky_buckets >
1960 MAX_HRD_NUM_LEAKY_BUCKETS) {
1961 GST_WARNING
1962 ("hrd_num_leaky_buckets (%d) > MAX_HRD_NUM_LEAKY_BUCKETS (%d)",
1963 seqhdr->advanced.hrd_param.hrd_num_leaky_buckets,
1964 MAX_HRD_NUM_LEAKY_BUCKETS);
1965 goto failed;
1966 }
1967 for (i = 0; i < seqhdr->advanced.hrd_param.hrd_num_leaky_buckets; i++)
1968 READ_UINT8 (&br, entrypoint->hrd_full[i], 8);
1969 }
1970
1971 READ_UINT8 (&br, entrypoint->coded_size_flag, 1);
1972 if (entrypoint->coded_size_flag) {
1973 READ_UINT16 (&br, entrypoint->coded_width, 12);
1974 READ_UINT16 (&br, entrypoint->coded_height, 12);
1975 entrypoint->coded_height = (entrypoint->coded_height + 1) << 1;
1976 entrypoint->coded_width = (entrypoint->coded_width + 1) << 1;
1977 calculate_mb_size (seqhdr, entrypoint->coded_width,
1978 entrypoint->coded_height);
1979 }
1980
1981 if (entrypoint->extended_mv)
1982 READ_UINT8 (&br, entrypoint->extended_dmv, 1);
1983
1984 READ_UINT8 (&br, entrypoint->range_mapy_flag, 1);
1985 if (entrypoint->range_mapy_flag)
1986 READ_UINT8 (&br, entrypoint->range_mapy, 3);
1987
1988 READ_UINT8 (&br, entrypoint->range_mapuv_flag, 1);
1989 if (entrypoint->range_mapuv_flag)
1990 READ_UINT8 (&br, entrypoint->range_mapuv, 3);
1991
1992 advanced->entrypoint = *entrypoint;
1993
1994 return GST_VC1_PARSER_OK;
1995
1996 failed:
1997 GST_WARNING ("Failed to parse entry point header");
1998
1999 return GST_VC1_PARSER_ERROR;
2000 }
2001
2002 /**
2003 * gst_vc1_parse_frame_layer:
2004 * @data: The data to parse
2005 * @size: the size of @data
2006 * @framelayer: The #GstVC1FrameLayer to fill.
2007 *
2008 * Parses @data, and fills @framelayer fields.
2009 *
2010 * Returns: a #GstVC1ParserResult
2011 */
2012 GstVC1ParserResult
gst_vc1_parse_frame_layer(const guint8 * data,gsize size,GstVC1FrameLayer * framelayer)2013 gst_vc1_parse_frame_layer (const guint8 * data, gsize size,
2014 GstVC1FrameLayer * framelayer)
2015 {
2016 GstBitReader br = GST_BIT_READER_INIT (data, size);
2017
2018 if (gst_bit_reader_get_remaining (&br) < 64) {
2019 GST_WARNING ("Could not parse frame layer");
2020
2021 return GST_VC1_PARSER_ERROR;
2022 }
2023
2024 /* set default values */
2025 framelayer->skiped_p_frame = 0;
2026
2027 framelayer->key = gst_bit_reader_get_bits_uint8_unchecked (&br, 1);
2028 gst_bit_reader_skip_unchecked (&br, 7);
2029
2030 framelayer->framesize = gst_bit_reader_get_bits_uint32_unchecked (&br, 24);
2031
2032 if (framelayer->framesize == 0 || framelayer->framesize == 1)
2033 framelayer->skiped_p_frame = 1;
2034
2035 /* compute next_framelayer_offset */
2036 framelayer->next_framelayer_offset = framelayer->framesize + 8;
2037
2038 framelayer->timestamp = gst_bit_reader_get_bits_uint32_unchecked (&br, 32);
2039
2040 return GST_VC1_PARSER_OK;
2041 }
2042
2043 /**
2044 * gst_vc1_parse_frame_header:
2045 * @data: The data to parse
2046 * @size: the size of @data
2047 * @framehdr: The #GstVC1FrameHdr to fill.
2048 * @seqhdr: The #GstVC1SeqHdr currently being parsed
2049 * @bitplanes: The #GstVC1BitPlanes to store bitplanes in or %NULL
2050 *
2051 * Parses @data, and fills @entrypoint fields.
2052 *
2053 * Returns: a #GstVC1ParserResult
2054 */
2055 GstVC1ParserResult
gst_vc1_parse_frame_header(const guint8 * data,gsize size,GstVC1FrameHdr * framehdr,GstVC1SeqHdr * seqhdr,GstVC1BitPlanes * bitplanes)2056 gst_vc1_parse_frame_header (const guint8 * data, gsize size,
2057 GstVC1FrameHdr * framehdr, GstVC1SeqHdr * seqhdr,
2058 GstVC1BitPlanes * bitplanes)
2059 {
2060 GstBitReader br;
2061 GstVC1ParserResult result;
2062
2063 gst_bit_reader_init (&br, data, size);
2064
2065 if (seqhdr->profile == GST_VC1_PROFILE_ADVANCED)
2066 result = parse_frame_header_advanced (&br, framehdr, seqhdr, bitplanes,
2067 FALSE);
2068 else
2069 result = parse_frame_header (&br, framehdr, seqhdr, bitplanes);
2070
2071 framehdr->header_size = gst_bit_reader_get_pos (&br);
2072 return result;
2073 }
2074
2075 /**
2076 * gst_vc1_parse_field_header:
2077 * @data: The data to parse
2078 * @size: the size of @data
2079 * @fieldhdr: The #GstVC1FrameHdr to fill.
2080 * @seqhdr: The #GstVC1SeqHdr currently being parsed
2081 * @bitplanes: The #GstVC1BitPlanes to store bitplanes in or %NULL
2082 *
2083 * Parses @data, and fills @fieldhdr fields.
2084 *
2085 * Returns: a #GstVC1ParserResult
2086 */
2087 GstVC1ParserResult
gst_vc1_parse_field_header(const guint8 * data,gsize size,GstVC1FrameHdr * fieldhdr,GstVC1SeqHdr * seqhdr,GstVC1BitPlanes * bitplanes)2088 gst_vc1_parse_field_header (const guint8 * data, gsize size,
2089 GstVC1FrameHdr * fieldhdr, GstVC1SeqHdr * seqhdr,
2090 GstVC1BitPlanes * bitplanes)
2091 {
2092 GstBitReader br;
2093 GstVC1ParserResult result;
2094
2095 gst_bit_reader_init (&br, data, size);
2096
2097 result = parse_frame_header_advanced (&br, fieldhdr, seqhdr, bitplanes, TRUE);
2098
2099 return result;
2100 }
2101
2102 /**
2103 * gst_vc1_parse_slice_header:
2104 * @data: The data to parse
2105 * @size: The size of @data
2106 * @slicehdr: The #GstVC1SliceHdr to fill
2107 * @seqhdr: The #GstVC1SeqHdr that was previously parsed
2108 *
2109 * Parses @data, and fills @slicehdr fields.
2110 *
2111 * Returns: a #GstVC1ParserResult
2112 *
2113 * Since: 1.2
2114 */
2115 GstVC1ParserResult
gst_vc1_parse_slice_header(const guint8 * data,gsize size,GstVC1SliceHdr * slicehdr,GstVC1SeqHdr * seqhdr)2116 gst_vc1_parse_slice_header (const guint8 * data, gsize size,
2117 GstVC1SliceHdr * slicehdr, GstVC1SeqHdr * seqhdr)
2118 {
2119 GstBitReader br;
2120 GstVC1FrameHdr framehdr;
2121 GstVC1ParserResult result;
2122 guint8 pic_header_flag;
2123
2124 GST_DEBUG ("Parsing slice header");
2125
2126 if (seqhdr->profile != GST_VC1_PROFILE_ADVANCED)
2127 return GST_VC1_PARSER_BROKEN_DATA;
2128
2129 gst_bit_reader_init (&br, data, size);
2130
2131 READ_UINT16 (&br, slicehdr->slice_addr, 9);
2132 READ_UINT8 (&br, pic_header_flag, 1);
2133 if (pic_header_flag)
2134 result = parse_frame_header_advanced (&br, &framehdr, seqhdr, NULL, FALSE);
2135 else
2136 result = GST_VC1_PARSER_OK;
2137
2138 slicehdr->header_size = gst_bit_reader_get_pos (&br);
2139 return result;
2140
2141 failed:
2142 GST_WARNING ("Failed to parse slice header");
2143 return GST_VC1_PARSER_ERROR;
2144 }
2145
2146 /**
2147 * gst_vc1_bitplanes_new:
2148 *
2149 * Creates a new #GstVC1BitPlanes. It should be freed with
2150 * gst_vc1_bitplanes_free() after use.
2151 *
2152 * Returns: a new #GstVC1BitPlanes
2153 */
2154 GstVC1BitPlanes *
gst_vc1_bitplanes_new(void)2155 gst_vc1_bitplanes_new (void)
2156 {
2157 return g_slice_new0 (GstVC1BitPlanes);
2158 }
2159
2160 /**
2161 * gst_vc1_bitplane_free:
2162 * @bitplanes: the #GstVC1BitPlanes to free
2163 *
2164 * Frees @bitplanes.
2165 */
2166 void
gst_vc1_bitplanes_free(GstVC1BitPlanes * bitplanes)2167 gst_vc1_bitplanes_free (GstVC1BitPlanes * bitplanes)
2168 {
2169 gst_vc1_bitplanes_free_1 (bitplanes);
2170 g_slice_free (GstVC1BitPlanes, bitplanes);
2171 }
2172
2173 /**
2174 * gst_vc1_bitplane_free_1:
2175 * @bitplanes: The #GstVC1BitPlanes to free
2176 *
2177 * Frees @bitplanes fields.
2178 */
2179 void
gst_vc1_bitplanes_free_1(GstVC1BitPlanes * bitplanes)2180 gst_vc1_bitplanes_free_1 (GstVC1BitPlanes * bitplanes)
2181 {
2182 g_free (bitplanes->acpred);
2183 g_free (bitplanes->fieldtx);
2184 g_free (bitplanes->overflags);
2185 g_free (bitplanes->mvtypemb);
2186 g_free (bitplanes->skipmb);
2187 g_free (bitplanes->directmb);
2188 g_free (bitplanes->forwardmb);
2189 }
2190
2191 /**
2192 * gst_vc1_bitplanes_ensure_size:
2193 * @bitplanes: The #GstVC1BitPlanes to reset
2194 * @seqhdr: The #GstVC1SeqHdr from which to set @bitplanes
2195 *
2196 * Fills the @bitplanes structure from @seqhdr, this function
2197 * should be called after #gst_vc1_parse_sequence_header if
2198 * in simple or main mode, or after #gst_vc1_parse_entry_point_header
2199 * if in advanced mode.
2200 *
2201 * Returns: %TRUE if everything went fine, %FALSE otherwise
2202 */
2203 gboolean
gst_vc1_bitplanes_ensure_size(GstVC1BitPlanes * bitplanes,GstVC1SeqHdr * seqhdr)2204 gst_vc1_bitplanes_ensure_size (GstVC1BitPlanes * bitplanes,
2205 GstVC1SeqHdr * seqhdr)
2206 {
2207 g_return_val_if_fail (bitplanes != NULL, FALSE);
2208 g_return_val_if_fail (seqhdr != NULL, FALSE);
2209
2210 if (bitplanes->size) {
2211 bitplanes->size = seqhdr->mb_height * seqhdr->mb_stride;
2212 bitplanes->acpred =
2213 g_realloc_n (bitplanes->acpred, bitplanes->size, sizeof (guint8));
2214 bitplanes->fieldtx =
2215 g_realloc_n (bitplanes->fieldtx, bitplanes->size, sizeof (guint8));
2216 bitplanes->overflags =
2217 g_realloc_n (bitplanes->overflags, bitplanes->size, sizeof (guint8));
2218 bitplanes->mvtypemb =
2219 g_realloc_n (bitplanes->mvtypemb, bitplanes->size, sizeof (guint8));
2220 bitplanes->skipmb =
2221 g_realloc_n (bitplanes->skipmb, bitplanes->size, sizeof (guint8));
2222 bitplanes->directmb =
2223 g_realloc_n (bitplanes->directmb, bitplanes->size, sizeof (guint8));
2224 bitplanes->forwardmb =
2225 g_realloc_n (bitplanes->forwardmb, bitplanes->size, sizeof (guint8));
2226 } else {
2227 bitplanes->size = seqhdr->mb_height * seqhdr->mb_stride;
2228 bitplanes->acpred = g_malloc0 (bitplanes->size * sizeof (guint8));
2229 bitplanes->fieldtx = g_malloc0 (bitplanes->size * sizeof (guint8));
2230 bitplanes->overflags = g_malloc0 (bitplanes->size * sizeof (guint8));
2231 bitplanes->mvtypemb = g_malloc0 (bitplanes->size * sizeof (guint8));
2232 bitplanes->skipmb = g_malloc0 (bitplanes->size * sizeof (guint8));
2233 bitplanes->directmb = g_malloc0 (bitplanes->size * sizeof (guint8));
2234 bitplanes->forwardmb = g_malloc0 (bitplanes->size * sizeof (guint8));
2235 }
2236
2237 return TRUE;
2238 }
2239