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_mapy_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