ext/codecparsers/gst-libs/gst/codecparsers/gstvc1parser.c

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