1 /* gstvp9parser.c
2 *
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>
7 *
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.
12 *
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.
17 *
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.
22 */
23 /**
24 * SECTION:gstvp9parser
25 * @title: GstVp9Parser
26 * @short_description: Convenience library for parsing vp9 video bitstream.
27 *
28 * For more details about the structures, you can refer to the
29 * specifications:
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #include <string.h>
37 #include <stdlib.h>
38 #include <gst/base/gstbitreader.h>
39 #include "vp9utils.h"
40 #include "gstvp9parser.h"
41
42 #define MIN_TILE_WIDTH_B64 4
43 #define MAX_TILE_WIDTH_B64 64
44
45 /* order of sb64, where sb64 = 64x64 */
46 #define ALIGN_SB64(w) ((w + 63) >> 6)
47
48 GST_DEBUG_CATEGORY_STATIC (gst_vp9_parser_debug);
49 #define GST_CAT_DEFAULT gst_vp9_parser_debug
50
51 static gboolean initialized = FALSE;
52 #define INITIALIZE_DEBUG_CATEGORY \
53 if (!initialized) { \
54 GST_DEBUG_CATEGORY_INIT (gst_vp9_parser_debug, "codecparsers_vp9", 0, \
55 "vp9 parser library"); \
56 initialized = TRUE; \
57 }
58
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)
61
62 #define GST_VP9_PARSER_GET_PRIVATE(parser) ((GstVp9ParserPrivate *)(parser->priv))
63
64 typedef struct _ReferenceSize
65 {
66 guint32 width;
67 guint32 height;
68 } ReferenceSize;
69
70 typedef struct
71 {
72 /* for loop filters */
73 gint8 ref_deltas[GST_VP9_MAX_REF_LF_DELTAS];
74 gint8 mode_deltas[GST_VP9_MAX_MODE_LF_DELTAS];
75
76 guint8 segmentation_abs_delta;
77 GstVp9SegmentationInfoData segmentation[GST_VP9_MAX_SEGMENTS];
78
79 ReferenceSize reference[GST_VP9_REF_FRAMES];
80 } GstVp9ParserPrivate;
81
82 static gint32
gst_vp9_read_signed_bits(GstBitReader * br,int bits)83 gst_vp9_read_signed_bits (GstBitReader * br, int bits)
84 {
85 const gint32 value = gst_vp9_read_bits (br, bits);
86 return gst_vp9_read_bit (br) ? -value : value;
87 }
88
89 static gboolean
verify_frame_marker(GstBitReader * br)90 verify_frame_marker (GstBitReader * br)
91 {
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 !");
95 return FALSE;
96 }
97 return TRUE;
98 }
99
100 static gboolean
verify_sync_code(GstBitReader * const br)101 verify_sync_code (GstBitReader * const br)
102 {
103 return (gst_vp9_read_bits (br, 24) == GST_VP9_SYNC_CODE);
104 }
105
106 static gboolean
parse_bitdepth_colorspace_sampling(GstVp9Parser * parser,GstBitReader * const br,GstVp9FrameHdr * frame_hdr)107 parse_bitdepth_colorspace_sampling (GstVp9Parser * parser,
108 GstBitReader * const br, GstVp9FrameHdr * frame_hdr)
109 {
110 if (frame_hdr->profile > GST_VP9_PROFILE_1)
111 parser->bit_depth =
112 gst_vp9_read_bit (br) ? GST_VP9_BIT_DEPTH_12 : GST_VP9_BIT_DEPTH_10;
113 else
114 parser->bit_depth = GST_VP9_BIT_DEPTH_8;
115
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);
119
120 if (frame_hdr->profile == GST_VP9_PROFILE_1
121 || frame_hdr->profile == GST_VP9_PROFILE_3) {
122
123 parser->subsampling_x = gst_vp9_read_bit (br);
124 parser->subsampling_y = gst_vp9_read_bit (br);
125
126 if (parser->subsampling_x == 1 && parser->subsampling_y == 1) {
127 GST_ERROR
128 ("4:2:0 subsampling is not supported in profile_1 or profile_3");
129 goto error;
130 }
131
132 if (gst_vp9_read_bit (br)) {
133 GST_ERROR ("Reserved bit set!");
134 goto error;
135 }
136 } else {
137 parser->subsampling_y = parser->subsampling_x = 1;
138 }
139 } else {
140 parser->color_range = GST_VP9_CR_FULL;
141
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!");
146 goto error;
147 }
148 } else {
149 GST_ERROR
150 ("4:4:4 subsampling is not supported in profile_0 and profile_2");
151 goto error;
152 }
153 }
154 return TRUE;
155
156 error:
157 return FALSE;
158 }
159
160 static guint
parse_profile(GstBitReader * br)161 parse_profile (GstBitReader * br)
162 {
163 guint8 profile = gst_vp9_read_bit (br);
164 profile |= gst_vp9_read_bit (br) << 1;
165 if (profile > 2)
166 profile += gst_vp9_read_bit (br);
167 return profile;
168 }
169
170 static void
parse_frame_size(GstBitReader * br,guint32 * width,guint32 * height)171 parse_frame_size (GstBitReader * br, guint32 * width, guint32 * height)
172 {
173 const guint32 w = gst_vp9_read_bits (br, 16) + 1;
174 const guint32 h = gst_vp9_read_bits (br, 16) + 1;
175 *width = w;
176 *height = h;
177 }
178
179 static void
parse_display_frame_size(GstBitReader * br,GstVp9FrameHdr * frame_hdr)180 parse_display_frame_size (GstBitReader * br, GstVp9FrameHdr * frame_hdr)
181 {
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);
186 }
187
188 static void
parse_frame_size_from_refs(const GstVp9Parser * parser,GstVp9FrameHdr * frame_hdr,GstBitReader * br)189 parse_frame_size_from_refs (const GstVp9Parser * parser,
190 GstVp9FrameHdr * frame_hdr, GstBitReader * br)
191 {
192 gboolean found = FALSE;
193 int i;
194 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
195
196 for (i = 0; i < GST_VP9_REFS_PER_FRAME; i++) {
197 found = gst_vp9_read_bit (br);
198
199 if (found) {
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;
203 break;
204 }
205 }
206 if (!found)
207 parse_frame_size (br, &frame_hdr->width, &frame_hdr->height);
208 }
209
210 static GstVp9InterpolationFilter
parse_interp_filter(GstBitReader * br)211 parse_interp_filter (GstBitReader * br)
212 {
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
218 };
219
220 return gst_vp9_read_bit (br) ? GST_VP9_INTERPOLATION_FILTER_SWITCHABLE :
221 filter_map[gst_vp9_read_bits (br, 2)];
222 }
223
224 static void
parse_loopfilter(GstVp9LoopFilter * lf,GstBitReader * br)225 parse_loopfilter (GstVp9LoopFilter * lf, GstBitReader * br)
226 {
227 lf->filter_level = gst_vp9_read_bits (br, 6);
228 lf->sharpness_level = gst_vp9_read_bits (br, 3);
229
230 lf->mode_ref_delta_update = 0;
231
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) {
236 int i;
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);
241 }
242
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);
247 }
248 }
249 }
250 }
251
252 static gint8
parse_delta_q(GstBitReader * br)253 parse_delta_q (GstBitReader * br)
254 {
255 return gst_vp9_read_bit (br) ? gst_vp9_read_signed_bits (br, 4) : 0;
256 }
257
258 static void
parse_quantization(GstVp9QuantIndices * quant_indices,GstBitReader * br)259 parse_quantization (GstVp9QuantIndices * quant_indices, GstBitReader * br)
260 {
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);
265 }
266
267 static void
parse_segmentation(GstVp9SegmentationInfo * seg,GstBitReader * br)268 parse_segmentation (GstVp9SegmentationInfo * seg, GstBitReader * br)
269 {
270 int i;
271
272 seg->update_map = FALSE;
273 seg->update_data = FALSE;
274
275 seg->enabled = gst_vp9_read_bit (br);
276 if (!seg->enabled)
277 return;
278
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;
286 }
287
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;
294 }
295 } else {
296 for (i = 0; i < GST_VP9_PREDICTION_PROBS; i++)
297 seg->pred_probs[i] = GST_VP9_MAX_PROB;
298 }
299 }
300
301 /* Segmentation data update */
302 seg->update_data = gst_vp9_read_bit (br);
303
304 if (seg->update_data) {
305 /* clear all features */
306 memset (seg->data, 0, sizeof (seg->data));
307
308 seg->abs_delta = gst_vp9_read_bit (br);
309
310 for (i = 0; i < GST_VP9_MAX_SEGMENTS; i++) {
311 GstVp9SegmentationInfoData *seg_data = seg->data + i;
312 guint8 data;
313
314 /* SEG_LVL_ALT_Q */
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;
319 }
320
321 /* SEG_LVL_ALT_LF */
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;
326 }
327
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);
332 }
333
334 seg_data->reference_skip = gst_vp9_read_bit (br);
335 }
336 }
337 }
338
339 static guint32
get_max_lb_tile_cols(guint32 sb_cols)340 get_max_lb_tile_cols (guint32 sb_cols)
341 {
342 gint max_log2 = 1;
343 while ((sb_cols >> max_log2) >= MIN_TILE_WIDTH_B64)
344 ++max_log2;
345 return max_log2 - 1;
346 }
347
348 static guint32
get_min_lb_tile_cols(guint32 sb_cols)349 get_min_lb_tile_cols (guint32 sb_cols)
350 {
351 gint min_log2 = 0;
352 while ((MAX_TILE_WIDTH_B64 << min_log2) < sb_cols)
353 ++min_log2;
354 return min_log2;
355 }
356
357 static gboolean
parse_tile_info(GstVp9FrameHdr * frame_hdr,GstBitReader * br)358 parse_tile_info (GstVp9FrameHdr * frame_hdr, GstBitReader * br)
359 {
360 guint32 max_ones;
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);
364
365 g_assert (min_lb_tile_cols <= max_lb_tile_cols);
366 max_ones = max_lb_tile_cols - min_lb_tile_cols;
367
368 /* columns */
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++;
372
373 if (frame_hdr->log2_tile_columns > 6) {
374 GST_ERROR ("Invalid number of tile columns..!");
375 return FALSE;
376 }
377
378 /* row */
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);
382
383 return TRUE;
384 }
385
386 static void
loop_filter_update(GstVp9Parser * parser,const GstVp9LoopFilter * lf)387 loop_filter_update (GstVp9Parser * parser, const GstVp9LoopFilter * lf)
388 {
389 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
390 int i;
391
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];
395 }
396
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];
400 }
401 }
402
403 static guint8
seg_get_base_qindex(const GstVp9Parser * parser,const GstVp9FrameHdr * frame_hdr,int segid)404 seg_get_base_qindex (const GstVp9Parser * parser,
405 const GstVp9FrameHdr * frame_hdr, int segid)
406 {
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 eanble = %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);
412 */
413 if (frame_hdr->segmentation.enabled && seg->alternate_quantizer_enabled) {
414 if (priv->segmentation_abs_delta)
415 seg_base = seg->alternate_quantizer;
416 else
417 seg_base += seg->alternate_quantizer;
418 }
419 return CLAMP (seg_base, 0, MAXQ);
420 }
421
422 static guint8
seg_get_filter_level(const GstVp9Parser * parser,const GstVp9FrameHdr * frame_hdr,int segid)423 seg_get_filter_level (const GstVp9Parser * parser,
424 const GstVp9FrameHdr * frame_hdr, int segid)
425 {
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;
429
430 if (frame_hdr->segmentation.enabled && seg->alternate_loop_filter_enabled) {
431 if (priv->segmentation_abs_delta)
432 seg_filter = seg->alternate_loop_filter;
433 else
434 seg_filter += seg->alternate_loop_filter;
435 }
436 return CLAMP (seg_filter, 0, GST_VP9_MAX_LOOP_FILTER);
437 }
438
439 /*save segmentation info from frame header to parser*/
440 static void
segmentation_save(GstVp9Parser * parser,const GstVp9FrameHdr * frame_hdr)441 segmentation_save (GstVp9Parser * parser, const GstVp9FrameHdr * frame_hdr)
442 {
443 const GstVp9SegmentationInfo *info = &frame_hdr->segmentation;
444 if (!info->enabled)
445 return;
446
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));
456 }
457
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));
463 }
464 }
465
466 static void
segmentation_update(GstVp9Parser * parser,const GstVp9FrameHdr * frame_hdr)467 segmentation_update (GstVp9Parser * parser, const GstVp9FrameHdr * frame_hdr)
468 {
469 int i = 0;
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);
475
476 segmentation_save (parser, frame_hdr);
477
478 for (i = 0; i < GST_VP9_MAX_SEGMENTS; i++) {
479 guint8 q = seg_get_base_qindex (parser, frame_hdr, i);
480
481 GstVp9Segmentation *seg = parser->segmentation + i;
482 const GstVp9SegmentationInfoData *info = priv->segmentation + i;
483
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);
491
492 if (lf->filter_level) {
493 guint8 filter = seg_get_filter_level (parser, frame_hdr, i);
494
495 if (!lf->mode_ref_delta_enabled) {
496 memset (seg->filter_level, filter, sizeof (seg->filter_level));
497 } else {
498 int ref, mode;
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);
509 }
510 }
511 }
512 }
513 seg->reference_frame_enabled = info->reference_frame_enabled;;
514 seg->reference_frame = info->reference_frame;
515 seg->reference_skip = info->reference_skip;
516 }
517 }
518
519 static void
reference_update(GstVp9Parser * parser,const GstVp9FrameHdr * const frame_hdr)520 reference_update (GstVp9Parser * parser, const GstVp9FrameHdr * const frame_hdr)
521 {
522 guint8 flag = 1;
523 guint8 refresh_frame_flags;
524 int i;
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;
529 } else {
530 refresh_frame_flags = frame_hdr->refresh_frame_flags;
531 }
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;
536 }
537 flag <<= 1;
538 }
539 }
540
541 static inline int
frame_is_intra_only(const GstVp9FrameHdr * frame_hdr)542 frame_is_intra_only (const GstVp9FrameHdr * frame_hdr)
543 {
544 return frame_hdr->frame_type == GST_VP9_KEY_FRAME || frame_hdr->intra_only;
545 }
546
547 static void
set_default_lf_deltas(GstVp9Parser * parser)548 set_default_lf_deltas (GstVp9Parser * parser)
549 {
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;
555
556 priv->mode_deltas[0] = 0;
557 priv->mode_deltas[1] = 0;
558 }
559
560 static void
set_default_segmentation_info(GstVp9Parser * parser)561 set_default_segmentation_info (GstVp9Parser * parser)
562 {
563 GstVp9ParserPrivate *priv = GST_VP9_PARSER_GET_PRIVATE (parser);
564
565 memset (priv->segmentation, 0, sizeof (priv->segmentation));
566
567 priv->segmentation_abs_delta = FALSE;
568 }
569
570 static void
setup_past_independence(GstVp9Parser * parser,GstVp9FrameHdr * const frame_hdr)571 setup_past_independence (GstVp9Parser * parser,
572 GstVp9FrameHdr * const frame_hdr)
573 {
574 set_default_lf_deltas (parser);
575 set_default_segmentation_info (parser);
576
577 memset (frame_hdr->ref_frame_sign_bias, 0,
578 sizeof (frame_hdr->ref_frame_sign_bias));
579 }
580
581 static void
gst_vp9_parser_reset(GstVp9Parser * parser)582 gst_vp9_parser_reset (GstVp9Parser * parser)
583 {
584 GstVp9ParserPrivate *priv = parser->priv;
585
586 parser->priv = NULL;
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));
591
592 memset (priv, 0, sizeof (GstVp9ParserPrivate));
593 parser->priv = priv;
594 }
595
596 static GstVp9ParserResult
gst_vp9_parser_update(GstVp9Parser * parser,GstVp9FrameHdr * const frame_hdr)597 gst_vp9_parser_update (GstVp9Parser * parser, GstVp9FrameHdr * const frame_hdr)
598 {
599 if (frame_hdr->frame_type == GST_VP9_KEY_FRAME)
600 gst_vp9_parser_reset (parser);
601
602 if (frame_is_intra_only (frame_hdr) || frame_hdr->error_resilient_mode)
603 setup_past_independence (parser, frame_hdr);
604
605 loop_filter_update (parser, &frame_hdr->loopfilter);
606 segmentation_update (parser, frame_hdr);
607 reference_update (parser, frame_hdr);
608
609 return GST_VP9_PARSER_OK;
610 }
611
612
613 /******** API *************/
614
615 /**
616 * gst_vp9_parser_new:
617 *
618 * Creates a new #GstVp9Parser. It should be freed with
619 * gst_vp9_parser_free() after use.
620 *
621 * Returns: a new #GstVp9Parser
622 *
623 * Since: 1.8
624 */
625 GstVp9Parser *
gst_vp9_parser_new(void)626 gst_vp9_parser_new (void)
627 {
628 GstVp9Parser *parser;
629 GstVp9ParserPrivate *priv;
630
631 INITIALIZE_DEBUG_CATEGORY;
632 GST_DEBUG ("Create VP9 Parser");
633
634 parser = g_slice_new0 (GstVp9Parser);
635 if (!parser)
636 return NULL;
637
638 priv = g_slice_new0 (GstVp9ParserPrivate);
639 if (!priv)
640 return NULL;
641
642 parser->priv = priv;
643
644 return parser;
645 }
646
647 /**
648 * gst_vp9_parser_free:
649 * @parser: the #GstVp9Parser to free
650 *
651 * Frees @parser.
652 *
653 * Since: 1.8
654 */
655 void
gst_vp9_parser_free(GstVp9Parser * parser)656 gst_vp9_parser_free (GstVp9Parser * parser)
657 {
658 if (parser) {
659 if (parser->priv) {
660 g_slice_free (GstVp9ParserPrivate, parser->priv);
661 parser->priv = NULL;
662 }
663 g_slice_free (GstVp9Parser, parser);
664 }
665 }
666
667 /**
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
673 *
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.
676 *
677 * Returns: a #GstVp9ParserResult
678 *
679 * Since: 1.8
680 */
681 GstVp9ParserResult
gst_vp9_parser_parse_frame_header(GstVp9Parser * parser,GstVp9FrameHdr * frame_hdr,const guint8 * data,gsize size)682 gst_vp9_parser_parse_frame_header (GstVp9Parser * parser,
683 GstVp9FrameHdr * frame_hdr, const guint8 * data, gsize size)
684 {
685 GstBitReader bit_reader;
686 GstBitReader *br = &bit_reader;
687
688 gst_bit_reader_init (br, data, size);
689 memset (frame_hdr, 0, sizeof (*frame_hdr));
690
691 /* Parsing Uncompressed Data Chunk */
692
693 if (!verify_frame_marker (br))
694 goto error;
695
696 frame_hdr->profile = parse_profile (br);
697 if (frame_hdr->profile > GST_VP9_PROFILE_UNDEFINED) {
698 GST_ERROR ("Stream has undefined VP9 profile !");
699 goto error;
700 }
701
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;
706 }
707
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);
711
712 if (frame_hdr->frame_type == GST_VP9_KEY_FRAME) {
713
714 if (!verify_sync_code (br)) {
715 GST_ERROR ("Invalid VP9 Key-frame sync code !");
716 goto error;
717 }
718
719 if (!parse_bitdepth_colorspace_sampling (parser, br, frame_hdr)) {
720 GST_ERROR ("Failed to parse color_space/bit_depth info !");
721 goto error;
722 }
723
724 parse_frame_size (br, &frame_hdr->width, &frame_hdr->height);
725
726 parse_display_frame_size (br, frame_hdr);
727
728 } else {
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);
732
733 if (frame_hdr->intra_only) {
734
735 if (!verify_sync_code (br)) {
736 GST_ERROR ("Invalid VP9 sync code in intra-only frame !");
737 goto error;
738 }
739
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 !");
743 goto error;
744 }
745 } else {
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;
750 }
751
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);
756
757 } else {
758 int i;
759 frame_hdr->refresh_frame_flags =
760 gst_vp9_read_bits (br, GST_VP9_REF_FRAMES);
761
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);
766 }
767
768 parse_frame_size_from_refs (parser, frame_hdr, br);
769 parse_display_frame_size (br, frame_hdr);
770
771 frame_hdr->allow_high_precision_mv = gst_vp9_read_bit (br);
772 frame_hdr->mcomp_filter_type = parse_interp_filter (br);
773 }
774 }
775
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);
782
783 /* loopfilter header */
784 parse_loopfilter (&frame_hdr->loopfilter, br);
785
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;
793
794 /* segmentation header */
795 parse_segmentation (&frame_hdr->segmentation, br);
796
797 /* tile header */
798 if (!parse_tile_info (frame_hdr, br)) {
799 GST_ERROR ("Failed to parse tile info...!");
800 goto error;
801 }
802
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...!");
807 goto error;
808 }
809
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);
813
814 error:
815 return GST_VP9_PARSER_ERROR;
816 }
817