/* Gstreamer * Copyright (C) <2011> Intel * Copyright (C) <2011> Collabora Ltd. * Copyright (C) <2011> Thibault Saunier * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, * Boston, MA 02110-1301, USA. */ /** * SECTION:gstvc1parser * @short_description: Convenience library for parsing vc1 video * bitstream. * * For more details about the structures, look at the * smpte specifications (S421m-2006.pdf). * */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include "gstvc1parser.h" #include "parserutils.h" #include #include #include #include #ifndef GST_DISABLE_GST_DEBUG #define GST_CAT_DEFAULT ensure_debug_category() static GstDebugCategory * ensure_debug_category (void) { static gsize cat_gonce = 0; if (g_once_init_enter (&cat_gonce)) { gsize cat_done; cat_done = (gsize) _gst_debug_category_new ("codecparsers_vc1", 0, "VC1 codec parsing library"); g_once_init_leave (&cat_gonce, cat_done); } return (GstDebugCategory *) cat_gonce; } #else #define ensure_debug_category() /* NOOP */ #endif /* GST_DISABLE_GST_DEBUG */ static const guint8 vc1_pquant_table[3][32] = { { /* Implicit quantizer */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31}, { /* Explicit quantizer, pquantizer uniform */ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}, { /* Explicit quantizer, pquantizer non-uniform */ 0, 1, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31} }; static const guint8 vc1_mvmode_table[2][5] = { /* Table 47: P Picture High rate (PQUANT <= 12) MVMODE code table */ { GST_VC1_MVMODE_1MV, GST_VC1_MVMODE_MIXED_MV, GST_VC1_MVMODE_1MV_HPEL, GST_VC1_MVMODE_INTENSITY_COMP, GST_VC1_MVMODE_1MV_HPEL_BILINEAR}, /* Table 46: P Picture Low rate (PQUANT > 12) MVMODE code table */ { GST_VC1_MVMODE_1MV_HPEL_BILINEAR, GST_VC1_MVMODE_1MV, GST_VC1_MVMODE_1MV_HPEL, GST_VC1_MVMODE_INTENSITY_COMP, GST_VC1_MVMODE_MIXED_MV} }; static const guint8 vc1_mvmode2_table[2][4] = { /* Table 50: P Picture High rate (PQUANT <= 12) MVMODE2 code table */ { GST_VC1_MVMODE_1MV, GST_VC1_MVMODE_MIXED_MV, GST_VC1_MVMODE_1MV_HPEL, GST_VC1_MVMODE_1MV_HPEL_BILINEAR}, /* Table 49: P Picture Low rate (PQUANT > 12) MVMODE2 code table */ { GST_VC1_MVMODE_1MV_HPEL_BILINEAR, GST_VC1_MVMODE_1MV, GST_VC1_MVMODE_1MV_HPEL, GST_VC1_MVMODE_MIXED_MV} }; /* Table 40: BFRACTION VLC Table */ static const VLCTable vc1_bfraction_vlc_table[] = { {GST_VC1_BFRACTION_BASIS / 2, 0x00, 3}, {GST_VC1_BFRACTION_BASIS / 3, 0x01, 3}, {(GST_VC1_BFRACTION_BASIS * 2) / 3, 0x02, 3}, {GST_VC1_BFRACTION_BASIS / 4, 0x02, 3}, {(GST_VC1_BFRACTION_BASIS * 3) / 4, 0x04, 3}, {GST_VC1_BFRACTION_BASIS / 5, 0x05, 3}, {(GST_VC1_BFRACTION_BASIS * 2) / 5, 0x06, 3}, {(GST_VC1_BFRACTION_BASIS * 3) / 5, 0x70, 7}, {(GST_VC1_BFRACTION_BASIS * 4) / 5, 0x71, 7}, {GST_VC1_BFRACTION_BASIS / 6, 0x72, 7}, {(GST_VC1_BFRACTION_BASIS * 5) / 6, 0x73, 7}, {GST_VC1_BFRACTION_BASIS / 7, 0x74, 7}, {(GST_VC1_BFRACTION_BASIS * 2) / 7, 0x75, 7}, {(GST_VC1_BFRACTION_BASIS * 3) / 7, 0x76, 7}, {(GST_VC1_BFRACTION_BASIS * 4) / 7, 0x77, 7}, {(GST_VC1_BFRACTION_BASIS * 5) / 7, 0x78, 7}, {(GST_VC1_BFRACTION_BASIS * 6) / 7, 0x79, 7}, {GST_VC1_BFRACTION_BASIS / 8, 0x7a, 7}, {(GST_VC1_BFRACTION_BASIS * 3) / 8, 0x7b, 7}, {(GST_VC1_BFRACTION_BASIS * 5) / 8, 0x7c, 7}, {(GST_VC1_BFRACTION_BASIS * 7) / 8, 0x7d, 7}, {GST_VC1_BFRACTION_RESERVED, 0x7e, 7}, {GST_VC1_BFRACTION_PTYPE_BI, 0x7f, 7} }; /* Imode types */ enum { IMODE_RAW, IMODE_NORM2, IMODE_DIFF2, IMODE_NORM6, IMODE_DIFF6, IMODE_ROWSKIP, IMODE_COLSKIP }; /* Table 69: IMODE VLC Codetable */ static const VLCTable vc1_imode_vlc_table[] = { {IMODE_NORM2, 0x02, 2}, {IMODE_NORM6, 0x03, 2}, {IMODE_ROWSKIP, 0x02, 3}, {IMODE_COLSKIP, 0x03, 3}, {IMODE_DIFF2, 0x01, 3}, {IMODE_DIFF6, 0x01, 4}, {IMODE_RAW, 0x00, 4} }; /* Table 80: Norm-2/Diff-2 Code Table */ static const VLCTable vc1_norm2_vlc_table[4] = { {0, 0, 1}, {2, 4, 3}, {1, 5, 3}, {3, 3, 2} }; /* Table 81: Code table for 3x2 and 2x3 tiles */ static const VLCTable vc1_norm6_vlc_table[64] = { {0, 1, 1}, {1, 2, 4}, {2, 3, 4}, {3, 0, 8}, {4, 4, 4}, {5, 1, 8}, {6, 2, 8}, {7, (2 << 5) | 7, 10}, {8, 5, 4}, {9, 3, 8}, {10, 4, 8}, {11, (2 << 5) | 11, 10}, {12, 5, 8}, {13, (2 << 5) | 13, 10}, {14, (2 << 5) | 14, 10}, {15, (3 << 8) | 14, 13}, {16, 6, 4}, {17, 6, 8}, {18, 7, 8}, {19, (2 << 5) | 19, 10}, {20, 8, 8}, {21, (2 << 5) | 21, 10}, {22, (2 << 5) | 22, 10}, {23, (3 << 8) | 13, 13}, {24, 9, 8}, {25, (2 << 5) | 25, 10}, {26, (2 << 5) | 26, 10}, {27, (3 << 8) | 12, 13}, {28, (2 << 5) | 28, 10}, {29, (3 << 8) | 11, 13}, {30, (3 << 8) | 10, 13}, {31, (3 << 4) | 7, 9}, {32, 7, 4}, {33, 10, 8}, {34, 11, 8}, {35, (2 << 5) | 3, 10}, {36, 12, 8}, {37, (2 << 5) | 5, 10}, {38, (2 << 5) | 6, 10}, {39, (3 << 8) | 9, 13}, {40, 13, 8}, {41, (2 << 5) | 9, 10}, {42, (2 << 5) | 10, 10}, {43, (3 << 8) | 8, 13}, {44, (2 << 5) | 12, 10}, {45, (3 << 8) | 7, 13}, {46, (3 << 8) | 6, 13}, {47, (3 << 4) | 6, 9}, {48, 14, 8}, {49, (2 << 5) | 17, 10}, {50, (2 << 5) | 18, 10}, {51, (3 << 8) | 5, 13}, {52, (2 << 5) | 20, 10}, {53, (3 << 8) | 4, 13}, {54, (3 << 8) | 3, 13}, {55, (3 << 4) | 5, 9}, {56, (2 << 5) | 24, 10}, {57, (3 << 8) | 2, 13}, {58, (3 << 8) | 1, 13}, {59, (3 << 4) | 4, 9}, {60, (3 << 8) | 0, 13}, {61, (3 << 4) | 3, 9}, {62, (3 << 4) | 2, 9}, {63, (3 << 1) | 1, 6} }; /* SMPTE 421M Table 7 */ typedef struct { gint par_n, par_d; } PAR; static PAR aspect_ratios[] = { {0, 0}, {1, 1}, {12, 11}, {10, 11}, {16, 11}, {40, 33}, {24, 11}, {20, 11}, {32, 11}, {80, 33}, {18, 11}, {15, 11}, {64, 33}, {160, 99}, {0, 0}, {0, 0} }; /* SMPTE 421M Table 8 */ static const guint framerates_n[] = { 0, 24 * 1000, 25 * 1000, 30 * 1000, 50 * 1000, 60 * 1000, 48 * 1000, 72 * 1000 }; /* SMPTE 421M Table 9 */ static const guint framerates_d[] = { 0, 1000, 1001 }; static inline gboolean decode_colskip (GstBitReader * br, guint8 * data, guint width, guint height, guint stride, guint invert) { guint x, y; guint8 colskip, v; GST_DEBUG ("Parsing colskip"); invert &= 1; for (x = 0; x < width; x++) { READ_UINT8 (br, colskip, 1); if (data) { if (colskip) { for (y = 0; y < height; y++) { READ_UINT8 (br, v, 1); data[y * stride] = v ^ invert; } } else { for (y = 0; y < height; y++) data[y * stride] = invert; } data++; } else if (colskip) SKIP (br, height); } return TRUE; failed: GST_WARNING ("Failed to parse colskip"); return FALSE; } static inline gboolean decode_rowskip (GstBitReader * br, guint8 * data, guint width, guint height, guint stride, guint invert) { guint x, y; guint8 rowskip, v; GST_DEBUG ("Parsing rowskip"); invert &= 1; for (y = 0; y < height; y++) { READ_UINT8 (br, rowskip, 1); if (data) { if (!rowskip) memset (data, invert, width); else { for (x = 0; x < width; x++) { READ_UINT8 (br, v, 1); data[x] = v ^ invert; } } data += stride; } else if (rowskip) SKIP (br, width); } return TRUE; failed: GST_WARNING ("Failed to parse rowskip"); return FALSE; } static inline gint8 decode012 (GstBitReader * br) { guint8 n; READ_UINT8 (br, n, 1); if (n == 0) return 0; READ_UINT8 (br, n, 1); return n + 1; failed: GST_WARNING ("Could not decode 0 1 2 returning -1"); return -1; } static inline guint calculate_nb_pan_scan_win (GstVC1AdvancedSeqHdr * advseqhdr, GstVC1PicAdvanced * pic) { if (advseqhdr->interlace && !advseqhdr->psf) { if (advseqhdr->pulldown) return pic->rff + 2; return 2; } else { if (advseqhdr->pulldown) return pic->rptfrm + 1; return 1; } } static gboolean decode_refdist (GstBitReader * br, guint16 * value) { guint16 tmp; gint i = 2; if (!gst_bit_reader_peek_bits_uint16 (br, &tmp, i)) goto failed; if (tmp < 0x03) { READ_UINT16 (br, *value, i); return TRUE; } do { i++; if (!gst_bit_reader_peek_bits_uint16 (br, &tmp, i)) goto failed; if (!(tmp >> i)) { READ_UINT16 (br, *value, i); return TRUE; } } while (i < 16); failed: { GST_WARNING ("Could not decode end 0 returning"); return FALSE; } } /*** bitplanes decoding ***/ static gboolean bitplane_decoding (GstBitReader * br, guint8 * data, GstVC1SeqHdr * seqhdr, guint8 * is_raw) { const guint width = seqhdr->mb_width; const guint height = seqhdr->mb_height; const guint stride = seqhdr->mb_stride; guint imode, invert, invert_mask; guint x, y, v, o; guint8 *pdata = data; *is_raw = FALSE; GET_BITS (br, 1, &invert); invert_mask = -invert; if (!decode_vlc (br, &imode, vc1_imode_vlc_table, G_N_ELEMENTS (vc1_imode_vlc_table))) goto failed; switch (imode) { case IMODE_RAW: GST_DEBUG ("Parsing IMODE_RAW"); *is_raw = TRUE; return TRUE; case IMODE_DIFF2: invert_mask = 0; /* fall-through */ case IMODE_NORM2: invert_mask &= 3; GST_DEBUG ("Parsing IMODE_DIFF2 or IMODE_NORM2 biplane"); x = 0; o = (height * width) & 1; if (o) { GET_BITS (br, 1, &v); if (pdata) { *pdata++ = (v ^ invert_mask) & 1; if (++x == width) { x = 0; pdata += stride - width; } } } for (y = o; y < height * width; y += 2) { if (!decode_vlc (br, &v, vc1_norm2_vlc_table, G_N_ELEMENTS (vc1_norm2_vlc_table))) goto failed; if (pdata) { v ^= invert_mask; *pdata++ = v >> 1; if (++x == width) { x = 0; pdata += stride - width; } *pdata++ = v & 1; if (++x == width) { x = 0; pdata += stride - width; } } } break; case IMODE_DIFF6: invert_mask = 0; /* fall-through */ case IMODE_NORM6: GST_DEBUG ("Parsing IMODE_DIFF6 or IMODE_NORM6 biplane"); if (!(height % 3) && (width % 3)) { /* decode 2x3 "vertical" tiles */ for (y = 0; y < height; y += 3) { for (x = width & 1; x < width; x += 2) { if (!decode_vlc (br, &v, vc1_norm6_vlc_table, G_N_ELEMENTS (vc1_norm6_vlc_table))) goto failed; if (pdata) { v ^= invert_mask; pdata[x + 0] = v & 1; pdata[x + 1] = (v >> 1) & 1; pdata[x + 0 + stride] = (v >> 2) & 1; pdata[x + 1 + stride] = (v >> 3) & 1; pdata[x + 0 + stride * 2] = (v >> 4) & 1; pdata[x + 1 + stride * 2] = (v >> 5) & 1; } } if (pdata) pdata += 3 * stride; } x = width & 1; y = 0; } else { /* decode 3x2 "horizontal" tiles */ if (pdata) pdata += (height & 1) * stride; for (y = height & 1; y < height; y += 2) { for (x = width % 3; x < width; x += 3) { if (!decode_vlc (br, &v, vc1_norm6_vlc_table, G_N_ELEMENTS (vc1_norm6_vlc_table))) goto failed; if (pdata) { v ^= invert_mask; pdata[x + 0] = v & 1; pdata[x + 1] = (v >> 1) & 1; pdata[x + 2] = (v >> 2) & 1; pdata[x + 0 + stride] = (v >> 3) & 1; pdata[x + 1 + stride] = (v >> 4) & 1; pdata[x + 2 + stride] = (v >> 5) & 1; } } if (pdata) pdata += 2 * stride; } x = width % 3; y = height & 1; } if (x) { if (data) pdata = data; if (!decode_colskip (br, pdata, x, height, stride, invert_mask)) goto failed; } if (y) { if (data) pdata = data + x; if (!decode_rowskip (br, pdata, width - x, y, stride, invert_mask)) goto failed; } break; case IMODE_ROWSKIP: GST_DEBUG ("Parsing IMODE_ROWSKIP biplane"); if (!decode_rowskip (br, data, width, height, stride, invert_mask)) goto failed; break; case IMODE_COLSKIP: GST_DEBUG ("Parsing IMODE_COLSKIP biplane"); if (!decode_colskip (br, data, width, height, stride, invert_mask)) goto failed; break; } if (!data) return TRUE; /* Applying diff operator */ if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6) { pdata = data; pdata[0] ^= invert; for (x = 1; x < width; x++) pdata[x] ^= pdata[x - 1]; for (y = 1; y < height; y++) { pdata[stride] ^= pdata[0]; for (x = 1; x < width; x++) { if (pdata[stride + x - 1] != pdata[x]) pdata[stride + x] ^= invert; else pdata[stride + x] ^= pdata[stride + x - 1]; } pdata += stride; } } return TRUE; failed: GST_WARNING ("Failed to decode bitplane"); return FALSE; } static gboolean parse_vopdquant (GstBitReader * br, GstVC1FrameHdr * framehdr, guint8 dquant) { GstVC1VopDquant *vopdquant = &framehdr->vopdquant; GST_DEBUG ("Parsing vopdquant"); vopdquant->dqbilevel = 0; if (dquant == 2) { vopdquant->dquantfrm = 0; READ_UINT8 (br, vopdquant->pqdiff, 3); if (vopdquant->pqdiff != 7) vopdquant->altpquant = framehdr->pquant + vopdquant->pqdiff + 1; else { READ_UINT8 (br, vopdquant->abspq, 5); vopdquant->altpquant = vopdquant->abspq; } } else { READ_UINT8 (br, vopdquant->dquantfrm, 1); GST_DEBUG (" %u DquantFrm %u", gst_bit_reader_get_pos (br), vopdquant->dquantfrm); if (vopdquant->dquantfrm) { READ_UINT8 (br, vopdquant->dqprofile, 2); switch (vopdquant->dqprofile) { case GST_VC1_DQPROFILE_SINGLE_EDGE: case GST_VC1_DQPROFILE_DOUBLE_EDGES: READ_UINT8 (br, vopdquant->dqbedge, 2); break; case GST_VC1_DQPROFILE_ALL_MBS: READ_UINT8 (br, vopdquant->dqbilevel, 1); break; } if (vopdquant->dqbilevel || vopdquant->dqprofile != GST_VC1_DQPROFILE_ALL_MBS) { { READ_UINT8 (br, vopdquant->pqdiff, 3); if (vopdquant->pqdiff != 7) vopdquant->altpquant = framehdr->pquant + vopdquant->pqdiff + 1; else { READ_UINT8 (br, vopdquant->abspq, 5); vopdquant->altpquant = vopdquant->abspq; } } } } } return TRUE; failed: GST_WARNING ("Failed to parse vopdquant"); return FALSE; } static inline gint scan_for_start_codes (const guint8 * data, guint size) { GstByteReader br; gst_byte_reader_init (&br, data, size); /* NALU not empty, so we can at least expect 1 (even 2) bytes following sc */ return gst_byte_reader_masked_scan_uint32 (&br, 0xffffff00, 0x00000100, 0, size); } static inline gint get_unary (GstBitReader * br, gint stop, gint len) { int i; guint8 current = 0xff; for (i = 0; i < len; i++) { current = gst_bit_reader_get_bits_uint8_unchecked (br, 1); if (current == stop) return i; } return i; } static inline void calculate_framerate_bitrate (guint8 frmrtq_postproc, guint8 bitrtq_postproc, guint * framerate, guint * bitrate) { if (frmrtq_postproc == 0 && bitrtq_postproc == 31) { *framerate = 0; *bitrate = 0; } else if (frmrtq_postproc == 0 && bitrtq_postproc == 30) { *framerate = 2; *bitrate = 1952; } else if (frmrtq_postproc == 1 && bitrtq_postproc == 31) { *framerate = 6; *bitrate = 2016; } else { if (frmrtq_postproc == 7) { *framerate = 30; } else { *framerate = 2 + (frmrtq_postproc * 4); } if (bitrtq_postproc == 31) { *bitrate = 2016; } else { *bitrate = 32 + (bitrtq_postproc * 64); } } } static inline void calculate_mb_size (GstVC1SeqHdr * seqhdr, guint width, guint height) { seqhdr->mb_width = (width + 15) >> 4; seqhdr->mb_height = (height + 15) >> 4; seqhdr->mb_stride = seqhdr->mb_width + 1; } static GstVC1ParserResult parse_hrd_param_flag (GstBitReader * br, GstVC1HrdParam * hrd_param) { guint i; GST_DEBUG ("Parsing Hrd param flag"); if (gst_bit_reader_get_remaining (br) < 13) goto failed; hrd_param->hrd_num_leaky_buckets = gst_bit_reader_get_bits_uint8_unchecked (br, 5); hrd_param->bit_rate_exponent = gst_bit_reader_get_bits_uint8_unchecked (br, 4); hrd_param->buffer_size_exponent = gst_bit_reader_get_bits_uint8_unchecked (br, 4); if (gst_bit_reader_get_remaining (br) < (32 * hrd_param->hrd_num_leaky_buckets)) goto failed; for (i = 0; i < hrd_param->hrd_num_leaky_buckets; i++) { hrd_param->hrd_rate[i] = gst_bit_reader_get_bits_uint16_unchecked (br, 16); hrd_param->hrd_buffer[i] = gst_bit_reader_get_bits_uint16_unchecked (br, 16); } return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse hrd param flag"); return GST_VC1_PARSER_ERROR; } static GstVC1ParserResult parse_sequence_header_advanced (GstVC1SeqHdr * seqhdr, GstBitReader * br) { GstVC1AdvancedSeqHdr *advanced = &seqhdr->advanced; guint8 tmp; GST_DEBUG ("Parsing sequence header in advanced mode"); READ_UINT8 (br, tmp, 3); advanced->level = tmp; advanced->par_n = 0; advanced->par_d = 0; advanced->fps_n = 0; advanced->fps_d = 0; READ_UINT8 (br, advanced->colordiff_format, 2); READ_UINT8 (br, advanced->frmrtq_postproc, 3); READ_UINT8 (br, advanced->bitrtq_postproc, 5); calculate_framerate_bitrate (advanced->frmrtq_postproc, advanced->bitrtq_postproc, &advanced->framerate, &advanced->bitrate); GST_DEBUG ("level %u, colordiff_format %u , frmrtq_postproc %u," " bitrtq_postproc %u", advanced->level, advanced->colordiff_format, advanced->frmrtq_postproc, advanced->bitrtq_postproc); if (gst_bit_reader_get_remaining (br) < 32) goto failed; advanced->postprocflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1); advanced->max_coded_width = gst_bit_reader_get_bits_uint16_unchecked (br, 12); advanced->max_coded_height = gst_bit_reader_get_bits_uint16_unchecked (br, 12); advanced->max_coded_width = (advanced->max_coded_width + 1) << 1; advanced->max_coded_height = (advanced->max_coded_height + 1) << 1; calculate_mb_size (seqhdr, advanced->max_coded_width, advanced->max_coded_height); advanced->pulldown = gst_bit_reader_get_bits_uint8_unchecked (br, 1); advanced->interlace = gst_bit_reader_get_bits_uint8_unchecked (br, 1); advanced->tfcntrflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1); advanced->finterpflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1); GST_DEBUG ("postprocflag %u, max_coded_width %u, max_coded_height %u," "pulldown %u, interlace %u, tfcntrflag %u, finterpflag %u", advanced->postprocflag, advanced->max_coded_width, advanced->max_coded_height, advanced->pulldown, advanced->interlace, advanced->tfcntrflag, advanced->finterpflag); /* Skipping reserved bit */ gst_bit_reader_skip_unchecked (br, 1); advanced->psf = gst_bit_reader_get_bits_uint8_unchecked (br, 1); advanced->display_ext = gst_bit_reader_get_bits_uint8_unchecked (br, 1); if (advanced->display_ext) { READ_UINT16 (br, advanced->disp_horiz_size, 14); READ_UINT16 (br, advanced->disp_vert_size, 14); advanced->disp_horiz_size++; advanced->disp_vert_size++; READ_UINT8 (br, advanced->aspect_ratio_flag, 1); if (advanced->aspect_ratio_flag) { READ_UINT8 (br, advanced->aspect_ratio, 4); if (advanced->aspect_ratio == 15) { /* Aspect Width (6.1.14.3.2) and Aspect Height (6.1.14.3.3) * syntax elements hold a binary encoding of sizes ranging * from 1 to 256 */ READ_UINT8 (br, advanced->aspect_horiz_size, 8); READ_UINT8 (br, advanced->aspect_vert_size, 8); advanced->par_n = 1 + advanced->aspect_horiz_size; advanced->par_d = 1 + advanced->aspect_vert_size; } else { advanced->par_n = aspect_ratios[advanced->aspect_ratio].par_n; advanced->par_d = aspect_ratios[advanced->aspect_ratio].par_d; } } READ_UINT8 (br, advanced->framerate_flag, 1); if (advanced->framerate_flag) { READ_UINT8 (br, advanced->framerateind, 1); if (!advanced->framerateind) { READ_UINT8 (br, advanced->frameratenr, 8); READ_UINT8 (br, advanced->frameratedr, 4); } else { READ_UINT16 (br, advanced->framerateexp, 16); } if (advanced->frameratenr > 0 && advanced->frameratenr < 8 && advanced->frameratedr > 0 && advanced->frameratedr < 3) { advanced->fps_n = framerates_n[advanced->frameratenr]; advanced->fps_d = framerates_d[advanced->frameratedr]; } else { advanced->fps_n = advanced->framerateexp + 1; advanced->fps_d = 32; } } READ_UINT8 (br, advanced->color_format_flag, 1); if (advanced->color_format_flag) { if (gst_bit_reader_get_remaining (br) < 24) goto failed; advanced->color_prim = gst_bit_reader_get_bits_uint8_unchecked (br, 8); advanced->transfer_char = gst_bit_reader_get_bits_uint8_unchecked (br, 8); advanced->matrix_coef = gst_bit_reader_get_bits_uint8_unchecked (br, 8); } } READ_UINT8 (br, advanced->hrd_param_flag, 1); if (advanced->hrd_param_flag) return parse_hrd_param_flag (br, &advanced->hrd_param); return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse advanced headers"); return GST_VC1_PARSER_ERROR; } static GstVC1ParserResult parse_frame_header_advanced (GstBitReader * br, GstVC1FrameHdr * framehdr, GstVC1SeqHdr * seqhdr, GstVC1BitPlanes * bitplanes, gboolean field2) { GstVC1AdvancedSeqHdr *advhdr = &seqhdr->advanced; GstVC1PicAdvanced *pic = &framehdr->pic.advanced; GstVC1EntryPointHdr *entrypthdr = &advhdr->entrypoint; guint8 mvmodeidx; GST_DEBUG ("Parsing Frame header advanced %u", advhdr->interlace); /* Set the conveninence fields */ framehdr->profile = seqhdr->profile; framehdr->dquant = entrypthdr->dquant; if (advhdr->interlace) { gint8 fcm = decode012 (br); if (fcm < 0) goto failed; pic->fcm = (guint8) fcm; } else pic->fcm = GST_VC1_FRAME_PROGRESSIVE; if (pic->fcm == GST_VC1_FIELD_INTERLACE) { READ_UINT8 (br, pic->fptype, 3); if (field2) { switch (pic->fptype) { case 0x00: case 0x02: framehdr->ptype = GST_VC1_PICTURE_TYPE_I; break; case 0x01: case 0x03: framehdr->ptype = GST_VC1_PICTURE_TYPE_P; break; case 0x04: case 0x06: framehdr->ptype = GST_VC1_PICTURE_TYPE_B; break; case 0x05: case 0x07: framehdr->ptype = GST_VC1_PICTURE_TYPE_BI; break; } } else { switch (pic->fptype) { case 0x00: case 0x01: framehdr->ptype = GST_VC1_PICTURE_TYPE_I; break; case 0x02: case 0x03: framehdr->ptype = GST_VC1_PICTURE_TYPE_P; break; case 0x04: case 0x05: framehdr->ptype = GST_VC1_PICTURE_TYPE_B; break; case 0x06: case 0x07: framehdr->ptype = GST_VC1_PICTURE_TYPE_BI; break; } } } else framehdr->ptype = (guint8) get_unary (br, 0, 4); if (advhdr->tfcntrflag) { READ_UINT8 (br, pic->tfcntr, 8); GST_DEBUG ("tfcntr %u", pic->tfcntr); } if (advhdr->pulldown) { if (!advhdr->interlace || advhdr->psf) { READ_UINT8 (br, pic->rptfrm, 2); GST_DEBUG ("rptfrm %u", pic->rptfrm); } else { READ_UINT8 (br, pic->tff, 1); READ_UINT8 (br, pic->rff, 1); GST_DEBUG ("tff %u, rff %u", pic->tff, pic->rff); } } if (entrypthdr->panscan_flag) { READ_UINT8 (br, pic->ps_present, 1); if (pic->ps_present) { guint i, nb_pan_scan_win = calculate_nb_pan_scan_win (advhdr, pic); if (gst_bit_reader_get_remaining (br) < 64 * nb_pan_scan_win) goto failed; for (i = 0; i < nb_pan_scan_win; i++) { pic->ps_hoffset = gst_bit_reader_get_bits_uint32_unchecked (br, 18); pic->ps_voffset = gst_bit_reader_get_bits_uint32_unchecked (br, 18); pic->ps_width = gst_bit_reader_get_bits_uint16_unchecked (br, 14); pic->ps_height = gst_bit_reader_get_bits_uint16_unchecked (br, 14); } } } if (framehdr->ptype == GST_VC1_PICTURE_TYPE_SKIPPED) return GST_VC1_PARSER_OK; READ_UINT8 (br, pic->rndctrl, 1); if (advhdr->interlace) { READ_UINT8 (br, pic->uvsamp, 1); GST_DEBUG ("uvsamp %u", pic->uvsamp); if (pic->fcm == GST_VC1_FIELD_INTERLACE && entrypthdr->refdist_flag && pic->fptype < 4) decode_refdist (br, &pic->refdist); else pic->refdist = 0; } if (advhdr->finterpflag) { READ_UINT8 (br, framehdr->interpfrm, 1); GST_DEBUG ("interpfrm %u", framehdr->interpfrm); } if ((pic->fcm != GST_VC1_FIELD_INTERLACE && framehdr->ptype == GST_VC1_PICTURE_TYPE_B) || (pic->fcm == GST_VC1_FIELD_INTERLACE && (pic->fptype > 4))) { guint bfraction; if (!decode_vlc (br, &bfraction, vc1_bfraction_vlc_table, G_N_ELEMENTS (vc1_bfraction_vlc_table))) goto failed; pic->bfraction = bfraction; GST_DEBUG ("bfraction %u", pic->bfraction); if (pic->bfraction == GST_VC1_BFRACTION_PTYPE_BI) { framehdr->ptype = GST_VC1_PICTURE_TYPE_BI; } } READ_UINT8 (br, framehdr->pqindex, 5); if (!framehdr->pqindex) goto failed; /* compute pquant */ if (entrypthdr->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) framehdr->pquant = vc1_pquant_table[0][framehdr->pqindex]; else framehdr->pquant = vc1_pquant_table[1][framehdr->pqindex]; framehdr->pquantizer = 1; if (entrypthdr->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) framehdr->pquantizer = framehdr->pqindex < 9; if (entrypthdr->quantizer == GST_VC1_QUANTIZER_NON_UNIFORM) framehdr->pquantizer = 0; if (framehdr->pqindex <= 8) READ_UINT8 (br, framehdr->halfqp, 1); else framehdr->halfqp = 0; if (entrypthdr->quantizer == GST_VC1_QUANTIZER_EXPLICITLY) { READ_UINT8 (br, framehdr->pquantizer, 1); } if (advhdr->postprocflag) READ_UINT8 (br, pic->postproc, 2); GST_DEBUG ("Parsing %u picture, pqindex %u, pquant %u pquantizer %u" "halfqp %u", framehdr->ptype, framehdr->pqindex, framehdr->pquant, framehdr->pquantizer, framehdr->halfqp); switch (framehdr->ptype) { case GST_VC1_PICTURE_TYPE_I: case GST_VC1_PICTURE_TYPE_BI: if (pic->fcm == GST_VC1_FRAME_INTERLACE) { if (!bitplane_decoding (br, bitplanes ? bitplanes->fieldtx : NULL, seqhdr, &pic->fieldtx)) goto failed; } if (!bitplane_decoding (br, bitplanes ? bitplanes->acpred : NULL, seqhdr, &pic->acpred)) goto failed; if (entrypthdr->overlap && framehdr->pquant <= 8) { pic->condover = decode012 (br); if (pic->condover == (guint8) - 1) goto failed; else if (pic->condover == GST_VC1_CONDOVER_SELECT) { if (!bitplane_decoding (br, bitplanes ? bitplanes->overflags : NULL, seqhdr, &pic->overflags)) goto failed; GST_DEBUG ("overflags %u", pic->overflags); } } framehdr->transacfrm = get_unary (br, 0, 2); pic->transacfrm2 = get_unary (br, 0, 2); READ_UINT8 (br, framehdr->transdctab, 1); if (framehdr->dquant) parse_vopdquant (br, framehdr, framehdr->dquant); GST_DEBUG ("acpred %u, condover %u, transacfrm %u, transacfrm2 %u, transdctab %u", pic->acpred, pic->condover, framehdr->transacfrm, pic->transacfrm2, framehdr->transdctab); break; case GST_VC1_PICTURE_TYPE_B: if (entrypthdr->extended_mv) pic->mvrange = get_unary (br, 0, 3); else pic->mvrange = 0; if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) { if (entrypthdr->extended_dmv) pic->dmvrange = get_unary (br, 0, 3); } if (pic->fcm == GST_VC1_FRAME_INTERLACE) READ_UINT8 (br, pic->intcomp, 1); else READ_UINT8 (br, pic->mvmode, 1); if (pic->fcm == GST_VC1_FIELD_INTERLACE) { if (!bitplane_decoding (br, bitplanes ? bitplanes->forwardmb : NULL, seqhdr, &pic->forwardmb)) goto failed; } else { if (!bitplane_decoding (br, bitplanes ? bitplanes->directmb : NULL, seqhdr, &pic->directmb)) goto failed; if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL, seqhdr, &pic->skipmb)) goto failed; } if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) { if (gst_bit_reader_get_remaining (br) < 7) goto failed; pic->mbmodetab = gst_bit_reader_get_bits_uint8_unchecked (br, 2); pic->imvtab = gst_bit_reader_get_bits_uint8_unchecked (br, 2); pic->icbptab = gst_bit_reader_get_bits_uint8_unchecked (br, 3); if (pic->fcm == GST_VC1_FRAME_INTERLACE) READ_UINT8 (br, pic->mvbptab2, 2); if (pic->fcm == GST_VC1_FRAME_INTERLACE || (pic->fcm == GST_VC1_FIELD_INTERLACE && pic->mvmode == GST_VC1_MVMODE_MIXED_MV)) READ_UINT8 (br, pic->mvbptab4, 2); } else { READ_UINT8 (br, pic->mvtab, 2); READ_UINT8 (br, pic->cbptab, 2); } if (framehdr->dquant) { parse_vopdquant (br, framehdr, framehdr->dquant); } if (entrypthdr->vstransform) { READ_UINT8 (br, pic->ttmbf, 1); if (pic->ttmbf) { READ_UINT8 (br, pic->ttfrm, 2); } } framehdr->transacfrm = get_unary (br, 0, 2); READ_UINT8 (br, framehdr->transdctab, 1); GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u," "cbptab %u directmb %u skipmb %u", framehdr->transacfrm, framehdr->transdctab, pic->mvmode, pic->mvtab, pic->cbptab, pic->directmb, pic->skipmb); break; case GST_VC1_PICTURE_TYPE_P: if (pic->fcm == GST_VC1_FIELD_INTERLACE) { READ_UINT8 (br, pic->numref, 1); if (pic->numref) READ_UINT8 (br, pic->reffield, 1); } if (entrypthdr->extended_mv) pic->mvrange = get_unary (br, 0, 3); else pic->mvrange = 0; if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) { if (entrypthdr->extended_dmv) pic->dmvrange = get_unary (br, 0, 3); } if (pic->fcm == GST_VC1_FRAME_INTERLACE) { READ_UINT8 (br, pic->mvswitch4, 1); READ_UINT8 (br, pic->intcomp, 1); if (pic->intcomp) { READ_UINT8 (br, pic->lumscale, 6); READ_UINT8 (br, pic->lumshift, 6); } } else { mvmodeidx = framehdr->pquant > 12; pic->mvmode = vc1_mvmode_table[mvmodeidx][get_unary (br, 1, 4)]; if (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP) { pic->mvmode2 = vc1_mvmode2_table[mvmodeidx][get_unary (br, 1, 3)]; if (pic->fcm == GST_VC1_FIELD_INTERLACE) pic->intcompfield = decode012 (br); READ_UINT8 (br, pic->lumscale, 6); READ_UINT8 (br, pic->lumshift, 6); GST_DEBUG ("lumscale %u lumshift %u", pic->lumscale, pic->lumshift); if (pic->fcm == GST_VC1_FIELD_INTERLACE && pic->intcompfield) { READ_UINT8 (br, pic->lumscale2, 6); READ_UINT8 (br, pic->lumshift2, 6); } } if (pic->fcm == GST_VC1_FRAME_PROGRESSIVE) { if (pic->mvmode == GST_VC1_MVMODE_MIXED_MV || (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP && pic->mvmode2 == GST_VC1_MVMODE_MIXED_MV)) { if (!bitplane_decoding (br, bitplanes ? bitplanes->mvtypemb : NULL, seqhdr, &pic->mvtypemb)) goto failed; GST_DEBUG ("mvtypemb %u", pic->mvtypemb); } } } if (pic->fcm != GST_VC1_FIELD_INTERLACE) { if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL, seqhdr, &pic->skipmb)) goto failed; } if (pic->fcm != GST_VC1_FRAME_PROGRESSIVE) { if (gst_bit_reader_get_remaining (br) < 7) goto failed; pic->mbmodetab = gst_bit_reader_get_bits_uint8_unchecked (br, 2); pic->imvtab = gst_bit_reader_get_bits_uint8_unchecked (br, 2); pic->icbptab = gst_bit_reader_get_bits_uint8_unchecked (br, 3); if (pic->fcm != GST_VC1_FIELD_INTERLACE) { READ_UINT8 (br, pic->mvbptab2, 2); if (pic->mvswitch4) READ_UINT8 (br, pic->mvbptab4, 2); } else if (pic->mvmode == GST_VC1_MVMODE_MIXED_MV) READ_UINT8 (br, pic->mvbptab4, 2); } else { if (gst_bit_reader_get_remaining (br) < 4) goto failed; pic->mvtab = gst_bit_reader_get_bits_uint8_unchecked (br, 2); pic->cbptab = gst_bit_reader_get_bits_uint8_unchecked (br, 2); } if (framehdr->dquant) { parse_vopdquant (br, framehdr, framehdr->dquant); } if (entrypthdr->vstransform) { READ_UINT8 (br, pic->ttmbf, 1); if (pic->ttmbf) { READ_UINT8 (br, pic->ttfrm, 2); } } framehdr->transacfrm = get_unary (br, 0, 2); READ_UINT8 (br, framehdr->transdctab, 1); GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u," "cbptab %u skipmb %u", framehdr->transacfrm, framehdr->transdctab, pic->mvmode, pic->mvtab, pic->cbptab, pic->skipmb); break; default: goto failed; break; } return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse frame header"); return GST_VC1_PARSER_ERROR; } static GstVC1ParserResult parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr, GstVC1SeqHdr * seqhdr, GstVC1BitPlanes * bitplanes) { guint8 mvmodeidx, tmp; GstVC1PicSimpleMain *pic = &framehdr->pic.simple; GstVC1SeqStructC *structc = &seqhdr->struct_c; GST_DEBUG ("Parsing frame header in simple or main mode"); /* Set the conveninence fields */ framehdr->profile = seqhdr->profile; framehdr->dquant = structc->dquant; framehdr->interpfrm = 0; if (structc->finterpflag) READ_UINT8 (br, framehdr->interpfrm, 1); READ_UINT8 (br, pic->frmcnt, 2); pic->rangeredfrm = 0; if (structc->rangered) { READ_UINT8 (br, pic->rangeredfrm, 1); } /* Figuring out the picture type */ READ_UINT8 (br, tmp, 1); framehdr->ptype = tmp; if (structc->maxbframes) { if (!framehdr->ptype) { READ_UINT8 (br, tmp, 1); if (tmp) framehdr->ptype = GST_VC1_PICTURE_TYPE_I; else framehdr->ptype = GST_VC1_PICTURE_TYPE_B; } else framehdr->ptype = GST_VC1_PICTURE_TYPE_P; } else { if (framehdr->ptype) framehdr->ptype = GST_VC1_PICTURE_TYPE_P; else framehdr->ptype = GST_VC1_PICTURE_TYPE_I; } if (framehdr->ptype == GST_VC1_PICTURE_TYPE_B) { guint bfraction; if (!decode_vlc (br, &bfraction, vc1_bfraction_vlc_table, G_N_ELEMENTS (vc1_bfraction_vlc_table))) goto failed; pic->bfraction = bfraction; GST_DEBUG ("bfraction %d", pic->bfraction); if (pic->bfraction == GST_VC1_BFRACTION_PTYPE_BI) { framehdr->ptype = GST_VC1_PICTURE_TYPE_BI; } } if (framehdr->ptype == GST_VC1_PICTURE_TYPE_I || framehdr->ptype == GST_VC1_PICTURE_TYPE_BI) READ_UINT8 (br, pic->bf, 7); READ_UINT8 (br, framehdr->pqindex, 5); if (!framehdr->pqindex) return GST_VC1_PARSER_ERROR; GST_DEBUG ("pqindex %u", framehdr->pqindex); /* compute pquant */ if (structc->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) framehdr->pquant = vc1_pquant_table[0][framehdr->pqindex]; else framehdr->pquant = vc1_pquant_table[1][framehdr->pqindex]; GST_DEBUG ("pquant %u", framehdr->pquant); if (framehdr->pqindex <= 8) READ_UINT8 (br, framehdr->halfqp, 1); else framehdr->halfqp = 0; /* Set pquantizer */ framehdr->pquantizer = 1; if (structc->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) framehdr->pquantizer = framehdr->pqindex < 9; else if (structc->quantizer == GST_VC1_QUANTIZER_NON_UNIFORM) framehdr->pquantizer = 0; if (structc->quantizer == GST_VC1_QUANTIZER_EXPLICITLY) READ_UINT8 (br, framehdr->pquantizer, 1); if (structc->extended_mv == 1) { pic->mvrange = get_unary (br, 0, 3); GST_DEBUG ("mvrange %u", pic->mvrange); } if (structc->multires && (framehdr->ptype == GST_VC1_PICTURE_TYPE_P || framehdr->ptype == GST_VC1_PICTURE_TYPE_I)) { READ_UINT8 (br, pic->respic, 2); GST_DEBUG ("Respic %u", pic->respic); } GST_DEBUG ("Parsing %u Frame, pquantizer %u, halfqp %u, rangeredfrm %u, " "interpfrm %u", framehdr->ptype, framehdr->pquantizer, framehdr->halfqp, pic->rangeredfrm, framehdr->interpfrm); switch (framehdr->ptype) { case GST_VC1_PICTURE_TYPE_I: case GST_VC1_PICTURE_TYPE_BI: framehdr->transacfrm = get_unary (br, 0, 2); pic->transacfrm2 = get_unary (br, 0, 2); READ_UINT8 (br, framehdr->transdctab, 1); GST_DEBUG ("transacfrm %u, transacfrm2 %u, transdctab %u", framehdr->transacfrm, pic->transacfrm2, framehdr->transdctab); break; case GST_VC1_PICTURE_TYPE_P: mvmodeidx = framehdr->pquant > 12; pic->mvmode = vc1_mvmode_table[mvmodeidx][get_unary (br, 1, 4)]; if (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP) { pic->mvmode2 = vc1_mvmode2_table[mvmodeidx][get_unary (br, 1, 3)]; READ_UINT8 (br, pic->lumscale, 6); READ_UINT8 (br, pic->lumshift, 6); GST_DEBUG ("lumscale %u lumshift %u", pic->lumscale, pic->lumshift); } if (pic->mvmode == GST_VC1_MVMODE_MIXED_MV || (pic->mvmode == GST_VC1_MVMODE_INTENSITY_COMP && pic->mvmode2 == GST_VC1_MVMODE_MIXED_MV)) { if (!bitplane_decoding (br, bitplanes ? bitplanes->mvtypemb : NULL, seqhdr, &pic->mvtypemb)) goto failed; GST_DEBUG ("mvtypemb %u", pic->mvtypemb); } if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL, seqhdr, &pic->skipmb)) goto failed; READ_UINT8 (br, pic->mvtab, 2); READ_UINT8 (br, pic->cbptab, 2); if (framehdr->dquant) { parse_vopdquant (br, framehdr, framehdr->dquant); } if (structc->vstransform) { READ_UINT8 (br, pic->ttmbf, 1); GST_DEBUG ("ttmbf %u", pic->ttmbf); if (pic->ttmbf) { READ_UINT8 (br, pic->ttfrm, 2); GST_DEBUG ("ttfrm %u", pic->ttfrm); } } framehdr->transacfrm = get_unary (br, 0, 2); READ_UINT8 (br, framehdr->transdctab, 1); GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u," "cbptab %u skipmb %u", framehdr->transacfrm, framehdr->transdctab, pic->mvmode, pic->mvtab, pic->cbptab, pic->skipmb); break; case GST_VC1_PICTURE_TYPE_B: READ_UINT8 (br, pic->mvmode, 1); if (!bitplane_decoding (br, bitplanes ? bitplanes->directmb : NULL, seqhdr, &pic->directmb)) goto failed; if (!bitplane_decoding (br, bitplanes ? bitplanes->skipmb : NULL, seqhdr, &pic->skipmb)) goto failed; READ_UINT8 (br, pic->mvtab, 2); READ_UINT8 (br, pic->cbptab, 2); if (framehdr->dquant) parse_vopdquant (br, framehdr, framehdr->dquant); if (structc->vstransform) { READ_UINT8 (br, pic->ttmbf, 1); if (pic->ttmbf) { READ_UINT8 (br, pic->ttfrm, 2); } } framehdr->transacfrm = get_unary (br, 0, 2); READ_UINT8 (br, framehdr->transdctab, 1); GST_DEBUG ("transacfrm %u transdctab %u mvmode %u mvtab %u," "cbptab %u directmb %u skipmb %u", framehdr->transacfrm, framehdr->transdctab, pic->mvmode, pic->mvtab, pic->cbptab, pic->directmb, pic->skipmb); break; default: goto failed; break; } return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse Simple picture header"); return GST_VC1_PARSER_ERROR; } static GstVC1ParserResult parse_sequence_header_struct_a (GstBitReader * br, GstVC1SeqStructA * structa) { if (gst_bit_reader_get_remaining (br) < 64) { GST_WARNING ("Failed to parse struct A"); return GST_VC1_PARSER_ERROR; } structa->vert_size = gst_bit_reader_get_bits_uint32_unchecked (br, 32); structa->horiz_size = gst_bit_reader_get_bits_uint32_unchecked (br, 32); return GST_VC1_PARSER_OK; } static GstVC1ParserResult parse_sequence_header_struct_b (GstBitReader * br, GstVC1SeqStructB * structb) { if (gst_bit_reader_get_remaining (br) < 96) { GST_WARNING ("Failed to parse sequence header"); return GST_VC1_PARSER_ERROR; } structb->level = gst_bit_reader_get_bits_uint8_unchecked (br, 3); structb->cbr = gst_bit_reader_get_bits_uint8_unchecked (br, 1); /* res4 */ gst_bit_reader_skip_unchecked (br, 4); structb->hrd_buffer = gst_bit_reader_get_bits_uint32_unchecked (br, 24); structb->hrd_rate = gst_bit_reader_get_bits_uint32_unchecked (br, 32); structb->framerate = gst_bit_reader_get_bits_uint32_unchecked (br, 32); return GST_VC1_PARSER_OK; } static GstVC1ParserResult parse_sequence_header_struct_c (GstBitReader * br, GstVC1SeqStructC * structc) { guint8 old_interlaced_mode, tmp; READ_UINT8 (br, tmp, 2); structc->profile = tmp; if (structc->profile == GST_VC1_PROFILE_ADVANCED) return GST_VC1_PARSER_OK; GST_DEBUG ("Parsing sequence header in simple or main mode"); if (gst_bit_reader_get_remaining (br) < 29) goto failed; /* Reserved bits */ old_interlaced_mode = gst_bit_reader_get_bits_uint8_unchecked (br, 1); if (old_interlaced_mode) GST_WARNING ("Old interlaced mode used"); structc->wmvp = gst_bit_reader_get_bits_uint8_unchecked (br, 1); if (structc->wmvp) GST_DEBUG ("WMVP mode"); structc->frmrtq_postproc = gst_bit_reader_get_bits_uint8_unchecked (br, 3); structc->bitrtq_postproc = gst_bit_reader_get_bits_uint8_unchecked (br, 5); structc->loop_filter = gst_bit_reader_get_bits_uint8_unchecked (br, 1); calculate_framerate_bitrate (structc->frmrtq_postproc, structc->bitrtq_postproc, &structc->framerate, &structc->bitrate); /* Skipping reserved3 bit */ gst_bit_reader_skip_unchecked (br, 1); structc->multires = gst_bit_reader_get_bits_uint8_unchecked (br, 1); /* Skipping reserved4 bit */ gst_bit_reader_skip_unchecked (br, 1); structc->fastuvmc = gst_bit_reader_get_bits_uint8_unchecked (br, 1); structc->extended_mv = gst_bit_reader_get_bits_uint8_unchecked (br, 1); structc->dquant = gst_bit_reader_get_bits_uint8_unchecked (br, 2); structc->vstransform = gst_bit_reader_get_bits_uint8_unchecked (br, 1); /* Skipping reserved5 bit */ gst_bit_reader_skip_unchecked (br, 1); structc->overlap = gst_bit_reader_get_bits_uint8_unchecked (br, 1); structc->syncmarker = gst_bit_reader_get_bits_uint8_unchecked (br, 1); structc->rangered = gst_bit_reader_get_bits_uint8_unchecked (br, 1); structc->maxbframes = gst_bit_reader_get_bits_uint8_unchecked (br, 3); structc->quantizer = gst_bit_reader_get_bits_uint8_unchecked (br, 2); structc->finterpflag = gst_bit_reader_get_bits_uint8_unchecked (br, 1); GST_DEBUG ("frmrtq_postproc %u, bitrtq_postproc %u, loop_filter %u, " "multires %u, fastuvmc %u, extended_mv %u, dquant %u, vstransform %u, " "overlap %u, syncmarker %u, rangered %u, maxbframes %u, quantizer %u, " "finterpflag %u", structc->frmrtq_postproc, structc->bitrtq_postproc, structc->loop_filter, structc->multires, structc->fastuvmc, structc->extended_mv, structc->dquant, structc->vstransform, structc->overlap, structc->syncmarker, structc->rangered, structc->maxbframes, structc->quantizer, structc->finterpflag); if (structc->wmvp) { if (gst_bit_reader_get_remaining (br) < 29) goto failed; structc->coded_width = gst_bit_reader_get_bits_uint16_unchecked (br, 11); structc->coded_height = gst_bit_reader_get_bits_uint16_unchecked (br, 11); structc->framerate = gst_bit_reader_get_bits_uint8_unchecked (br, 5); gst_bit_reader_skip_unchecked (br, 1); structc->slice_code = gst_bit_reader_get_bits_uint8_unchecked (br, 1); GST_DEBUG ("coded_width %u, coded_height %u, framerate %u slice_code %u", structc->coded_width, structc->coded_height, structc->framerate, structc->slice_code); } return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to struct C"); return GST_VC1_PARSER_ERROR; } /**** API ****/ /** * gst_vc1_identify_next_bdu: * @data: The data to parse * @size: the size of @data * @bdu: (out): The #GstVC1BDU where to store parsed bdu headers * * Parses @data and fills @bdu fields * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_identify_next_bdu (const guint8 * data, gsize size, GstVC1BDU * bdu) { gint off1, off2; g_return_val_if_fail (bdu != NULL, GST_VC1_PARSER_ERROR); if (size < 4) { GST_DEBUG ("Can't parse, buffer has too small size %" G_GSIZE_FORMAT, size); return GST_VC1_PARSER_ERROR; } off1 = scan_for_start_codes (data, size); if (off1 < 0) { GST_DEBUG ("No start code prefix in this buffer"); return GST_VC1_PARSER_NO_BDU; } bdu->sc_offset = off1; bdu->offset = off1 + 4; bdu->data = (guint8 *) data; bdu->type = (GstVC1StartCode) (data[bdu->offset - 1]); if (bdu->type == GST_VC1_END_OF_SEQ) { GST_DEBUG ("End-of-Seq BDU found"); bdu->size = 0; return GST_VC1_PARSER_OK; } off2 = scan_for_start_codes (data + bdu->offset, size - bdu->offset); if (off2 < 0) { GST_DEBUG ("Bdu start %d, No end found", bdu->offset); return GST_VC1_PARSER_NO_BDU_END; } if (off2 > 0 && data[bdu->offset + off2 - 1] == 00) off2--; bdu->size = off2; GST_DEBUG ("Complete bdu found. Off: %d, Size: %d", bdu->offset, bdu->size); return GST_VC1_PARSER_OK; } /** * gst_vc1_parse_sequence_layer: * @data: The data to parse * @size: the size of @data * @seqlayer: The #GstVC1SeqLayer to set. * * Parses @data, and fills @seqlayer fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_sequence_layer (const guint8 * data, gsize size, GstVC1SeqLayer * seqlayer) { guint32 tmp; guint8 tmp8; guint8 structA[8] = { 0, }; guint8 structB[12] = { 0, }; GstBitReader br; GstByteReader byter = GST_BYTE_READER_INIT (data, size); GstByteWriter bytew; g_return_val_if_fail (seqlayer != NULL, GST_VC1_PARSER_ERROR); /* Thanks to the specification, structA and structB fields are defined * as unisgned integer msb first. * But in sequence-layer there are serialized in little-endian byte order, * so we must take care of their endianness before using bit reader */ if (!gst_byte_reader_get_uint24_le (&byter, &seqlayer->numframes)) goto failed; if (!gst_byte_reader_get_uint8 (&byter, &tmp8)) goto failed; if (tmp8 != 0xC5) goto failed; /* 0x00000004 */ if (!gst_byte_reader_get_uint32_le (&byter, &tmp)) goto failed; if (tmp != 0x04) goto failed; /* As an exception, structC is serialized in big-endian byte order so * no endianness issue here but we should at least have 4 bytes */ if (gst_byte_reader_get_remaining (&byter) < 4) goto failed; gst_bit_reader_init (&br, data + gst_byte_reader_get_pos (&byter), 4); if (parse_sequence_header_struct_c (&br, &seqlayer->struct_c) == GST_VC1_PARSER_ERROR) goto failed; gst_byte_reader_skip (&byter, 4); /* structA */ gst_byte_writer_init_with_data (&bytew, structA, 8, TRUE); gst_byte_reader_get_uint32_le (&byter, &tmp); gst_byte_writer_put_uint32_be (&bytew, tmp); gst_byte_reader_get_uint32_le (&byter, &tmp); gst_byte_writer_put_uint32_be (&bytew, tmp); gst_bit_reader_init (&br, structA, 8); if (parse_sequence_header_struct_a (&br, &seqlayer->struct_a) == GST_VC1_PARSER_ERROR) goto failed; /* 0x0000000C */ if (!gst_byte_reader_get_uint32_le (&byter, &tmp)) goto failed; if (tmp != 0x0C) goto failed; /* structB */ gst_byte_writer_reset (&bytew); gst_byte_writer_init_with_data (&bytew, structB, 12, TRUE); gst_byte_reader_get_uint32_le (&byter, &tmp); gst_byte_writer_put_uint32_be (&bytew, tmp); gst_byte_reader_get_uint32_le (&byter, &tmp); gst_byte_writer_put_uint32_be (&bytew, tmp); gst_byte_reader_get_uint32_le (&byter, &tmp); gst_byte_writer_put_uint32_be (&bytew, tmp); gst_bit_reader_init (&br, structB, 12); if (parse_sequence_header_struct_b (&br, &seqlayer->struct_b) == GST_VC1_PARSER_ERROR) goto failed; return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse sequence layer"); return GST_VC1_PARSER_ERROR; } /** * gst_vc1_parse_sequence_header_struct_a: * @data: The data to parse * @size: the size of @data * @structa: The #GstVC1SeqStructA to set. * * Parses @data, and fills @structa fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_sequence_header_struct_a (const guint8 * data, gsize size, GstVC1SeqStructA * structa) { GstBitReader br = GST_BIT_READER_INIT (data, size); g_return_val_if_fail (structa != NULL, GST_VC1_PARSER_ERROR); return parse_sequence_header_struct_a (&br, structa); } /** * gst_vc1_parse_sequence_header_struct_b: * @data: The data to parse * @size: the size of @data * @structb: The #GstVC1SeqStructB to set. * * Parses @data, and fills @structb fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_sequence_header_struct_b (const guint8 * data, gsize size, GstVC1SeqStructB * structb) { GstBitReader br = GST_BIT_READER_INIT (data, size); g_return_val_if_fail (structb != NULL, GST_VC1_PARSER_ERROR); return parse_sequence_header_struct_b (&br, structb); } /** * gst_vc1_parse_sequence_header_struct_c: * @data: The data to parse * @size: the size of @data * @structc: The #GstVC1SeqStructC to set. * * Parses @data, and fills @structc fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_sequence_header_struct_c (const guint8 * data, gsize size, GstVC1SeqStructC * structc) { GstBitReader br = GST_BIT_READER_INIT (data, size); g_return_val_if_fail (structc != NULL, GST_VC1_PARSER_ERROR); return parse_sequence_header_struct_c (&br, structc); } /** * gst_vc1_parse_sequence_header: * @data: The data to parse * @size: the size of @data * @seqhdr: The #GstVC1SeqHdr to set. * * Parses @data, and fills @seqhdr fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_sequence_header (const guint8 * data, gsize size, GstVC1SeqHdr * seqhdr) { GstBitReader br = GST_BIT_READER_INIT (data, size); g_return_val_if_fail (seqhdr != NULL, GST_VC1_PARSER_ERROR); if (parse_sequence_header_struct_c (&br, &seqhdr->struct_c) == GST_VC1_PARSER_ERROR) goto failed; /* Convenience field */ seqhdr->profile = seqhdr->struct_c.profile; if (seqhdr->profile == GST_VC1_PROFILE_ADVANCED) return parse_sequence_header_advanced (seqhdr, &br); /* Compute MB height and width */ calculate_mb_size (seqhdr, seqhdr->struct_c.coded_width, seqhdr->struct_c.coded_height); return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse sequence header"); return GST_VC1_PARSER_ERROR; } /** * gst_vc1_parse_entry_point_header: * @data: The data to parse * @size: the size of @data * @entrypoint: (out): The #GstVC1EntryPointHdr to set. * @seqhdr: The #GstVC1SeqHdr currently being parsed * * Parses @data, and sets @entrypoint fields. * * Returns: a #GstVC1EntryPointHdr */ GstVC1ParserResult gst_vc1_parse_entry_point_header (const guint8 * data, gsize size, GstVC1EntryPointHdr * entrypoint, GstVC1SeqHdr * seqhdr) { GstBitReader br; guint8 i; GstVC1AdvancedSeqHdr *advanced = &seqhdr->advanced; g_return_val_if_fail (entrypoint != NULL, GST_VC1_PARSER_ERROR); gst_bit_reader_init (&br, data, size); if (gst_bit_reader_get_remaining (&br) < 13) goto failed; entrypoint->broken_link = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->closed_entry = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->panscan_flag = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->refdist_flag = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->loopfilter = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->fastuvmc = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->extended_mv = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->dquant = gst_bit_reader_get_bits_uint8_unchecked (&br, 2); entrypoint->vstransform = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->overlap = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); entrypoint->quantizer = gst_bit_reader_get_bits_uint8_unchecked (&br, 2); if (advanced->hrd_param_flag) { if (seqhdr->advanced.hrd_param.hrd_num_leaky_buckets > MAX_HRD_NUM_LEAKY_BUCKETS) { GST_WARNING ("hrd_num_leaky_buckets (%d) > MAX_HRD_NUM_LEAKY_BUCKETS (%d)", seqhdr->advanced.hrd_param.hrd_num_leaky_buckets, MAX_HRD_NUM_LEAKY_BUCKETS); goto failed; } for (i = 0; i < seqhdr->advanced.hrd_param.hrd_num_leaky_buckets; i++) READ_UINT8 (&br, entrypoint->hrd_full[i], 8); } READ_UINT8 (&br, entrypoint->coded_size_flag, 1); if (entrypoint->coded_size_flag) { READ_UINT16 (&br, entrypoint->coded_width, 12); READ_UINT16 (&br, entrypoint->coded_height, 12); entrypoint->coded_height = (entrypoint->coded_height + 1) << 1; entrypoint->coded_width = (entrypoint->coded_width + 1) << 1; calculate_mb_size (seqhdr, entrypoint->coded_width, entrypoint->coded_height); } if (entrypoint->extended_mv) READ_UINT8 (&br, entrypoint->extended_dmv, 1); READ_UINT8 (&br, entrypoint->range_mapy_flag, 1); if (entrypoint->range_mapy_flag) READ_UINT8 (&br, entrypoint->range_mapy, 3); READ_UINT8 (&br, entrypoint->range_mapuv_flag, 1); if (entrypoint->range_mapy_flag) READ_UINT8 (&br, entrypoint->range_mapuv, 3); advanced->entrypoint = *entrypoint; return GST_VC1_PARSER_OK; failed: GST_WARNING ("Failed to parse entry point header"); return GST_VC1_PARSER_ERROR; } /** * gst_vc1_parse_frame_layer: * @data: The data to parse * @size: the size of @data * @framelayer: The #GstVC1FrameLayer to fill. * * Parses @data, and fills @framelayer fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_frame_layer (const guint8 * data, gsize size, GstVC1FrameLayer * framelayer) { GstBitReader br = GST_BIT_READER_INIT (data, size); if (gst_bit_reader_get_remaining (&br) < 64) { GST_WARNING ("Could not parse frame layer"); return GST_VC1_PARSER_ERROR; } /* set default values */ framelayer->skiped_p_frame = 0; framelayer->key = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); gst_bit_reader_skip_unchecked (&br, 7); framelayer->framesize = gst_bit_reader_get_bits_uint32_unchecked (&br, 24); if (framelayer->framesize == 0 || framelayer->framesize == 1) framelayer->skiped_p_frame = 1; /* compute next_framelayer_offset */ framelayer->next_framelayer_offset = framelayer->framesize + 8; framelayer->timestamp = gst_bit_reader_get_bits_uint32_unchecked (&br, 32); return GST_VC1_PARSER_OK; } /** * gst_vc1_parse_frame_header: * @data: The data to parse * @size: the size of @data * @framehdr: The #GstVC1FrameHdr to fill. * @seqhdr: The #GstVC1SeqHdr currently being parsed * @bitplanes: The #GstVC1BitPlanes to store bitplanes in or %NULL * * Parses @data, and fills @entrypoint fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_frame_header (const guint8 * data, gsize size, GstVC1FrameHdr * framehdr, GstVC1SeqHdr * seqhdr, GstVC1BitPlanes * bitplanes) { GstBitReader br; GstVC1ParserResult result; gst_bit_reader_init (&br, data, size); if (seqhdr->profile == GST_VC1_PROFILE_ADVANCED) result = parse_frame_header_advanced (&br, framehdr, seqhdr, bitplanes, FALSE); else result = parse_frame_header (&br, framehdr, seqhdr, bitplanes); framehdr->header_size = gst_bit_reader_get_pos (&br); return result; } /** * gst_vc1_parse_field_header: * @data: The data to parse * @size: the size of @data * @fieldhdr: The #GstVC1FrameHdr to fill. * @seqhdr: The #GstVC1SeqHdr currently being parsed * @bitplanes: The #GstVC1BitPlanes to store bitplanes in or %NULL * * Parses @data, and fills @fieldhdr fields. * * Returns: a #GstVC1ParserResult */ GstVC1ParserResult gst_vc1_parse_field_header (const guint8 * data, gsize size, GstVC1FrameHdr * fieldhdr, GstVC1SeqHdr * seqhdr, GstVC1BitPlanes * bitplanes) { GstBitReader br; GstVC1ParserResult result; gst_bit_reader_init (&br, data, size); result = parse_frame_header_advanced (&br, fieldhdr, seqhdr, bitplanes, TRUE); return result; } /** * gst_vc1_parse_slice_header: * @data: The data to parse * @size: The size of @data * @slicehdr: The #GstVC1SliceHdr to fill * @seqhdr: The #GstVC1SeqHdr that was previously parsed * * Parses @data, and fills @slicehdr fields. * * Returns: a #GstVC1ParserResult * * Since: 1.2 */ GstVC1ParserResult gst_vc1_parse_slice_header (const guint8 * data, gsize size, GstVC1SliceHdr * slicehdr, GstVC1SeqHdr * seqhdr) { GstBitReader br; GstVC1FrameHdr framehdr; GstVC1ParserResult result; guint8 pic_header_flag; GST_DEBUG ("Parsing slice header"); if (seqhdr->profile != GST_VC1_PROFILE_ADVANCED) return GST_VC1_PARSER_BROKEN_DATA; gst_bit_reader_init (&br, data, size); READ_UINT16 (&br, slicehdr->slice_addr, 9); READ_UINT8 (&br, pic_header_flag, 1); if (pic_header_flag) result = parse_frame_header_advanced (&br, &framehdr, seqhdr, NULL, FALSE); else result = GST_VC1_PARSER_OK; slicehdr->header_size = gst_bit_reader_get_pos (&br); return result; failed: GST_WARNING ("Failed to parse slice header"); return GST_VC1_PARSER_ERROR; } /** * gst_vc1_bitplanes_new: * * Creates a new #GstVC1BitPlanes. It should be freed with * gst_vc1_bitplanes_free() after use. * * Returns: a new #GstVC1BitPlanes */ GstVC1BitPlanes * gst_vc1_bitplanes_new (void) { return g_slice_new0 (GstVC1BitPlanes); } /** * gst_vc1_bitplane_free: * @bitplanes: the #GstVC1BitPlanes to free * * Frees @bitplanes. */ void gst_vc1_bitplanes_free (GstVC1BitPlanes * bitplanes) { gst_vc1_bitplanes_free_1 (bitplanes); g_slice_free (GstVC1BitPlanes, bitplanes); } /** * gst_vc1_bitplane_free_1: * @bitplanes: The #GstVC1BitPlanes to free * * Frees @bitplanes fields. */ void gst_vc1_bitplanes_free_1 (GstVC1BitPlanes * bitplanes) { g_free (bitplanes->acpred); g_free (bitplanes->fieldtx); g_free (bitplanes->overflags); g_free (bitplanes->mvtypemb); g_free (bitplanes->skipmb); g_free (bitplanes->directmb); g_free (bitplanes->forwardmb); } /** * gst_vc1_bitplanes_ensure_size: * @bitplanes: The #GstVC1BitPlanes to reset * @seqhdr: The #GstVC1SeqHdr from which to set @bitplanes * * Fills the @bitplanes structure from @seqhdr, this function * should be called after #gst_vc1_parse_sequence_header if * in simple or main mode, or after #gst_vc1_parse_entry_point_header * if in advanced mode. * * Returns: %TRUE if everything went fine, %FALSE otherwize */ gboolean gst_vc1_bitplanes_ensure_size (GstVC1BitPlanes * bitplanes, GstVC1SeqHdr * seqhdr) { g_return_val_if_fail (bitplanes != NULL, FALSE); g_return_val_if_fail (seqhdr != NULL, FALSE); if (bitplanes->size) { bitplanes->size = seqhdr->mb_height * seqhdr->mb_stride; bitplanes->acpred = g_realloc_n (bitplanes->acpred, bitplanes->size, sizeof (guint8)); bitplanes->fieldtx = g_realloc_n (bitplanes->fieldtx, bitplanes->size, sizeof (guint8)); bitplanes->overflags = g_realloc_n (bitplanes->overflags, bitplanes->size, sizeof (guint8)); bitplanes->mvtypemb = g_realloc_n (bitplanes->mvtypemb, bitplanes->size, sizeof (guint8)); bitplanes->skipmb = g_realloc_n (bitplanes->skipmb, bitplanes->size, sizeof (guint8)); bitplanes->directmb = g_realloc_n (bitplanes->directmb, bitplanes->size, sizeof (guint8)); bitplanes->forwardmb = g_realloc_n (bitplanes->forwardmb, bitplanes->size, sizeof (guint8)); } else { bitplanes->size = seqhdr->mb_height * seqhdr->mb_stride; bitplanes->acpred = g_malloc0 (bitplanes->size * sizeof (guint8)); bitplanes->fieldtx = g_malloc0 (bitplanes->size * sizeof (guint8)); bitplanes->overflags = g_malloc0 (bitplanes->size * sizeof (guint8)); bitplanes->mvtypemb = g_malloc0 (bitplanes->size * sizeof (guint8)); bitplanes->skipmb = g_malloc0 (bitplanes->size * sizeof (guint8)); bitplanes->directmb = g_malloc0 (bitplanes->size * sizeof (guint8)); bitplanes->forwardmb = g_malloc0 (bitplanes->size * sizeof (guint8)); } return TRUE; }