From fc09e451084be59f27f843457982714a619f8ab4 Mon Sep 17 00:00:00 2001 From: Thibault Saunier Date: Wed, 5 Oct 2011 12:15:00 -0300 Subject: [PATCH] codecparsers: VC1: Implement Sequence Layer Data Structures Instead of having a single VC1SequenceHeader structure, use the 3 structs from the "Table 265: Sequence Layer Data Structure" of the specification for the library to be more flexible. Implement the functions to parse them --- docs/libs/gst-plugins-bad-libs-sections.txt | 9 +- gst-libs/gst/codecparsers/gstvc1parser.c | 438 ++++++++++++++------ gst-libs/gst/codecparsers/gstvc1parser.h | 141 +++++-- tests/check/libs/vc1parser.c | 164 ++++---- 4 files changed, 497 insertions(+), 255 deletions(-) diff --git a/docs/libs/gst-plugins-bad-libs-sections.txt b/docs/libs/gst-plugins-bad-libs-sections.txt index 3509f3648b..4b5e221eac 100644 --- a/docs/libs/gst-plugins-bad-libs-sections.txt +++ b/docs/libs/gst-plugins-bad-libs-sections.txt @@ -61,7 +61,10 @@ GstVC1Condover GstVC1MvMode GstVC1SeqHdr GstVC1AdvancedSeqHdr -GstVC1SimpleMainSeqHdr +GstVC1SeqLayer +GstVC1SeqStructA +GstVC1SeqStructB +GstVC1SeqStructC GstVC1HrdParam GstVC1EntryPointHdr GstVC1FrameHdr @@ -72,6 +75,10 @@ GstVC1VopDquant GstVC1BDU gst_vc1_identify_next_bdu gst_vc1_parse_sequence_header +gst_vc1_parse_sequence_layer +gst_vc1_parse_sequence_header_struct_a +gst_vc1_parse_sequence_header_struct_b +gst_vc1_parse_sequence_header_struct_c gst_vc1_parse_entry_point_header gst_vc1_parse_frame_header diff --git a/gst-libs/gst/codecparsers/gstvc1parser.c b/gst-libs/gst/codecparsers/gstvc1parser.c index 3e82ab56db..aad915d8b8 100644 --- a/gst-libs/gst/codecparsers/gstvc1parser.c +++ b/gst-libs/gst/codecparsers/gstvc1parser.c @@ -565,28 +565,28 @@ get_unary (GstBitReader * br, gint stop, gint len) } static inline void -calculate_framerate_bitrate (GstVC1SeqHdr * seqhdr) +calculate_framerate_bitrate (guint8 frmrtq_postproc, guint8 bitrtq_postproc, + guint * framerate, guint * bitrate) { - /* Calulate bitrate and framerate */ - if (seqhdr->frmrtq_postproc == 0 && seqhdr->bitrtq_postproc == 30) { - seqhdr->framerate = 0; - seqhdr->bitrate = 0; - } else if (seqhdr->frmrtq_postproc == 0 && seqhdr->bitrtq_postproc == 30) { - seqhdr->framerate = 2; - seqhdr->bitrate = 1952; - } else if (seqhdr->frmrtq_postproc == 0 && seqhdr->bitrtq_postproc == 31) { - seqhdr->framerate = 6; - seqhdr->bitrate = 2016; + if (frmrtq_postproc == 0 && bitrtq_postproc == 30) { + *framerate = 0; + *bitrate = 0; + } else if (frmrtq_postproc == 0 && bitrtq_postproc == 30) { + *framerate = 2; + *bitrate = 1952; + } else if (frmrtq_postproc == 0 && bitrtq_postproc == 31) { + *framerate = 6; + *bitrate = 2016; } else { - if (seqhdr->frmrtq_postproc == 7) { - seqhdr->framerate = 30; + if (frmrtq_postproc == 7) { + *framerate = 30; } else { - seqhdr->framerate = 2 + (seqhdr->frmrtq_postproc * 4); + *framerate = 2 + (frmrtq_postproc * 4); } - if (seqhdr->bitrtq_postproc == 31) { - seqhdr->bitrate = 2016; + if (bitrtq_postproc == 31) { + *bitrate = 2016; } else { - seqhdr->bitrate = 32 + (seqhdr->bitrtq_postproc * 64); + *bitrate = 32 + (bitrtq_postproc * 64); } } } @@ -630,20 +630,22 @@ failed: static GstVC1ParserResult parse_sequence_header_advanced (GstVC1SeqHdr * seqhdr, GstBitReader * br) { - GstVC1AdvancedSeqHdr *advanced = &seqhdr->profile.advanced; + GstVC1AdvancedSeqHdr *advanced = &seqhdr->advanced; GST_DEBUG ("Parsing sequence header in advanced mode"); READ_UINT8 (br, advanced->level, 3); - READ_UINT8 (br, seqhdr->colordiff_format, 2); - READ_UINT8 (br, seqhdr->frmrtq_postproc, 3); - READ_UINT8 (br, seqhdr->bitrtq_postproc, 5); - calculate_framerate_bitrate (seqhdr); + 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, seqhdr->colordiff_format, - seqhdr->frmrtq_postproc, seqhdr->bitrtq_postproc); + " bitrtq_postproc %u", advanced->level, advanced->colordiff_format, + advanced->frmrtq_postproc, advanced->bitrtq_postproc); if (gst_bit_reader_get_remaining (br) < 32) goto failed; @@ -659,13 +661,13 @@ parse_sequence_header_advanced (GstVC1SeqHdr * seqhdr, GstBitReader * br) 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); - seqhdr->finterpflag = 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, seqhdr->finterpflag); + advanced->interlace, advanced->tfcntrflag, advanced->finterpflag); /* Skipping reserved bit */ gst_bit_reader_skip_unchecked (br, 1); @@ -727,7 +729,7 @@ static GstVC1ParserResult parse_frame_header_advanced (GstBitReader * br, GstVC1FrameHdr * framehdr, GstVC1SeqHdr * seqhdr) { - GstVC1AdvancedSeqHdr *advhdr = &seqhdr->profile.advanced; + GstVC1AdvancedSeqHdr *advhdr = &seqhdr->advanced; GstVC1PicAdvanced *pic = &framehdr->pic.advanced; GstVC1EntryPointHdr *entrypthdr = &advhdr->entrypoint; guint8 mvmodeidx; @@ -737,7 +739,7 @@ parse_frame_header_advanced (GstBitReader * br, GstVC1FrameHdr * framehdr, GST_DEBUG ("Parsing Frame header advanced %u", advhdr->interlace); /* Set the conveninence fields */ - framehdr->profile = seqhdr->profiletype; + framehdr->profile = seqhdr->profile; framehdr->dquant = entrypthdr->dquant; if (advhdr->interlace) { @@ -798,7 +800,7 @@ parse_frame_header_advanced (GstBitReader * br, GstVC1FrameHdr * framehdr, GST_DEBUG ("uvsamp %u", pic->uvsamp); } - if (seqhdr->finterpflag) { + if (advhdr->finterpflag) { READ_UINT8 (br, framehdr->interpfrm, 1); GST_DEBUG ("interpfrm %u", framehdr->interpfrm); } @@ -988,31 +990,28 @@ parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr, { guint8 mvmodeidx; GstVC1PicSimpleMain *pic = &framehdr->pic.simple; - GstVC1SimpleMainSeqHdr *simplehdr = &seqhdr->profile.simplemain; - guint width = seqhdr->mb_width; - guint height = seqhdr->mb_height; - + GstVC1SeqStructC *structc = &seqhdr->struct_c; GST_DEBUG ("Parsing frame header in simple or main mode"); /* Set the conveninence fields */ - framehdr->profile = seqhdr->profiletype; - framehdr->dquant = simplehdr->dquant; + framehdr->profile = seqhdr->profile; + framehdr->dquant = structc->dquant; framehdr->interpfrm = 0; - if (seqhdr->finterpflag) + if (structc->finterpflag) READ_UINT8 (br, framehdr->interpfrm, 1); READ_UINT8 (br, pic->frmcnt, 2); pic->rangeredfrm = 0; - if (simplehdr->rangered) { + if (structc->rangered) { READ_UINT8 (br, pic->rangeredfrm, 2); } /* Figuring out the picture type */ READ_UINT8 (br, framehdr->ptype, 1); - if (simplehdr->maxbframes) { + if (structc->maxbframes) { if (!framehdr->ptype) { READ_UINT8 (br, framehdr->ptype, 1); @@ -1055,7 +1054,7 @@ parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr, GST_DEBUG ("pqindex %u", framehdr->pqindex); /* compute pquant */ - if (simplehdr->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) + if (structc->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) framehdr->pquant = vc1_pquant_table[0][framehdr->pqindex]; else framehdr->pquant = vc1_pquant_table[1][framehdr->pqindex]; @@ -1069,20 +1068,20 @@ parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr, /* Set pquantizer */ framehdr->pquantizer = 1; - if (simplehdr->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) + if (structc->quantizer == GST_VC1_QUANTIZER_IMPLICITLY) framehdr->pquantizer = framehdr->pqindex < 9; - else if (simplehdr->quantizer == GST_VC1_QUANTIZER_NON_UNIFORM) + else if (structc->quantizer == GST_VC1_QUANTIZER_NON_UNIFORM) framehdr->pquantizer = 0; - if (simplehdr->quantizer == GST_VC1_QUANTIZER_EXPLICITLY) + if (structc->quantizer == GST_VC1_QUANTIZER_EXPLICITLY) READ_UINT8 (br, framehdr->pquantizer, 1); - if (simplehdr->extended_mv == 1) { + if (structc->extended_mv == 1) { pic->mvrange = get_unary (br, 0, 3); GST_DEBUG ("mvrange %u", pic->mvrange); } - if (simplehdr->multires && (framehdr->ptype == GST_VC1_PICTURE_TYPE_P || + 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); @@ -1132,7 +1131,7 @@ parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr, parse_vopdquant (br, framehdr, framehdr->dquant); } - if (simplehdr->vstransform) { + if (structc->vstransform) { READ_UINT8 (br, pic->ttmbf, 1); GST_DEBUG ("ttmbf %u", pic->ttmbf); @@ -1163,7 +1162,7 @@ parse_frame_header (GstBitReader * br, GstVC1FrameHdr * framehdr, if (framehdr->dquant) parse_vopdquant (br, framehdr, framehdr->dquant); - if (simplehdr->vstransform) { + if (structc->vstransform) { READ_UINT8 (br, pic->ttmbf, 1); if (pic->ttmbf) { @@ -1190,6 +1189,130 @@ failed: 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: @@ -1230,7 +1353,7 @@ gst_vc1_identify_next_bdu (const guint8 * data, gsize size, GstVC1BDU * bdu) bdu->type = (GstVC1StartCode) (data[bdu->offset - 1]); if (bdu->type == GST_VC1_END_OF_SEQ) { - GST_DEBUG ("End-of-Sequence BDU found"); + GST_DEBUG ("End-of-Seq BDU found"); bdu->size = 0; return GST_VC1_PARSER_OK; } @@ -1252,10 +1375,135 @@ gst_vc1_identify_next_bdu (const guint8 * data, gsize size, GstVC1BDU * bdu) } /** - * gst_vc1_parse_sequence_header: + * gst_vc1_parse_sequence_layer: * @data: The data to parse * @size: the size of @data - * @seqhdr: The #GstVC1SeqHdr to set. + * @structa: 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; + GstBitReader br = GST_BIT_READER_INIT (data, size); + + g_return_val_if_fail (seqlayer != NULL, GST_VC1_PARSER_ERROR); + + ensure_debug_category (); + + READ_UINT32 (&br, tmp, 8); + if (tmp != 0xC5) + goto failed; + + READ_UINT32 (&br, seqlayer->numframes, 24); + + if (parse_sequence_header_struct_c (&br, &seqlayer->struct_c) == + GST_VC1_PARSER_ERROR) + goto failed; + + READ_UINT32 (&br, tmp, 32); + if (tmp != 0x04) + goto failed; + + if (parse_sequence_header_struct_a (&br, &seqlayer->struct_a) == + GST_VC1_PARSER_ERROR) + goto failed; + + READ_UINT32 (&br, tmp, 32); + if (tmp != 0x0C) + goto failed; + + 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); + + ensure_debug_category (); + + + 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 + * @structa: 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); + + ensure_debug_category (); + + 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); + + ensure_debug_category (); + + 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. * @@ -1265,92 +1513,25 @@ GstVC1ParserResult gst_vc1_parse_sequence_header (const guint8 * data, gsize size, GstVC1SeqHdr * seqhdr) { - GstBitReader br; - guint8 old_interlaced_mode; - GstVC1SimpleMainSeqHdr *simplehdr = &seqhdr->profile.simplemain; + GstBitReader br = GST_BIT_READER_INIT (data, size); g_return_val_if_fail (seqhdr != NULL, GST_VC1_PARSER_ERROR); ensure_debug_category (); - gst_bit_reader_init (&br, data, size); - - READ_UINT8 (&br, seqhdr->profiletype, 2); - - if (seqhdr->profiletype == GST_VC1_PROFILE_ADVANCED) { - return parse_sequence_header_advanced (seqhdr, &br); - } - - GST_DEBUG ("Parsing sequence header in simple or main mode"); - - if (gst_bit_reader_get_remaining (&br) < 29) + if (parse_sequence_header_struct_c (&br, &seqhdr->struct_c) == + GST_VC1_PARSER_ERROR) 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"); + /* Convenience field */ + seqhdr->profile = seqhdr->struct_c.profile; - simplehdr->wmvp = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - if (simplehdr->wmvp) - GST_DEBUG ("WMVP mode"); - - seqhdr->frmrtq_postproc = gst_bit_reader_get_bits_uint8_unchecked (&br, 3); - seqhdr->bitrtq_postproc = gst_bit_reader_get_bits_uint8_unchecked (&br, 5); - simplehdr->loop_filter = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - calculate_framerate_bitrate (seqhdr); - - /* Skipping reserved3 bit */ - gst_bit_reader_skip_unchecked (&br, 1); - - simplehdr->multires = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - - /* Skipping reserved4 bit */ - gst_bit_reader_skip_unchecked (&br, 1); - - simplehdr->fastuvmc = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - simplehdr->extended_mv = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - simplehdr->dquant = gst_bit_reader_get_bits_uint8_unchecked (&br, 2); - simplehdr->vstransform = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - - /* Skipping reserved5 bit */ - gst_bit_reader_skip_unchecked (&br, 1); - - simplehdr->overlap = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - simplehdr->syncmarker = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - simplehdr->rangered = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - simplehdr->maxbframes = gst_bit_reader_get_bits_uint8_unchecked (&br, 3); - simplehdr->quantizer = gst_bit_reader_get_bits_uint8_unchecked (&br, 2); - seqhdr->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", seqhdr->frmrtq_postproc, seqhdr->bitrtq_postproc, - simplehdr->loop_filter, simplehdr->multires, simplehdr->fastuvmc, - simplehdr->extended_mv, simplehdr->dquant, simplehdr->vstransform, - simplehdr->overlap, simplehdr->syncmarker, simplehdr->rangered, - simplehdr->maxbframes, simplehdr->quantizer, seqhdr->finterpflag); - - if (simplehdr->wmvp) { - if (gst_bit_reader_get_remaining (&br) < 29) - goto failed; - - simplehdr->coded_width = gst_bit_reader_get_bits_uint16_unchecked (&br, 11); - simplehdr->coded_height = - gst_bit_reader_get_bits_uint16_unchecked (&br, 11); - simplehdr->framerate = gst_bit_reader_get_bits_uint8_unchecked (&br, 5); - gst_bit_reader_skip_unchecked (&br, 1); - simplehdr->slice_code = gst_bit_reader_get_bits_uint8_unchecked (&br, 1); - - GST_DEBUG ("coded_width %u, coded_height %u, framerate %u slice_code %u", - simplehdr->coded_width, simplehdr->coded_height, simplehdr->framerate, - simplehdr->slice_code); - } + if (seqhdr->profile == GST_VC1_PROFILE_ADVANCED) + return parse_sequence_header_advanced (seqhdr, &br); /* compute height and width */ - seqhdr->mb_height = (simplehdr->coded_height + 15) >> 4; - seqhdr->mb_width = (simplehdr->coded_width + 15) >> 4; + seqhdr->mb_height = (seqhdr->struct_c.coded_height + 15) >> 4; + seqhdr->mb_width = (seqhdr->struct_c.coded_width + 15) >> 4; return GST_VC1_PARSER_OK; @@ -1377,7 +1558,7 @@ gst_vc1_parse_entry_point_header (const guint8 * data, gsize size, { GstBitReader br; guint8 i; - GstVC1AdvancedSeqHdr *advanced = &seqhdr->profile.advanced; + GstVC1AdvancedSeqHdr *advanced = &seqhdr->advanced; g_return_val_if_fail (entrypoint != NULL, GST_VC1_PARSER_ERROR); @@ -1401,8 +1582,7 @@ gst_vc1_parse_entry_point_header (const guint8 * data, gsize size, entrypoint->quantizer = gst_bit_reader_get_bits_uint8_unchecked (&br, 2); if (advanced->hrd_param_flag) { - for (i = 0; i < seqhdr->profile.advanced.hrd_param.hrd_num_leaky_buckets; - i++) + for (i = 0; i < seqhdr->advanced.hrd_param.hrd_num_leaky_buckets; i++) READ_UINT8 (&br, entrypoint->hrd_full[MAX_HRD_NUM_LEAKY_BUCKETS], 8); } @@ -1459,7 +1639,7 @@ gst_vc1_parse_frame_header (const guint8 * data, gsize size, gst_bit_reader_init (&br, data, size); - if (seqhdr->profiletype == GST_VC1_PROFILE_ADVANCED) + if (seqhdr->profile == GST_VC1_PROFILE_ADVANCED) result = parse_frame_header_advanced (&br, framehdr, seqhdr); else result = parse_frame_header (&br, framehdr, seqhdr); diff --git a/gst-libs/gst/codecparsers/gstvc1parser.h b/gst-libs/gst/codecparsers/gstvc1parser.h index aad83fa557..fd792649f8 100644 --- a/gst-libs/gst/codecparsers/gstvc1parser.h +++ b/gst-libs/gst/codecparsers/gstvc1parser.h @@ -129,10 +129,15 @@ typedef enum typedef struct _GstVC1SeqHdr GstVC1SeqHdr; typedef struct _GstVC1AdvancedSeqHdr GstVC1AdvancedSeqHdr; -typedef struct _GstVC1SimpleMainSeqHdr GstVC1SimpleMainSeqHdr; typedef struct _GstVC1HrdParam GstVC1HrdParam; typedef struct _GstVC1EntryPointHdr GstVC1EntryPointHdr; +typedef struct _GstVC1SeqLayer GstVC1SeqLayer; + +typedef struct _GstVC1SeqStructA GstVC1SeqStructA; +typedef struct _GstVC1SeqStructB GstVC1SeqStructB; +typedef struct _GstVC1SeqStructC GstVC1SeqStructC; + /* Pictures Structures */ typedef struct _GstVC1FrameHdr GstVC1FrameHdr; typedef struct _GstVC1PicAdvanced GstVC1PicAdvanced; @@ -152,37 +157,6 @@ struct _GstVC1HrdParam guint16 hrd_buffer[MAX_HRD_NUM_LEAKY_BUCKETS]; }; -/** - * GstVC1SimpleMainSeqHdr: - * - * Structure for simple and main profile sequence headers specific parameters. - */ -struct _GstVC1SimpleMainSeqHdr -{ - guint8 res_sprite; - guint8 loop_filter; - guint8 multires; - guint8 fastuvmc; - guint8 extended_mv; - guint8 dquant; - guint8 vstransform; - guint8 overlap; - guint8 syncmarker; - guint8 rangered; - guint8 maxbframes; - guint8 quantizer; - - /* This should be filled by user if previously known */ - guint16 coded_width; - /* This should be filled by user if previously known */ - guint16 coded_height; - - /* Wmvp specific */ - guint8 wmvp; /* Specify if the stream is wmp or not */ - guint8 framerate; - guint8 slice_code; -}; - /** * GstVC1EntryPointHdr: * @@ -221,12 +195,15 @@ struct _GstVC1EntryPointHdr struct _GstVC1AdvancedSeqHdr { guint8 level; + guint8 frmrtq_postproc; + guint8 bitrtq_postproc; guint8 postprocflag; guint16 max_coded_width; guint16 max_coded_height; guint8 pulldown; guint8 interlace; guint8 tfcntrflag; + guint8 finterpflag; guint8 psf; guint8 display_ext; guint16 disp_horiz_size; @@ -245,13 +222,80 @@ struct _GstVC1AdvancedSeqHdr guint8 transfer_char; guint8 matrix_coef; guint8 hrd_param_flag; + guint8 colordiff_format; GstVC1HrdParam hrd_param; + /* computed */ + guint framerate; /* Around in fps, 0 if unknown*/ + guint bitrate; /* Around in kpbs, 0 if unknown*/ + /* The last parsed entry point */ GstVC1EntryPointHdr entrypoint; }; +struct _GstVC1SeqStructA +{ + guint32 vert_size; + guint32 horiz_size; +}; + +struct _GstVC1SeqStructB +{ + guint8 level; + guint8 cbr; + guint32 framerate; + + /* In simple and main profiles only */ + guint32 hrd_buffer; + guint32 hrd_rate; +}; + +struct _GstVC1SeqStructC +{ + GstVC1Profile profile; + + /* Only in simple and main profiles */ + guint8 frmrtq_postproc; + guint8 bitrtq_postproc; + guint8 res_sprite; + guint8 loop_filter; + guint8 multires; + guint8 fastuvmc; + guint8 extended_mv; + guint8 dquant; + guint8 vstransform; + guint8 overlap; + guint8 syncmarker; + guint8 rangered; + guint8 maxbframes; + guint8 quantizer; + guint8 finterpflag; + + /* Computed */ + guint framerate; /* Around in fps, 0 if unknown*/ + guint bitrate; /* Around in kpbs, 0 if unknown*/ + + /* This should be filled by user if previously known */ + guint16 coded_width; + /* This should be filled by user if previously known */ + guint16 coded_height; + + /* Wmvp specific */ + guint8 wmvp; /* Specify if the stream is wmp or not */ + /* In the wmvp case, the framerate is not computed but in the bistream */ + guint8 slice_code; +}; + +struct _GstVC1SeqLayer +{ + guint32 numframes; + + GstVC1SeqStructA struct_a; + GstVC1SeqStructB struct_b; + GstVC1SeqStructC struct_c; +}; + /** * GstVC1SeqHdr: * @@ -259,22 +303,15 @@ struct _GstVC1AdvancedSeqHdr */ struct _GstVC1SeqHdr { - guint8 profiletype; - guint8 colordiff_format; - guint8 frmrtq_postproc; - guint8 bitrtq_postproc; - guint8 finterpflag; + GstVC1Profile profile; + + GstVC1SeqStructC struct_c; /* calculated */ - guint framerate; /* Around in fps, 0 if unknown*/ - guint bitrate; /* Around in kpbs, 0 if unknown*/ guint mb_height; guint mb_width; - union { - GstVC1AdvancedSeqHdr advanced; - GstVC1SimpleMainSeqHdr simplemain; - } profile; + GstVC1AdvancedSeqHdr advanced; }; @@ -466,6 +503,24 @@ GstVC1ParserResult gst_vc1_parse_entry_point_header (const guint8 *data, GstVC1EntryPointHdr * entrypoint, GstVC1SeqHdr *seqhdr); +GstVC1ParserResult gst_vc1_parse_sequence_layer (const guint8 *data, + gsize size, + GstVC1SeqLayer * seqlayer); + +GstVC1ParserResult +gst_vc1_parse_sequence_header_struct_a (const guint8 *data, + gsize size, + GstVC1SeqStructA *structa); +GstVC1ParserResult +gst_vc1_parse_sequence_header_struct_b (const guint8 *data, + gsize size, + GstVC1SeqStructB *structb); + +GstVC1ParserResult +gst_vc1_parse_sequence_header_struct_c (const guint8 *data, + gsize size, + GstVC1SeqStructC *structc); + GstVC1ParserResult gst_vc1_parse_frame_header (const guint8 *data, gsize size, GstVC1FrameHdr * framehdr, diff --git a/tests/check/libs/vc1parser.c b/tests/check/libs/vc1parser.c index 1fd9e39a65..0553efc3f6 100644 --- a/tests/check/libs/vc1parser.c +++ b/tests/check/libs/vc1parser.c @@ -799,10 +799,10 @@ GST_START_TEST (test_vc1_identify_bdu) res = gst_vc1_parse_sequence_header (bdu.data + bdu.offset, bdu.size, &hdr); assert_equals_int (res, GST_VC1_PARSER_OK); - assert_equals_int (hdr.profiletype, GST_VC1_PROFILE_ADVANCED); + assert_equals_int (hdr.profile, GST_VC1_PROFILE_ADVANCED); - assert_equals_int (hdr.profile.advanced.level, GST_VC1_LEVEL_L1); - assert_equals_int (hdr.colordiff_format, 1); + assert_equals_int (hdr.advanced.level, GST_VC1_LEVEL_L1); + assert_equals_int (hdr.advanced.colordiff_format, 1); res = gst_vc1_identify_next_bdu (sequence_fullframe + bdu.sc_offset + bdu.size, sizeof (sequence_fullframe) - bdu.sc_offset - bdu.size, &bdu); @@ -822,29 +822,29 @@ GST_START_TEST (test_vc1_parse_p_frame_header_main) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1SimpleMainSeqHdr *simplehdr = &seqhdr.profile.simplemain; + GstVC1SeqStructC *structc = &seqhdr.struct_c; GstVC1PicSimpleMain *pic = &framehdr.pic.simple; - simplehdr->coded_height = 240; - simplehdr->coded_width = 320; + structc->coded_height = 240; + structc->coded_width = 320; assert_equals_int (gst_vc1_parse_sequence_header (pframe_header_main, sizeof (pframe_header_main), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_MAIN); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_MAIN); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 2); - assert_equals_int (simplehdr->loop_filter, 1); - assert_equals_int (simplehdr->multires, 0); - assert_equals_int (simplehdr->extended_mv, 0); - assert_equals_int (simplehdr->rangered, 0); - assert_equals_int (simplehdr->vstransform, 1); - assert_equals_int (simplehdr->overlap, 1); - assert_equals_int (simplehdr->syncmarker, 0); - assert_equals_int (simplehdr->dquant, 1); - assert_equals_int (simplehdr->quantizer, 0); - assert_equals_int (simplehdr->maxbframes, 1); + assert_equals_int (structc->frmrtq_postproc, 7); + assert_equals_int (structc->bitrtq_postproc, 2); + assert_equals_int (structc->loop_filter, 1); + assert_equals_int (structc->multires, 0); + assert_equals_int (structc->extended_mv, 0); + assert_equals_int (structc->rangered, 0); + assert_equals_int (structc->vstransform, 1); + assert_equals_int (structc->overlap, 1); + assert_equals_int (structc->syncmarker, 0); + assert_equals_int (structc->dquant, 1); + assert_equals_int (structc->quantizer, 0); + assert_equals_int (structc->maxbframes, 1); assert_equals_int (gst_vc1_parse_frame_header (pframe_main, sizeof (pframe_main), &framehdr, &seqhdr), GST_VC1_PARSER_OK); @@ -866,31 +866,31 @@ GST_START_TEST (test_vc1_parse_b_frame_header_main) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1SimpleMainSeqHdr *simplehdr = &seqhdr.profile.simplemain; + GstVC1SeqStructC *structc = &seqhdr.struct_c; GstVC1PicSimpleMain *pic = &framehdr.pic.simple; - simplehdr->coded_height = 240; - simplehdr->coded_width = 320; + structc->coded_height = 240; + structc->coded_width = 320; assert_equals_int (gst_vc1_parse_sequence_header (bframe_header_main, sizeof (bframe_header_main), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_MAIN); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_MAIN); assert_equals_int (seqhdr.mb_height, 15); assert_equals_int (seqhdr.mb_width, 20); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 3); - assert_equals_int (simplehdr->loop_filter, 1); - assert_equals_int (simplehdr->multires, 0); - assert_equals_int (simplehdr->extended_mv, 0); - assert_equals_int (simplehdr->rangered, 0); - assert_equals_int (simplehdr->vstransform, 1); - assert_equals_int (simplehdr->overlap, 1); - assert_equals_int (simplehdr->syncmarker, 0); - assert_equals_int (simplehdr->dquant, 1); - assert_equals_int (simplehdr->quantizer, 0); - assert_equals_int (simplehdr->maxbframes, 1); + assert_equals_int (structc->frmrtq_postproc, 7); + assert_equals_int (structc->bitrtq_postproc, 3); + assert_equals_int (structc->loop_filter, 1); + assert_equals_int (structc->multires, 0); + assert_equals_int (structc->extended_mv, 0); + assert_equals_int (structc->rangered, 0); + assert_equals_int (structc->vstransform, 1); + assert_equals_int (structc->overlap, 1); + assert_equals_int (structc->syncmarker, 0); + assert_equals_int (structc->dquant, 1); + assert_equals_int (structc->quantizer, 0); + assert_equals_int (structc->maxbframes, 1); assert_equals_int (gst_vc1_parse_frame_header (bframe_main, sizeof (bframe_main), &framehdr, &seqhdr), GST_VC1_PARSER_OK); @@ -915,28 +915,28 @@ GST_START_TEST (test_vc1_parse_bi_frame_header_main) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1SimpleMainSeqHdr *simplehdr = &seqhdr.profile.simplemain; + GstVC1SeqStructC *structc = &seqhdr.struct_c; GstVC1PicSimpleMain *pic = &framehdr.pic.simple; - simplehdr->coded_height = 240; - simplehdr->coded_width = 320; + structc->coded_height = 240; + structc->coded_width = 320; assert_equals_int (gst_vc1_parse_sequence_header (i_bi_frame_header, sizeof (i_bi_frame_header), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_MAIN); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 7); - assert_equals_int (simplehdr->loop_filter, 1); - assert_equals_int (simplehdr->multires, 0); - assert_equals_int (simplehdr->extended_mv, 0); - assert_equals_int (simplehdr->rangered, 0); - assert_equals_int (simplehdr->vstransform, 1); - assert_equals_int (simplehdr->overlap, 1); - assert_equals_int (simplehdr->syncmarker, 0); - assert_equals_int (simplehdr->dquant, 1); - assert_equals_int (simplehdr->quantizer, 0); - assert_equals_int (simplehdr->maxbframes, 1); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_MAIN); + assert_equals_int (structc->frmrtq_postproc, 7); + assert_equals_int (structc->bitrtq_postproc, 7); + assert_equals_int (structc->loop_filter, 1); + assert_equals_int (structc->multires, 0); + assert_equals_int (structc->extended_mv, 0); + assert_equals_int (structc->rangered, 0); + assert_equals_int (structc->vstransform, 1); + assert_equals_int (structc->overlap, 1); + assert_equals_int (structc->syncmarker, 0); + assert_equals_int (structc->dquant, 1); + assert_equals_int (structc->quantizer, 0); + assert_equals_int (structc->maxbframes, 1); assert_equals_int (gst_vc1_parse_frame_header (biframe_main, sizeof (biframe_main), &framehdr, &seqhdr), GST_VC1_PARSER_OK); @@ -958,28 +958,28 @@ GST_START_TEST (test_vc1_parse_i_frame_header_main) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1SimpleMainSeqHdr *simplehdr = &seqhdr.profile.simplemain; + GstVC1SeqStructC *structc = &seqhdr.struct_c; GstVC1PicSimpleMain *pic = &framehdr.pic.simple; - simplehdr->coded_height = 240; - simplehdr->coded_width = 320; + structc->coded_height = 240; + structc->coded_width = 320; assert_equals_int (gst_vc1_parse_sequence_header (i_bi_frame_header, sizeof (i_bi_frame_header), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_MAIN); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 7); - assert_equals_int (simplehdr->loop_filter, 1); - assert_equals_int (simplehdr->multires, 0); - assert_equals_int (simplehdr->extended_mv, 0); - assert_equals_int (simplehdr->rangered, 0); - assert_equals_int (simplehdr->vstransform, 1); - assert_equals_int (simplehdr->overlap, 1); - assert_equals_int (simplehdr->syncmarker, 0); - assert_equals_int (simplehdr->dquant, 1); - assert_equals_int (simplehdr->quantizer, 0); - assert_equals_int (simplehdr->maxbframes, 1); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_MAIN); + assert_equals_int (structc->frmrtq_postproc, 7); + assert_equals_int (structc->bitrtq_postproc, 7); + assert_equals_int (structc->loop_filter, 1); + assert_equals_int (structc->multires, 0); + assert_equals_int (structc->extended_mv, 0); + assert_equals_int (structc->rangered, 0); + assert_equals_int (structc->vstransform, 1); + assert_equals_int (structc->overlap, 1); + assert_equals_int (structc->syncmarker, 0); + assert_equals_int (structc->dquant, 1); + assert_equals_int (structc->quantizer, 0); + assert_equals_int (structc->maxbframes, 1); assert_equals_int (gst_vc1_parse_frame_header (iframe_main, sizeof (iframe_main), &framehdr, &seqhdr), GST_VC1_PARSER_OK); @@ -1001,23 +1001,23 @@ GST_START_TEST (test_vc1_parse_i_frame_header_adv) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1AdvancedSeqHdr *advhdr = &seqhdr.profile.advanced; + GstVC1AdvancedSeqHdr *advhdr = &seqhdr.advanced; GstVC1EntryPointHdr *entrypt = &advhdr->entrypoint; GstVC1PicAdvanced *pic = &framehdr.pic.advanced; assert_equals_int (gst_vc1_parse_sequence_header (iframe_adv_hdr, sizeof (iframe_adv_hdr), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_ADVANCED); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_ADVANCED); assert_equals_int (advhdr->level, GST_VC1_LEVEL_L3); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 31); + assert_equals_int (advhdr->frmrtq_postproc, 7); + assert_equals_int (advhdr->bitrtq_postproc, 31); assert_equals_int (advhdr->postprocflag, 0); assert_equals_int (advhdr->max_coded_width, 1920); assert_equals_int (advhdr->max_coded_height, 1080); assert_equals_int (advhdr->interlace, 1); assert_equals_int (advhdr->tfcntrflag, 0); - assert_equals_int (seqhdr.finterpflag, 0); + assert_equals_int (advhdr->finterpflag, 0); assert_equals_int (advhdr->display_ext, 1); assert_equals_int (advhdr->disp_horiz_size, 1920); @@ -1062,23 +1062,23 @@ GST_START_TEST (test_vc1_parse_b_frame_header_adv) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1AdvancedSeqHdr *advhdr = &seqhdr.profile.advanced; + GstVC1AdvancedSeqHdr *advhdr = &seqhdr.advanced; GstVC1EntryPointHdr *entrypt = &advhdr->entrypoint; GstVC1PicAdvanced *pic = &framehdr.pic.advanced; assert_equals_int (gst_vc1_parse_sequence_header (iframe_adv_hdr, sizeof (iframe_adv_hdr), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_ADVANCED); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_ADVANCED); assert_equals_int (advhdr->level, GST_VC1_LEVEL_L3); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 31); + assert_equals_int (advhdr->frmrtq_postproc, 7); + assert_equals_int (advhdr->bitrtq_postproc, 31); assert_equals_int (advhdr->postprocflag, 0); assert_equals_int (advhdr->max_coded_width, 1920); assert_equals_int (advhdr->max_coded_height, 1080); assert_equals_int (advhdr->interlace, 1); assert_equals_int (advhdr->tfcntrflag, 0); - assert_equals_int (seqhdr.finterpflag, 0); + assert_equals_int (advhdr->finterpflag, 0); assert_equals_int (advhdr->display_ext, 1); assert_equals_int (advhdr->disp_horiz_size, 1920); @@ -1132,23 +1132,23 @@ GST_START_TEST (test_vc1_parse_p_frame_header_adv) GstVC1FrameHdr framehdr; GstVC1SeqHdr seqhdr; - GstVC1AdvancedSeqHdr *advhdr = &seqhdr.profile.advanced; + GstVC1AdvancedSeqHdr *advhdr = &seqhdr.advanced; GstVC1EntryPointHdr *entrypt = &advhdr->entrypoint; GstVC1PicAdvanced *pic = &framehdr.pic.advanced; assert_equals_int (gst_vc1_parse_sequence_header (iframe_adv_hdr, sizeof (iframe_adv_hdr), &seqhdr), GST_VC1_PARSER_OK); - assert_equals_int (seqhdr.profiletype, GST_VC1_PROFILE_ADVANCED); + assert_equals_int (seqhdr.profile, GST_VC1_PROFILE_ADVANCED); assert_equals_int (advhdr->level, GST_VC1_LEVEL_L3); - assert_equals_int (seqhdr.frmrtq_postproc, 7); - assert_equals_int (seqhdr.bitrtq_postproc, 31); + assert_equals_int (advhdr->frmrtq_postproc, 7); + assert_equals_int (advhdr->bitrtq_postproc, 31); assert_equals_int (advhdr->postprocflag, 0); assert_equals_int (advhdr->max_coded_width, 1920); assert_equals_int (advhdr->max_coded_height, 1080); assert_equals_int (advhdr->interlace, 1); assert_equals_int (advhdr->tfcntrflag, 0); - assert_equals_int (seqhdr.finterpflag, 0); + assert_equals_int (advhdr->finterpflag, 0); assert_equals_int (advhdr->display_ext, 1); assert_equals_int (advhdr->disp_horiz_size, 1920);