3 * Copyright (C) 2013-2014 Intel Corporation
4 * Copyright (C) 2015 Intel Corporation
5 * Author: XuGuangxin<Guangxin.Xu@intel.com>
6 * Author: Sreerenj Balachandran<sreerenj.balachandran@intel.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
24 * SECTION:gstvp9parser
25 * @title: GstVp9Parser
26 * @short_description: Convenience library for parsing vp9 video bitstream.
28 * For more details about the structures, you can refer to the
38 #include <gst/base/gstbitreader.h>
40 #include "gstvp9parser.h"
42 #define MIN_TILE_WIDTH_B64 4
43 #define MAX_TILE_WIDTH_B64 64
45 /* order of sb64, where sb64 = 64x64 */
46 #define ALIGN_SB64(w) ((w + 63) >> 6)
48 GST_DEBUG_CATEGORY_STATIC (gst_vp9_parser_debug);
49 #define GST_CAT_DEFAULT gst_vp9_parser_debug
51 static gboolean initialized = FALSE;
52 #define INITIALIZE_DEBUG_CATEGORY \
54 GST_DEBUG_CATEGORY_INIT (gst_vp9_parser_debug, "codecparsers_vp9", 0, \
55 "vp9 parser library"); \
59 #define gst_vp9_read_bit(br) gst_bit_reader_get_bits_uint8_unchecked(br, 1)
60 #define gst_vp9_read_bits(br, bits) gst_bit_reader_get_bits_uint32_unchecked(br, bits)
62 #define GST_VP9_PARSER_GET_PRIVATE(parser) ((GstVp9ParserPrivate *)(parser->priv))
64 typedef struct _ReferenceSize
72 /* for loop filters */
73 gint8 ref_deltas[GST_VP9_MAX_REF_LF_DELTAS];
74 gint8 mode_deltas[GST_VP9_MAX_MODE_LF_DELTAS];
76 guint8 segmentation_abs_delta;
77 GstVp9SegmentationInfoData segmentation[GST_VP9_MAX_SEGMENTS];
79 ReferenceSize reference[GST_VP9_REF_FRAMES];
80 } GstVp9ParserPrivate;
83 gst_vp9_read_signed_bits (GstBitReader * br, int bits)
85 const gint32 value = gst_vp9_read_bits (br, bits);
86 return gst_vp9_read_bit (br) ? -value : value;
90 verify_frame_marker (GstBitReader * br)
92 guint8 frame_marker = gst_vp9_read_bits (br, 2);
93 if (frame_marker != GST_VP9_FRAME_MARKER) {
94 GST_ERROR ("Invalid VP9 Frame Marker !");
101 verify_sync_code (GstBitReader * const br)
103 return (gst_vp9_read_bits (br, 24) == GST_VP9_SYNC_CODE);
107 parse_bitdepth_colorspace_sampling (GstVp9Parser * parser,
108 GstBitReader * const br, GstVp9FrameHdr * frame_hdr)
110 if (frame_hdr->profile > GST_VP9_PROFILE_1)
112 gst_vp9_read_bit (br) ? GST_VP9_BIT_DEPTH_12 : GST_VP9_BIT_DEPTH_10;
114 parser->bit_depth = GST_VP9_BIT_DEPTH_8;
116 parser->color_space = gst_vp9_read_bits (br, 3);
117 if (parser->color_space != GST_VP9_CS_SRGB) {
118 parser->color_range = gst_vp9_read_bit (br);
120 if (frame_hdr->profile == GST_VP9_PROFILE_1
121 || frame_hdr->profile == GST_VP9_PROFILE_3) {
123 parser->subsampling_x = gst_vp9_read_bit (br);
124 parser->subsampling_y = gst_vp9_read_bit (br);
126 if (parser->subsampling_x == 1 && parser->subsampling_y == 1) {
128 ("4:2:0 subsampling is not supported in profile_1 or profile_3");
132 if (gst_vp9_read_bit (br)) {
133 GST_ERROR ("Reserved bit set!");
137 parser->subsampling_y = parser->subsampling_x = 1;
140 parser->color_range = GST_VP9_CR_FULL;
142 if (frame_hdr->profile == GST_VP9_PROFILE_1
143 || frame_hdr->profile == GST_VP9_PROFILE_3) {
144 if (gst_vp9_read_bit (br)) {
145 GST_ERROR ("Reserved bit set!");
150 ("4:4:4 subsampling is not supported in profile_0 and profile_2");
161 parse_profile (GstBitReader * br)
163 guint8 profile = gst_vp9_read_bit (br);
164 profile |= gst_vp9_read_bit (br) << 1;
166 profile += gst_vp9_read_bit (br);
171 parse_frame_size (GstBitReader * br, guint32 * width, guint32 * height)
173 const guint32 w = gst_vp9_read_bits (br, 16) + 1;
174 const guint32 h = gst_vp9_read_bits (br, 16) + 1;
180 parse_display_frame_size (GstBitReader * br, GstVp9FrameHdr * frame_hdr)
182 frame_hdr->display_size_enabled = gst_vp9_read_bit (br);
183 if (frame_hdr->display_size_enabled)
184 parse_frame_size (br, &frame_hdr->display_width,
185 &frame_hdr->display_height);
189 parse_frame_size_from_refs (const GstVp9Parser * parser,
190 GstVp9FrameHdr * frame_hdr, GstBitReader * br)
192 gboolean found = FALSE;
194 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
196 for (i = 0; i < GST_VP9_REFS_PER_FRAME; i++) {
197 found = gst_vp9_read_bit (br);
200 guint8 idx = frame_hdr->ref_frame_indices[i];
201 frame_hdr->width = priv->reference[idx].width;
202 frame_hdr->height = priv->reference[idx].height;
207 parse_frame_size (br, &frame_hdr->width, &frame_hdr->height);
210 static GstVp9InterpolationFilter
211 parse_interp_filter (GstBitReader * br)
213 static const GstVp9InterpolationFilter filter_map[] = {
214 GST_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH,
215 GST_VP9_INTERPOLATION_FILTER_EIGHTTAP,
216 GST_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP,
217 GST_VP9_INTERPOLATION_FILTER_BILINEAR
220 return gst_vp9_read_bit (br) ? GST_VP9_INTERPOLATION_FILTER_SWITCHABLE :
221 filter_map[gst_vp9_read_bits (br, 2)];
225 parse_loopfilter (GstVp9LoopFilter * lf, GstBitReader * br)
227 lf->filter_level = gst_vp9_read_bits (br, 6);
228 lf->sharpness_level = gst_vp9_read_bits (br, 3);
230 lf->mode_ref_delta_update = 0;
232 lf->mode_ref_delta_enabled = gst_vp9_read_bit (br);
233 if (lf->mode_ref_delta_enabled) {
234 lf->mode_ref_delta_update = gst_vp9_read_bit (br);
235 if (lf->mode_ref_delta_update) {
237 for (i = 0; i < GST_VP9_MAX_REF_LF_DELTAS; i++) {
238 lf->update_ref_deltas[i] = gst_vp9_read_bit (br);
239 if (lf->update_ref_deltas[i])
240 lf->ref_deltas[i] = gst_vp9_read_signed_bits (br, 6);
243 for (i = 0; i < GST_VP9_MAX_MODE_LF_DELTAS; i++) {
244 lf->update_mode_deltas[i] = gst_vp9_read_bit (br);
245 if (lf->update_mode_deltas[i])
246 lf->mode_deltas[i] = gst_vp9_read_signed_bits (br, 6);
253 parse_delta_q (GstBitReader * br)
255 return gst_vp9_read_bit (br) ? gst_vp9_read_signed_bits (br, 4) : 0;
259 parse_quantization (GstVp9QuantIndices * quant_indices, GstBitReader * br)
261 quant_indices->y_ac_qi = gst_vp9_read_bits (br, QINDEX_BITS);
262 quant_indices->y_dc_delta = parse_delta_q (br);
263 quant_indices->uv_dc_delta = parse_delta_q (br);
264 quant_indices->uv_ac_delta = parse_delta_q (br);
268 parse_segmentation (GstVp9SegmentationInfo * seg, GstBitReader * br)
272 seg->update_map = FALSE;
273 seg->update_data = FALSE;
275 seg->enabled = gst_vp9_read_bit (br);
279 /* Segmentation map update */
280 seg->update_map = gst_vp9_read_bit (br);
281 if (seg->update_map) {
282 for (i = 0; i < GST_VP9_SEG_TREE_PROBS; i++) {
283 seg->update_tree_probs[i] = gst_vp9_read_bit (br);
284 seg->tree_probs[i] = seg->update_tree_probs[i] ?
285 gst_vp9_read_bits (br, 8) : GST_VP9_MAX_PROB;
288 seg->temporal_update = gst_vp9_read_bit (br);
289 if (seg->temporal_update) {
290 for (i = 0; i < GST_VP9_PREDICTION_PROBS; i++) {
291 seg->update_pred_probs[i] = gst_vp9_read_bit (br);
292 seg->pred_probs[i] = seg->update_pred_probs[i] ?
293 gst_vp9_read_bits (br, 8) : GST_VP9_MAX_PROB;
296 for (i = 0; i < GST_VP9_PREDICTION_PROBS; i++)
297 seg->pred_probs[i] = GST_VP9_MAX_PROB;
301 /* Segmentation data update */
302 seg->update_data = gst_vp9_read_bit (br);
304 if (seg->update_data) {
305 /* clear all features */
306 memset (seg->data, 0, sizeof (seg->data));
308 seg->abs_delta = gst_vp9_read_bit (br);
310 for (i = 0; i < GST_VP9_MAX_SEGMENTS; i++) {
311 GstVp9SegmentationInfoData *seg_data = seg->data + i;
315 seg_data->alternate_quantizer_enabled = gst_vp9_read_bit (br);
316 if (seg_data->alternate_quantizer_enabled) {
317 data = gst_vp9_read_bits (br, 8);
318 seg_data->alternate_quantizer = gst_vp9_read_bit (br) ? -data : data;
322 seg_data->alternate_loop_filter_enabled = gst_vp9_read_bit (br);
323 if (seg_data->alternate_loop_filter_enabled) {
324 data = gst_vp9_read_bits (br, 6);
325 seg_data->alternate_loop_filter = gst_vp9_read_bit (br) ? -data : data;
328 /* SEG_LVL_REF_FRAME */
329 seg_data->reference_frame_enabled = gst_vp9_read_bit (br);
330 if (seg_data->reference_frame_enabled) {
331 seg_data->reference_frame = gst_vp9_read_bits (br, 2);
334 seg_data->reference_skip = gst_vp9_read_bit (br);
340 get_max_lb_tile_cols (guint32 sb_cols)
343 while ((sb_cols >> max_log2) >= MIN_TILE_WIDTH_B64)
349 get_min_lb_tile_cols (guint32 sb_cols)
352 while ((MAX_TILE_WIDTH_B64 << min_log2) < sb_cols)
358 parse_tile_info (GstVp9FrameHdr * frame_hdr, GstBitReader * br)
361 const guint32 sb_cols = ALIGN_SB64 (frame_hdr->width);
362 guint32 min_lb_tile_cols = get_min_lb_tile_cols (sb_cols);
363 guint32 max_lb_tile_cols = get_max_lb_tile_cols (sb_cols);
365 g_assert (min_lb_tile_cols <= max_lb_tile_cols);
366 max_ones = max_lb_tile_cols - min_lb_tile_cols;
369 frame_hdr->log2_tile_columns = min_lb_tile_cols;
370 while (max_ones-- && gst_vp9_read_bit (br))
371 frame_hdr->log2_tile_columns++;
373 if (frame_hdr->log2_tile_columns > 6) {
374 GST_ERROR ("Invalid number of tile columns..!");
379 frame_hdr->log2_tile_rows = gst_vp9_read_bit (br);
380 if (frame_hdr->log2_tile_rows)
381 frame_hdr->log2_tile_rows += gst_vp9_read_bit (br);
387 loop_filter_update (GstVp9Parser * parser, const GstVp9LoopFilter * lf)
389 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
392 for (i = 0; i < GST_VP9_MAX_REF_LF_DELTAS; i++) {
393 if (lf->update_ref_deltas[i])
394 priv->ref_deltas[i] = lf->ref_deltas[i];
397 for (i = 0; i < GST_VP9_MAX_MODE_LF_DELTAS; i++) {
398 if (lf->update_mode_deltas[i])
399 priv->mode_deltas[i] = lf->mode_deltas[i];
404 seg_get_base_qindex (const GstVp9Parser * parser,
405 const GstVp9FrameHdr * frame_hdr, int segid)
407 int seg_base = frame_hdr->quant_indices.y_ac_qi;
408 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
409 const GstVp9SegmentationInfoData *seg = priv->segmentation + segid;
410 /* DEBUG("id = %d, seg_base = %d, seg enable = %d, alt enable = %d, abs = %d, alt= %d\n",segid,
411 seg_base, frame_hdr->segmentation.enabled, seg->alternate_quantizer_enabled, priv->segmentation_abs_delta, seg->alternate_quantizer);
413 if (frame_hdr->segmentation.enabled && seg->alternate_quantizer_enabled) {
414 if (priv->segmentation_abs_delta)
415 seg_base = seg->alternate_quantizer;
417 seg_base += seg->alternate_quantizer;
419 return CLAMP (seg_base, 0, MAXQ);
423 seg_get_filter_level (const GstVp9Parser * parser,
424 const GstVp9FrameHdr * frame_hdr, int segid)
426 int seg_filter = frame_hdr->loopfilter.filter_level;
427 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
428 const GstVp9SegmentationInfoData *seg = priv->segmentation + segid;
430 if (frame_hdr->segmentation.enabled && seg->alternate_loop_filter_enabled) {
431 if (priv->segmentation_abs_delta)
432 seg_filter = seg->alternate_loop_filter;
434 seg_filter += seg->alternate_loop_filter;
436 return CLAMP (seg_filter, 0, GST_VP9_MAX_LOOP_FILTER);
439 /*save segmentation info from frame header to parser*/
441 segmentation_save (GstVp9Parser * parser, const GstVp9FrameHdr * frame_hdr)
443 const GstVp9SegmentationInfo *info = &frame_hdr->segmentation;
447 if (info->update_map) {
448 g_assert (G_N_ELEMENTS (parser->mb_segment_tree_probs) ==
449 G_N_ELEMENTS (info->tree_probs));
450 g_assert (G_N_ELEMENTS (parser->segment_pred_probs) ==
451 G_N_ELEMENTS (info->pred_probs));
452 memcpy (parser->mb_segment_tree_probs, info->tree_probs,
453 sizeof (info->tree_probs));
454 memcpy (parser->segment_pred_probs, info->pred_probs,
455 sizeof (info->pred_probs));
458 if (info->update_data) {
459 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
460 priv->segmentation_abs_delta = info->abs_delta;
461 g_assert (G_N_ELEMENTS (priv->segmentation) == G_N_ELEMENTS (info->data));
462 memcpy (priv->segmentation, info->data, sizeof (info->data));
467 segmentation_update (GstVp9Parser * parser, const GstVp9FrameHdr * frame_hdr)
470 const GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
471 const GstVp9LoopFilter *lf = &frame_hdr->loopfilter;
472 const GstVp9QuantIndices *quant_indices = &frame_hdr->quant_indices;
473 int default_filter = lf->filter_level;
474 const int scale = 1 << (default_filter >> 5);
476 segmentation_save (parser, frame_hdr);
478 for (i = 0; i < GST_VP9_MAX_SEGMENTS; i++) {
479 guint8 q = seg_get_base_qindex (parser, frame_hdr, i);
481 GstVp9Segmentation *seg = parser->segmentation + i;
482 const GstVp9SegmentationInfoData *info = priv->segmentation + i;
484 seg->luma_dc_quant_scale =
485 gst_vp9_dc_quant (q, quant_indices->y_dc_delta, parser->bit_depth);
486 seg->luma_ac_quant_scale = gst_vp9_ac_quant (q, 0, parser->bit_depth);
487 seg->chroma_dc_quant_scale =
488 gst_vp9_dc_quant (q, quant_indices->uv_dc_delta, parser->bit_depth);
489 seg->chroma_ac_quant_scale =
490 gst_vp9_ac_quant (q, quant_indices->uv_ac_delta, parser->bit_depth);
492 if (lf->filter_level) {
493 guint8 filter = seg_get_filter_level (parser, frame_hdr, i);
495 if (!lf->mode_ref_delta_enabled) {
496 memset (seg->filter_level, filter, sizeof (seg->filter_level));
499 const int intra_filter =
500 filter + priv->ref_deltas[GST_VP9_REF_FRAME_INTRA] * scale;
501 seg->filter_level[GST_VP9_REF_FRAME_INTRA][0] =
502 CLAMP (intra_filter, 0, GST_VP9_MAX_LOOP_FILTER);
503 for (ref = GST_VP9_REF_FRAME_LAST; ref < GST_VP9_REF_FRAME_MAX; ++ref) {
504 for (mode = 0; mode < GST_VP9_MAX_MODE_LF_DELTAS; ++mode) {
505 const int inter_filter = filter + priv->ref_deltas[ref] * scale
506 + priv->mode_deltas[mode] * scale;
507 seg->filter_level[ref][mode] =
508 CLAMP (inter_filter, 0, GST_VP9_MAX_LOOP_FILTER);
513 seg->reference_frame_enabled = info->reference_frame_enabled;;
514 seg->reference_frame = info->reference_frame;
515 seg->reference_skip = info->reference_skip;
520 reference_update (GstVp9Parser * parser, const GstVp9FrameHdr * const frame_hdr)
523 guint8 refresh_frame_flags;
525 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
526 ReferenceSize *reference = priv->reference;
527 if (frame_hdr->frame_type == GST_VP9_KEY_FRAME) {
528 refresh_frame_flags = 0xff;
530 refresh_frame_flags = frame_hdr->refresh_frame_flags;
532 for (i = 0; i < GST_VP9_REF_FRAMES; i++) {
533 if (refresh_frame_flags & flag) {
534 reference[i].width = frame_hdr->width;
535 reference[i].height = frame_hdr->height;
542 frame_is_intra_only (const GstVp9FrameHdr * frame_hdr)
544 return frame_hdr->frame_type == GST_VP9_KEY_FRAME || frame_hdr->intra_only;
548 set_default_lf_deltas (GstVp9Parser * parser)
550 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
551 priv->ref_deltas[GST_VP9_REF_FRAME_INTRA] = 1;
552 priv->ref_deltas[GST_VP9_REF_FRAME_LAST] = 0;
553 priv->ref_deltas[GST_VP9_REF_FRAME_GOLDEN] = -1;
554 priv->ref_deltas[GST_VP9_REF_FRAME_ALTREF] = -1;
556 priv->mode_deltas[0] = 0;
557 priv->mode_deltas[1] = 0;
561 set_default_segmentation_info (GstVp9Parser * parser)
563 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
565 memset (priv->segmentation, 0, sizeof (priv->segmentation));
567 priv->segmentation_abs_delta = FALSE;
571 setup_past_independence (GstVp9Parser * parser,
572 GstVp9FrameHdr * const frame_hdr)
574 set_default_lf_deltas (parser);
575 set_default_segmentation_info (parser);
577 memset (frame_hdr->ref_frame_sign_bias, 0,
578 sizeof (frame_hdr->ref_frame_sign_bias));
582 gst_vp9_parser_reset (GstVp9Parser * parser)
584 GstVp9ParserPrivate *priv = parser->priv;
587 memset (parser->mb_segment_tree_probs, 0,
588 sizeof (parser->mb_segment_tree_probs));
589 memset (parser->segment_pred_probs, 0, sizeof (parser->segment_pred_probs));
590 memset (parser->segmentation, 0, sizeof (parser->segmentation));
592 memset (priv, 0, sizeof (GstVp9ParserPrivate));
596 static GstVp9ParserResult
597 gst_vp9_parser_update (GstVp9Parser * parser, GstVp9FrameHdr * const frame_hdr)
599 if (frame_hdr->frame_type == GST_VP9_KEY_FRAME)
600 gst_vp9_parser_reset (parser);
602 if (frame_is_intra_only (frame_hdr) || frame_hdr->error_resilient_mode)
603 setup_past_independence (parser, frame_hdr);
605 loop_filter_update (parser, &frame_hdr->loopfilter);
606 segmentation_update (parser, frame_hdr);
607 reference_update (parser, frame_hdr);
609 return GST_VP9_PARSER_OK;
613 /******** API *************/
616 * gst_vp9_parser_new:
618 * Creates a new #GstVp9Parser. It should be freed with
619 * gst_vp9_parser_free() after use.
621 * Returns: a new #GstVp9Parser
626 gst_vp9_parser_new (void)
628 GstVp9Parser *parser;
629 GstVp9ParserPrivate *priv;
631 INITIALIZE_DEBUG_CATEGORY;
632 GST_DEBUG ("Create VP9 Parser");
634 parser = g_slice_new0 (GstVp9Parser);
638 priv = g_slice_new0 (GstVp9ParserPrivate);
648 * gst_vp9_parser_free:
649 * @parser: the #GstVp9Parser to free
656 gst_vp9_parser_free (GstVp9Parser * parser)
660 g_slice_free (GstVp9ParserPrivate, parser->priv);
663 g_slice_free (GstVp9Parser, parser);
668 * gst_vp9_parser_parse_frame_header:
669 * @parser: The #GstVp9Parser
670 * @frame_hdr: The #GstVp9FrameHdr to fill
671 * @data: The data to parse
672 * @size: The size of the @data to parse
674 * Parses the VP9 bitstream contained in @data, and fills in @frame_hdr
675 * with the information. The @size argument represent the whole frame size.
677 * Returns: a #GstVp9ParserResult
682 gst_vp9_parser_parse_frame_header (GstVp9Parser * parser,
683 GstVp9FrameHdr * frame_hdr, const guint8 * data, gsize size)
685 GstBitReader bit_reader;
686 GstBitReader *br = &bit_reader;
688 gst_bit_reader_init (br, data, size);
689 memset (frame_hdr, 0, sizeof (*frame_hdr));
691 /* Parsing Uncompressed Data Chunk */
693 if (!verify_frame_marker (br))
696 frame_hdr->profile = parse_profile (br);
697 if (frame_hdr->profile > GST_VP9_PROFILE_UNDEFINED) {
698 GST_ERROR ("Stream has undefined VP9 profile !");
702 frame_hdr->show_existing_frame = gst_vp9_read_bit (br);
703 if (frame_hdr->show_existing_frame) {
704 frame_hdr->frame_to_show = gst_vp9_read_bits (br, GST_VP9_REF_FRAMES_LOG2);
705 return GST_VP9_PARSER_OK;
708 frame_hdr->frame_type = gst_vp9_read_bit (br);
709 frame_hdr->show_frame = gst_vp9_read_bit (br);
710 frame_hdr->error_resilient_mode = gst_vp9_read_bit (br);
712 if (frame_hdr->frame_type == GST_VP9_KEY_FRAME) {
714 if (!verify_sync_code (br)) {
715 GST_ERROR ("Invalid VP9 Key-frame sync code !");
719 if (!parse_bitdepth_colorspace_sampling (parser, br, frame_hdr)) {
720 GST_ERROR ("Failed to parse color_space/bit_depth info !");
724 parse_frame_size (br, &frame_hdr->width, &frame_hdr->height);
726 parse_display_frame_size (br, frame_hdr);
729 frame_hdr->intra_only = frame_hdr->show_frame ? 0 : gst_vp9_read_bit (br);
730 frame_hdr->reset_frame_context = frame_hdr->error_resilient_mode ?
731 0 : gst_vp9_read_bits (br, 2);
733 if (frame_hdr->intra_only) {
735 if (!verify_sync_code (br)) {
736 GST_ERROR ("Invalid VP9 sync code in intra-only frame !");
740 if (frame_hdr->profile > GST_VP9_PROFILE_0) {
741 if (!parse_bitdepth_colorspace_sampling (parser, br, frame_hdr)) {
742 GST_ERROR ("Failed to parse color_space/bit_depth info !");
746 parser->color_space = GST_VP9_CS_BT_601;
747 parser->color_range = GST_VP9_CR_LIMITED;
748 parser->subsampling_y = parser->subsampling_x = 1;
749 parser->bit_depth = GST_VP9_BIT_DEPTH_8;
752 frame_hdr->refresh_frame_flags =
753 gst_vp9_read_bits (br, GST_VP9_REF_FRAMES);
754 parse_frame_size (br, &frame_hdr->width, &frame_hdr->height);
755 parse_display_frame_size (br, frame_hdr);
759 frame_hdr->refresh_frame_flags =
760 gst_vp9_read_bits (br, GST_VP9_REF_FRAMES);
762 for (i = 0; i < GST_VP9_REFS_PER_FRAME; i++) {
763 frame_hdr->ref_frame_indices[i] =
764 gst_vp9_read_bits (br, GST_VP9_REF_FRAMES_LOG2);
765 frame_hdr->ref_frame_sign_bias[i] = gst_vp9_read_bit (br);
768 parse_frame_size_from_refs (parser, frame_hdr, br);
769 parse_display_frame_size (br, frame_hdr);
771 frame_hdr->allow_high_precision_mv = gst_vp9_read_bit (br);
772 frame_hdr->mcomp_filter_type = parse_interp_filter (br);
776 frame_hdr->refresh_frame_context =
777 frame_hdr->error_resilient_mode ? 0 : gst_vp9_read_bit (br);
778 frame_hdr->frame_parallel_decoding_mode =
779 frame_hdr->error_resilient_mode ? 1 : gst_vp9_read_bit (br);
780 frame_hdr->frame_context_idx =
781 gst_vp9_read_bits (br, GST_VP9_FRAME_CONTEXTS_LOG2);
783 /* loopfilter header */
784 parse_loopfilter (&frame_hdr->loopfilter, br);
786 /* quantization header */
787 parse_quantization (&frame_hdr->quant_indices, br);
788 /* set lossless_flag */
789 frame_hdr->lossless_flag = frame_hdr->quant_indices.y_ac_qi == 0 &&
790 frame_hdr->quant_indices.y_dc_delta == 0 &&
791 frame_hdr->quant_indices.uv_dc_delta == 0
792 && frame_hdr->quant_indices.uv_ac_delta == 0;
794 /* segmentation header */
795 parse_segmentation (&frame_hdr->segmentation, br);
798 if (!parse_tile_info (frame_hdr, br)) {
799 GST_ERROR ("Failed to parse tile info...!");
803 /* size of the rest of the header */
804 frame_hdr->first_partition_size = gst_vp9_read_bits (br, 16);
805 if (!frame_hdr->first_partition_size) {
806 GST_ERROR ("Failed to parse the first partition size...!");
810 frame_hdr->frame_header_length_in_bytes =
811 (gst_bit_reader_get_pos (br) + 7) / 8;
812 return gst_vp9_parser_update (parser, frame_hdr);
815 return GST_VP9_PARSER_ERROR;