1 /* gstav1parser.c
2 *
3 * Copyright (C) 2018 Georg Ottinger
4 * Copyright (C) 2019-2020 Intel Corporation
5 * Author: Georg Ottinger <g.ottinger@gmx.at>
6 * Author: Junyan He <junyan.he@hotmail.com>
7 * Author: Victor Jaquez <vjaquez@igalia.com>
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the
21 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
22 * Boston, MA 02110-1301, USA.
23 */
24 /**
25 * SECTION:gstav1parser
26 * @title: GstAV1Parser
27 * @short_description: Convenience library for parsing AV1 video bitstream.
28 *
29 * For more details about the structures, you can refer to the AV1 Bitstream &
30 * Decoding Process Specification V1.0.0
31 * [specification](https://aomediacodec.github.io/av1-spec/av1-spec.pdf)
32 *
33 * It offers you bitstream parsing of low overhead bistream format (Section 5)
34 * or Annex B according to the setting of the parser. By calling the function of
35 * gst_av1_parser_reset(), user can switch between bistream mode and Annex B mode.
36 *
37 * To retrieve OBUs and parse its headers, you should firstly call the function of
38 * gst_av1_parser_identify_one_obu() to get the OBU type if succeeds or just discard
39 * the data if fails.
40 *
41 * Then, depending on the #GstAV1OBUType of the newly parsed #GstAV1OBU,
42 * you should call the differents functions to parse the structure details:
43 *
44 * * #GST_AV1_OBU_SEQUENCE_HEADER: gst_av1_parser_parse_sequence_header_obu()
45 *
46 * * #GST_AV1_OBU_TEMPORAL_DELIMITER: gst_av1_parser_parse_temporal_delimiter_obu()
47 *
48 * * #GST_AV1_OBU_FRAME: gst_av1_parser_parse_frame_obu()
49 *
50 * * #GST_AV1_OBU_FRAME_HEADER: gst_av1_parser_parse_frame_header_obu()
51 *
52 * * #GST_AV1_OBU_TILE_GROUP: gst_av1_parser_parse_tile_group_obu()
53 *
54 * * #GST_AV1_OBU_METADATA: gst_av1_parser_parse_metadata_obu()
55 *
56 * * #GST_AV1_OBU_REDUNDANT_FRAME_HEADER: gst_av1_parser_parse_frame_header_obu()
57 *
58 * * #GST_AV1_OBU_TILE_LIST: gst_av1_parser_parse_tile_list_obu()
59 *
60 * Note: Some parser functions are dependent on information provided in the sequence
61 * header and reference frame's information. It maintains a state inside itself, which
62 * contains all global vars and reference information during the whole parsing process.
63 * Calling gst_av1_parser_reset() or a new sequence's arriving can clear and reset this
64 * inside state.
65 *
66 * After successfully handled a frame(for example, decode a frame successfully), you
67 * should call gst_av1_parser_reference_frame_update() to update the parser's inside
68 * state(such as reference information, global segmentation information, etc).
69 *
70 * Note: If the frame is actived by show_existing_frame in #GST_AV1_OBU_FRAME_HEADER,
71 * the function of gst_av1_parser_reference_frame_loading() should be called before
72 * really showing that frame.
73 *
74 * @since: 1.18.00
75 */
76
77 #ifdef HAVE_CONFIG_H
78 #include "config.h"
79 #endif
80
81 #include "gstav1parser.h"
82
83 #include <gst/base/gstbitreader.h>
84
85 #include <string.h>
86 #include <stdlib.h>
87
88 #ifndef GST_DISABLE_GST_DEBUG
89 #define GST_CAT_DEFAULT gst_av1_debug_category_get ()
90 static GstDebugCategory *
gst_av1_debug_category_get(void)91 gst_av1_debug_category_get (void)
92 {
93 static gsize cat_gonce = 0;
94
95 if (g_once_init_enter (&cat_gonce)) {
96 GstDebugCategory *cat = NULL;
97
98 GST_DEBUG_CATEGORY_INIT (cat, "codecparsers_av1", 0, "av1 parse library");
99
100 g_once_init_leave (&cat_gonce, (gsize) cat);
101 }
102
103 return (GstDebugCategory *) cat_gonce;
104 }
105 #endif /* GST_DISABLE_GST_DEBUG */
106
107 #define AV1_READ_BIT(br) ((guint8) gst_bit_reader_get_bits_uint32_unchecked (br, 1))
108 #define AV1_READ_UINT8(br) ((guint8) gst_bit_reader_get_bits_uint32_unchecked (br, 8))
109 #define AV1_READ_UINT16(br) ((guint16) gst_bit_reader_get_bits_uint32_unchecked (br, 16))
110 #define AV1_READ_UINT32(br) gst_bit_reader_get_bits_uint32_unchecked (br, 32)
111 #define AV1_READ_UINT64(br) gst_bit_reader_get_bits_uint64_unchecked (br, 64)
112 #define AV1_READ_BITS(br, nbits) \
113 ((nbits <= 32) ? (gst_bit_reader_get_bits_uint32_unchecked (br, nbits)) : \
114 (gst_bit_reader_get_bits_uint64_unchecked (br, nbits)))
115
116 static guint64
av1_read_bits_checked(GstBitReader * br,guint nbits,GstAV1ParserResult * retval,const char * func_name,gint line)117 av1_read_bits_checked (GstBitReader * br, guint nbits,
118 GstAV1ParserResult * retval, const char *func_name, gint line)
119 {
120 guint64 read_bits = 0;
121 gboolean result;
122
123 if (nbits <= 64)
124 result = gst_bit_reader_get_bits_uint64 (br, &read_bits, nbits);
125 else
126 result = FALSE;
127
128 if (result == TRUE) {
129 *retval = GST_AV1_PARSER_OK;
130 return read_bits;
131 } else {
132 *retval = GST_AV1_PARSER_NO_MORE_DATA;
133 GST_WARNING ("Read %d bits failed in func: %s, line %d", nbits, func_name,
134 line);
135 return 0;
136 }
137 }
138
139 #define AV1_READ_BIT_CHECKED(br, ret) \
140 ((guint8) av1_read_bits_checked (br, 1, ret, __func__, __LINE__))
141 #define AV1_READ_UINT8_CHECKED(br, ret) \
142 ((guint8) av1_read_bits_checked (br, 8, ret, __func__, __LINE__))
143 #define AV1_READ_UINT16_CHECKED(br, ret) \
144 ((guint16) av1_read_bits_checked (br, 16, ret, __func__, __LINE__))
145 #define AV1_READ_UINT32_CHECKED(br, ret) \
146 ((guint32) av1_read_bits_checked (br, 32, ret, __func__, __LINE__))
147 #define AV1_READ_BITS_CHECKED(br, nbits, ret) \
148 av1_read_bits_checked (br, nbits, ret, __func__, __LINE__)
149
150 #define AV1_REMAINING_BYTES(br) (gst_bit_reader_get_remaining (br) / 8)
151 #define AV1_REMAINING_BITS(br) (gst_bit_reader_get_remaining (br))
152
153 /*************************************
154 * *
155 * Helperfunctions *
156 * *
157 *************************************/
158
159 /* 4.7
160 *
161 * floor of the base 2 logarithm of the input x */
162 static gint
av1_helpers_floor_log2(guint32 x)163 av1_helpers_floor_log2 (guint32 x)
164 {
165 gint s = 0;
166
167 while (x != 0) {
168 x = x >> 1;
169 s++;
170 }
171 return s - 1;
172 }
173
174 /* 5.9.16 Tile size calculation
175 *
176 * returns the smallest value for k such that blkSize << k is greater
177 * than or equal to target */
178 static gint
av1_helper_tile_log2(gint blkSize,gint target)179 av1_helper_tile_log2 (gint blkSize, gint target)
180 {
181 gint k;
182 for (k = 0; (blkSize << k) < target; k++);
183 return k;
184 }
185
186 /* 5.9.29 */
187 static gint
av1_helper_inverse_recenter(gint r,gint v)188 av1_helper_inverse_recenter (gint r, gint v)
189 {
190 if (v > 2 * r)
191 return v;
192 else if (v & 1)
193 return r - ((v + 1) >> 1);
194 else
195 return r + (v >> 1);
196 }
197
198 /* Shift down with rounding for use when n >= 0, value >= 0 */
199 static guint64
av1_helper_round_power_of_two(guint64 value,guint16 n)200 av1_helper_round_power_of_two (guint64 value, guint16 n)
201 {
202 return (value + (((guint64) (1) << n) >> 1)) >> n;
203 }
204
205 /* Shift down with rounding for signed integers, for use when n >= 0 */
206 static gint64
av1_helper_round_power_of_two_signed(gint64 value,guint16 n)207 av1_helper_round_power_of_two_signed (gint64 value, guint16 n)
208 {
209 return (value < 0) ? -((gint64) (av1_helper_round_power_of_two (-value, n)))
210 : (gint64) av1_helper_round_power_of_two (value, n);
211 }
212
213 static gint
av1_helper_msb(guint n)214 av1_helper_msb (guint n)
215 {
216 int log = 0;
217 guint value = n;
218 int i;
219
220 g_assert (n != 0);
221
222 for (i = 4; i >= 0; --i) {
223 const gint shift = (1 << i);
224 const guint x = value >> shift;
225 if (x != 0) {
226 value = x;
227 log += shift;
228 }
229 }
230 return log;
231 }
232
233 static const guint16 div_lut[GST_AV1_DIV_LUT_NUM + 1] = {
234 16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,
235 15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,
236 15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,
237 14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,
238 13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,
239 13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,
240 13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,
241 12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,
242 12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,
243 11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,
244 11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,
245 11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,
246 10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
247 10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,
248 10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986,
249 9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732,
250 9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489,
251 9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259,
252 9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039,
253 9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830,
254 8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630,
255 8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439,
256 8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257,
257 8240, 8224, 8208, 8192,
258 };
259
260 static gint16
av1_helper_resolve_divisor_32(guint32 D,gint16 * shift)261 av1_helper_resolve_divisor_32 (guint32 D, gint16 * shift)
262 {
263 gint32 f;
264 gint32 e;
265
266 *shift = av1_helper_msb (D);
267 // e is obtained from D after resetting the most significant 1 bit.
268 e = D - ((guint32) 1 << *shift);
269 // Get the most significant DIV_LUT_BITS (8) bits of e into f
270 if (*shift > GST_AV1_DIV_LUT_BITS)
271 f = av1_helper_round_power_of_two (e, *shift - GST_AV1_DIV_LUT_BITS);
272 else
273 f = e << (GST_AV1_DIV_LUT_BITS - *shift);
274 g_assert (f <= GST_AV1_DIV_LUT_NUM);
275 *shift += GST_AV1_DIV_LUT_PREC_BITS;
276 // Use f as lookup into the precomputed table of multipliers
277 return div_lut[f];
278 }
279
280 /*************************************
281 * *
282 * Bitstream Functions *
283 * *
284 *************************************/
285 /* 4.10.5
286 *
287 * Unsigned integer represented by a variable number of little-endian
288 * bytes. */
289 static guint32
av1_bitstreamfn_leb128(GstBitReader * br,GstAV1ParserResult * retval)290 av1_bitstreamfn_leb128 (GstBitReader * br, GstAV1ParserResult * retval)
291 {
292 guint8 leb128_byte = 0;
293 guint64 value = 0;
294 gint i;
295
296 for (i = 0; i < 8; i++) {
297 leb128_byte = AV1_READ_UINT8_CHECKED (br, retval);
298 if (*retval != GST_AV1_PARSER_OK)
299 return 0;
300
301 value |= (((gint) leb128_byte & 0x7f) << (i * 7));
302 if (!(leb128_byte & 0x80))
303 break;
304 }
305
306 /* check for bitstream conformance see chapter4.10.5 */
307 if (value < G_MAXUINT32) {
308 return (guint32) value;
309 } else {
310 GST_WARNING ("invalid leb128");
311 *retval = GST_AV1_PARSER_BITSTREAM_ERROR;
312 return 0;
313 }
314 }
315
316 /* 4.10.3
317 *
318 * Variable length unsigned n-bit number appearing directly in the
319 * bitstream */
320 static guint32
av1_bitstreamfn_uvlc(GstBitReader * br,GstAV1ParserResult * retval)321 av1_bitstreamfn_uvlc (GstBitReader * br, GstAV1ParserResult * retval)
322 {
323 guint8 leadingZero = 0;
324 guint32 readv;
325 guint32 value;
326 gboolean done;
327
328 while (1) {
329 done = AV1_READ_BIT_CHECKED (br, retval);
330 if (*retval != GST_AV1_PARSER_OK) {
331 GST_WARNING ("invalid uvlc");
332 return 0;
333 }
334
335 if (done)
336 break;
337 leadingZero++;
338 }
339
340 if (leadingZero >= 32) {
341 value = G_MAXUINT32;
342 return value;
343 }
344 readv = AV1_READ_BITS_CHECKED (br, leadingZero, retval);
345 if (*retval != GST_AV1_PARSER_OK) {
346 GST_WARNING ("invalid uvlc");
347 return 0;
348 }
349
350 value = readv + (1 << leadingZero) - 1;
351
352 return value;
353 }
354
355 /* 4.10.6
356 *
357 * Signed integer converted from an n bits unsigned integer in the
358 * bitstream */
359 static guint32
av1_bitstreamfn_su(GstBitReader * br,guint8 n,GstAV1ParserResult * retval)360 av1_bitstreamfn_su (GstBitReader * br, guint8 n, GstAV1ParserResult * retval)
361 {
362 guint32 v, signMask;
363
364 v = AV1_READ_BITS_CHECKED (br, n, retval);
365 if (*retval != GST_AV1_PARSER_OK)
366 return 0;
367
368 signMask = 1 << (n - 1);
369 if (v & signMask)
370 return v - 2 * signMask;
371 else
372 return v;
373 }
374
375 /* 4.10.7
376 *
377 * Unsigned encoded integer with maximum number of values n */
378 static guint32
av1_bitstreamfn_ns(GstBitReader * br,guint32 n,GstAV1ParserResult * retval)379 av1_bitstreamfn_ns (GstBitReader * br, guint32 n, GstAV1ParserResult * retval)
380 {
381 gint w, m, v;
382 gint extra_bit;
383
384 w = av1_helpers_floor_log2 (n) + 1;
385 m = (1 << w) - n;
386 v = AV1_READ_BITS_CHECKED (br, w - 1, retval);
387 if (*retval != GST_AV1_PARSER_OK)
388 return 0;
389
390 if (v < m)
391 return v;
392 extra_bit = AV1_READ_BITS_CHECKED (br, 1, retval);
393 if (*retval != GST_AV1_PARSER_OK)
394 return 0;
395
396 return (v << 1) - m + extra_bit;
397 }
398
399 /* 4.10.4
400 *
401 * Unsigned little-endian n-byte number appearing directly in the
402 * bitstream */
403 static guint
av1_bitstreamfn_le(GstBitReader * br,guint8 n,GstAV1ParserResult * retval)404 av1_bitstreamfn_le (GstBitReader * br, guint8 n, GstAV1ParserResult * retval)
405 {
406 guint t = 0;
407 guint8 byte;
408 gint i;
409
410 for (i = 0; i < n; i++) {
411 byte = AV1_READ_BITS_CHECKED (br, 8, retval);
412 if (*retval != GST_AV1_PARSER_OK)
413 return 0;
414
415 t += (byte << (i * 8));
416 }
417 return t;
418 }
419
420 /* 5.9.13
421 *
422 * Delta quantizer */
423 static gint8
av1_bitstreamfn_delta_q(GstBitReader * br,GstAV1ParserResult * retval)424 av1_bitstreamfn_delta_q (GstBitReader * br, GstAV1ParserResult * retval)
425 {
426 guint8 delta_coded;
427
428 delta_coded = AV1_READ_BIT_CHECKED (br, retval);
429 if (*retval != GST_AV1_PARSER_OK)
430 return 0;
431
432 if (delta_coded) {
433 gint delta_q = av1_bitstreamfn_su (br, 7, retval);
434 if (*retval != GST_AV1_PARSER_OK)
435 return 0;
436 return delta_q;
437 } else {
438 return 0;
439 }
440
441 return 0;
442 }
443
444 /* 5.3.4 */
445 static GstAV1ParserResult
av1_bitstreamfn_trailing_bits(GstBitReader * br,guint32 nbBits)446 av1_bitstreamfn_trailing_bits (GstBitReader * br, guint32 nbBits)
447 {
448 guint8 trailing_one_bit, trailing_zero_bit;
449
450 g_assert (nbBits);
451
452 trailing_one_bit = AV1_READ_BIT (br);
453 if (trailing_one_bit != 1) {
454 return GST_AV1_PARSER_BITSTREAM_ERROR;
455 }
456
457 nbBits--;
458 while (nbBits > 0) {
459 trailing_zero_bit = AV1_READ_BIT (br);
460 if (trailing_zero_bit != 0)
461 return GST_AV1_PARSER_BITSTREAM_ERROR;
462 nbBits--;
463 }
464
465 return GST_AV1_PARSER_OK;
466 }
467
468 static GstAV1ParserResult
av1_skip_trailing_bits(GstAV1Parser * parser,GstBitReader * br,GstAV1OBU * obu)469 av1_skip_trailing_bits (GstAV1Parser * parser, GstBitReader * br,
470 GstAV1OBU * obu)
471 {
472 guint32 payloadBits = gst_bit_reader_get_pos (br);
473 GstAV1ParserResult ret;
474
475 if (obu->obu_size > 0
476 && obu->obu_type != GST_AV1_OBU_TILE_GROUP
477 && obu->obu_type != GST_AV1_OBU_TILE_LIST
478 && obu->obu_type != GST_AV1_OBU_FRAME) {
479 if (payloadBits >= obu->obu_size * 8)
480 return GST_AV1_PARSER_NO_MORE_DATA;
481
482 ret = av1_bitstreamfn_trailing_bits (br, obu->obu_size * 8 - payloadBits);
483 if (ret != GST_AV1_PARSER_OK)
484 return ret;
485 }
486 return GST_AV1_PARSER_OK;
487 }
488
489 static gboolean
av1_seq_level_idx_is_valid(GstAV1SeqLevels seq_level_idx)490 av1_seq_level_idx_is_valid (GstAV1SeqLevels seq_level_idx)
491 {
492 return seq_level_idx == GST_AV1_SEQ_LEVEL_MAX
493 || (seq_level_idx < GST_AV1_SEQ_LEVELS
494 /* The following levels are currently undefined. */
495 && seq_level_idx != GST_AV1_SEQ_LEVEL_2_2
496 && seq_level_idx != GST_AV1_SEQ_LEVEL_2_3
497 && seq_level_idx != GST_AV1_SEQ_LEVEL_3_2
498 && seq_level_idx != GST_AV1_SEQ_LEVEL_3_3
499 && seq_level_idx != GST_AV1_SEQ_LEVEL_4_2
500 && seq_level_idx != GST_AV1_SEQ_LEVEL_4_3
501 && seq_level_idx != GST_AV1_SEQ_LEVEL_7_0
502 && seq_level_idx != GST_AV1_SEQ_LEVEL_7_1
503 && seq_level_idx != GST_AV1_SEQ_LEVEL_7_2
504 && seq_level_idx != GST_AV1_SEQ_LEVEL_7_3);
505 }
506
507 static void
av1_parser_init_sequence_header(GstAV1SequenceHeaderOBU * seq_header)508 av1_parser_init_sequence_header (GstAV1SequenceHeaderOBU * seq_header)
509 {
510 memset (seq_header, 0, sizeof (*seq_header));
511 seq_header->bit_depth = 8;
512 seq_header->num_planes = 1;
513 }
514
515 /*************************************
516 * *
517 * Parser Functions *
518 * *
519 *************************************/
520 static void
gst_av1_parse_reset_state(GstAV1Parser * parser,gboolean free_sps)521 gst_av1_parse_reset_state (GstAV1Parser * parser, gboolean free_sps)
522 {
523 parser->state.begin_first_frame = FALSE;
524
525 parser->state.prev_frame_id = 0;
526 parser->state.current_frame_id = 0;
527 memset (&parser->state.ref_info, 0, sizeof (parser->state.ref_info));
528 parser->state.frame_width = 0;
529 parser->state.frame_height = 0;
530 parser->state.upscaled_width = 0;
531 parser->state.mi_cols = 0;
532 parser->state.mi_rows = 0;
533 parser->state.render_width = 0;
534 parser->state.render_height = 0;
535
536 memset (parser->state.mi_col_starts, 0, sizeof (parser->state.mi_col_starts));
537 memset (parser->state.mi_row_starts, 0, sizeof (parser->state.mi_row_starts));
538
539 parser->state.tile_cols_log2 = 0;
540 parser->state.tile_cols = 0;
541 parser->state.tile_rows_log2 = 0;
542 parser->state.tile_rows = 0;
543 parser->state.tile_size_bytes = 0;
544
545 parser->state.seen_frame_header = 0;
546
547 if (free_sps) {
548 parser->state.sequence_changed = FALSE;
549
550 if (parser->seq_header) {
551 g_slice_free (GstAV1SequenceHeaderOBU, parser->seq_header);
552 parser->seq_header = NULL;
553 }
554 }
555 }
556
557 /**
558 * gst_av1_parser_reset:
559 * @parser: the #GstAV1Parser
560 * @annex_b: indicate whether conforms to annex b
561 *
562 * Reset the current #GstAV1Parser's state totally.
563 *
564 * Since: 1.18
565 */
566 void
gst_av1_parser_reset(GstAV1Parser * parser,gboolean annex_b)567 gst_av1_parser_reset (GstAV1Parser * parser, gboolean annex_b)
568 {
569 g_return_if_fail (parser != NULL);
570
571 parser->annex_b = annex_b;
572 if (parser->annex_b)
573 gst_av1_parser_reset_annex_b (parser);
574
575 gst_av1_parse_reset_state (parser, TRUE);
576 }
577
578 /**
579 * gst_av1_parser_reset_annex_b:
580 * @parser: the #GstAV1Parser
581 *
582 * Only reset the current #GstAV1Parser's annex b context.
583 * The other part of the state is kept.
584 *
585 * Since: 1.20
586 */
587 void
gst_av1_parser_reset_annex_b(GstAV1Parser * parser)588 gst_av1_parser_reset_annex_b (GstAV1Parser * parser)
589 {
590 g_return_if_fail (parser != NULL);
591 g_return_if_fail (parser->annex_b);
592
593 if (parser->temporal_unit_consumed < parser->temporal_unit_size)
594 GST_DEBUG ("temporal_unit_consumed: %d, temporal_unit_size:%d, "
595 "discard the left %d bytes for a temporal_unit.",
596 parser->temporal_unit_consumed, parser->temporal_unit_size,
597 parser->temporal_unit_size - parser->temporal_unit_consumed);
598
599 if (parser->frame_unit_consumed < parser->frame_unit_size)
600 GST_DEBUG (" frame_unit_consumed %d, frame_unit_size: %d "
601 "discard the left %d bytes for a frame_unit.",
602 parser->frame_unit_consumed, parser->frame_unit_size,
603 parser->frame_unit_size - parser->frame_unit_consumed);
604
605 parser->temporal_unit_consumed = 0;
606 parser->temporal_unit_size = 0;
607 parser->frame_unit_consumed = 0;
608 parser->frame_unit_size = 0;
609 }
610
611 /* 5.3.2 */
612 static GstAV1ParserResult
gst_av1_parse_obu_header(GstAV1Parser * parser,GstBitReader * br,GstAV1OBUHeader * obu_header)613 gst_av1_parse_obu_header (GstAV1Parser * parser, GstBitReader * br,
614 GstAV1OBUHeader * obu_header)
615 {
616 guint8 obu_forbidden_bit;
617 guint8 obu_reserved_1bit;
618 guint8 obu_extension_header_reserved_3bits;
619 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
620
621 if (AV1_REMAINING_BYTES (br) < 1) {
622 ret = GST_AV1_PARSER_NO_MORE_DATA;
623 goto error;
624 }
625
626 obu_forbidden_bit = AV1_READ_BIT (br);
627 if (obu_forbidden_bit != 0) {
628 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
629 goto error;
630 }
631
632 obu_header->obu_type = AV1_READ_BITS (br, 4);
633 obu_header->obu_extention_flag = AV1_READ_BIT (br);
634 obu_header->obu_has_size_field = AV1_READ_BIT (br);
635 obu_reserved_1bit = AV1_READ_BIT (br);
636 if (obu_reserved_1bit != 0) {
637 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
638 goto error;
639 }
640
641 if (obu_header->obu_extention_flag) {
642 if (AV1_REMAINING_BYTES (br) < 1) {
643 ret = GST_AV1_PARSER_NO_MORE_DATA;
644 goto error;
645 }
646
647 /* 5.3.3 OBU extension header */
648 obu_header->obu_temporal_id = AV1_READ_BITS (br, 3);
649 obu_header->obu_spatial_id = AV1_READ_BITS (br, 2);
650 obu_extension_header_reserved_3bits = AV1_READ_BITS (br, 3);
651 if (obu_extension_header_reserved_3bits != 0) {
652 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
653 goto error;
654 }
655 }
656
657 return GST_AV1_PARSER_OK;
658
659 error:
660 GST_WARNING ("parse OBU header error %d", ret);
661 return ret;
662 }
663
664 /**
665 * gst_av1_parser_identify_one_obu:
666 * @parser: the #GstAV1Parser
667 * @data: the data to parse
668 * @size: the size of @data
669 * @obu: a #GstAV1OBU to store the identified result
670 * @consumed: (out): the consumed data size
671 *
672 * Identify one @obu's type from the incoming data stream. This function
673 * should be called first to know the type of @obu before other parse APIs.
674 *
675 * Returns: The #GstAV1ParserResult.
676 *
677 * Since: 1.18
678 */
679 GstAV1ParserResult
gst_av1_parser_identify_one_obu(GstAV1Parser * parser,const guint8 * data,guint32 size,GstAV1OBU * obu,guint32 * consumed)680 gst_av1_parser_identify_one_obu (GstAV1Parser * parser, const guint8 * data,
681 guint32 size, GstAV1OBU * obu, guint32 * consumed)
682 {
683 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
684 GstBitReader br;
685 guint obu_length = 0;
686 guint32 used;
687
688 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
689 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
690 g_return_val_if_fail (data != NULL, GST_AV1_PARSER_INVALID_OPERATION);
691 g_return_val_if_fail (consumed != NULL, GST_AV1_PARSER_INVALID_OPERATION);
692
693 *consumed = 0;
694 memset (obu, 0, sizeof (*obu));
695
696 if (parser->annex_b) {
697 GST_LOG ("temporal_unit_consumed: %d, temporal_unit_size:%d,"
698 " frame_unit_consumed %d, frame_unit_size: %d",
699 parser->temporal_unit_consumed, parser->temporal_unit_size,
700 parser->frame_unit_consumed, parser->frame_unit_size);
701 }
702
703 if (!size) {
704 return ret = GST_AV1_PARSER_NO_MORE_DATA;
705 goto error;
706 }
707
708 /* parse the data size if annex_b */
709 if (parser->annex_b) {
710 guint last_pos;
711 annex_b_again:
712 last_pos = 0;
713
714 if (*consumed > size)
715 goto error;
716 if (*consumed == size) {
717 ret = GST_AV1_PARSER_NO_MORE_DATA;
718 goto error;
719 }
720 gst_bit_reader_init (&br, data + *consumed, size - *consumed);
721
722 if (parser->temporal_unit_consumed > parser->temporal_unit_size)
723 goto error;
724
725 if (parser->temporal_unit_consumed &&
726 parser->temporal_unit_consumed == parser->temporal_unit_size) {
727 GST_LOG ("Complete a temporal unit of size %d",
728 parser->temporal_unit_size);
729 parser->temporal_unit_consumed = parser->temporal_unit_size = 0;
730 }
731
732 if (parser->temporal_unit_size == 0) {
733 parser->temporal_unit_size = av1_bitstreamfn_leb128 (&br, &ret);
734 if (ret != GST_AV1_PARSER_OK)
735 goto error;
736
737 g_assert (gst_bit_reader_get_pos (&br) % 8 == 0);
738 used = (gst_bit_reader_get_pos (&br) / 8 - last_pos);
739 last_pos = gst_bit_reader_get_pos (&br) / 8;
740 *consumed += used;
741
742 if (parser->temporal_unit_consumed == parser->temporal_unit_size) {
743 /* Some extreme case like a temporal unit just
744 hold a temporal_unit_size = 0 */
745 goto annex_b_again;
746 }
747 }
748
749 if (parser->frame_unit_consumed > parser->frame_unit_size)
750 goto error;
751
752 if (parser->frame_unit_consumed &&
753 parser->frame_unit_consumed == parser->frame_unit_size) {
754 GST_LOG ("Complete a frame unit of size %d", parser->frame_unit_size);
755 parser->frame_unit_size = parser->frame_unit_consumed = 0;
756 }
757
758 if (parser->frame_unit_size == 0) {
759 parser->frame_unit_size = av1_bitstreamfn_leb128 (&br, &ret);
760 if (ret != GST_AV1_PARSER_OK)
761 goto error;
762
763 g_assert (gst_bit_reader_get_pos (&br) % 8 == 0);
764 used = gst_bit_reader_get_pos (&br) / 8 - last_pos;
765 last_pos = gst_bit_reader_get_pos (&br) / 8;
766 *consumed += used;
767 parser->temporal_unit_consumed += used;
768
769 if (parser->frame_unit_size >
770 parser->temporal_unit_size - parser->temporal_unit_consumed) {
771 GST_INFO ("Error stream, frame unit size %d, bigger than the left"
772 "temporal unit size %d", parser->frame_unit_size,
773 parser->temporal_unit_size - parser->temporal_unit_consumed);
774 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
775 goto error;
776 }
777
778 if (parser->temporal_unit_consumed == parser->temporal_unit_size ||
779 parser->frame_unit_consumed == parser->frame_unit_size) {
780 /* Some extreme case like a temporal unit just hold a frame_unit_size,
781 or a frame unit just hold frame_unit_size = 0 */
782 goto annex_b_again;
783 }
784 }
785
786 obu_length = av1_bitstreamfn_leb128 (&br, &ret);
787 if (ret != GST_AV1_PARSER_OK)
788 goto error;
789
790 if (obu_length > parser->frame_unit_size - parser->frame_unit_consumed) {
791 GST_INFO ("Error stream, obu_length is %d, bigger than the left"
792 "frame unit size %d", obu_length,
793 parser->frame_unit_size - parser->frame_unit_consumed);
794 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
795 goto error;
796 }
797 /* update the consumed */
798 used = gst_bit_reader_get_pos (&br) / 8 - last_pos;
799 last_pos = gst_bit_reader_get_pos (&br) / 8;
800 *consumed += used;
801 parser->temporal_unit_consumed += used;
802 parser->frame_unit_consumed += used;
803
804 if (obu_length == 0) {
805 /* An empty obu? let continue to the next */
806 ret = GST_AV1_PARSER_DROP;
807 goto error;
808 }
809 }
810
811 if (*consumed > size)
812 goto error;
813 if (*consumed == size) {
814 ret = GST_AV1_PARSER_NO_MORE_DATA;
815 goto error;
816 }
817 gst_bit_reader_init (&br, data + *consumed, size - *consumed);
818
819 ret = gst_av1_parse_obu_header (parser, &br, &obu->header);
820 if (ret != GST_AV1_PARSER_OK)
821 goto error;
822
823 obu->obu_type = obu->header.obu_type;
824 GST_LOG ("identify obu type is %d", obu->obu_type);
825
826 if (obu->header.obu_has_size_field) {
827 guint size_sz = gst_bit_reader_get_pos (&br) / 8;
828
829 obu->obu_size = av1_bitstreamfn_leb128 (&br, &ret);
830 if (ret != GST_AV1_PARSER_OK)
831 goto error;
832
833 size_sz = gst_bit_reader_get_pos (&br) / 8 - size_sz;
834 if (obu_length
835 && obu_length - 1 - obu->header.obu_extention_flag - size_sz !=
836 obu->obu_size) {
837 /* If obu_size and obu_length are both present, but inconsistent,
838 then the packed bitstream is deemed invalid. */
839 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
840 goto error;
841 }
842
843 if (AV1_REMAINING_BYTES (&br) < obu->obu_size) {
844 ret = GST_AV1_PARSER_NO_MORE_DATA;
845 goto error;
846 }
847 } else {
848 if (obu_length == 0) {
849 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
850 goto error;
851 }
852
853 obu->obu_size = obu_length - 1 - obu->header.obu_extention_flag;
854 }
855
856 g_assert (gst_bit_reader_get_pos (&br) % 8 == 0);
857 used = gst_bit_reader_get_pos (&br) / 8;
858 /* fail if not a complete obu */
859 if (size - *consumed - used < obu->obu_size) {
860 ret = GST_AV1_PARSER_NO_MORE_DATA;
861 goto error;
862 }
863
864 /* update the consumed */
865 *consumed += used;
866 if (parser->annex_b) {
867 parser->temporal_unit_consumed += used;
868 parser->frame_unit_consumed += used;
869 }
870
871 obu->data = (guint8 *) (data + *consumed);
872
873 *consumed += obu->obu_size;
874 if (parser->annex_b) {
875 parser->temporal_unit_consumed += obu->obu_size;
876 parser->frame_unit_consumed += obu->obu_size;
877 }
878
879 if (obu->obu_type != GST_AV1_OBU_SEQUENCE_HEADER
880 && obu->obu_type != GST_AV1_OBU_TEMPORAL_DELIMITER
881 && parser->state.operating_point_idc && obu->header.obu_extention_flag) {
882 guint32 inTemporalLayer =
883 (parser->state.operating_point_idc >> obu->header.obu_temporal_id) & 1;
884 guint32 inSpatialLayer =
885 (parser->state.operating_point_idc >> (obu->header.obu_spatial_id +
886 8)) & 1;
887 if (!inTemporalLayer || !inSpatialLayer) {
888 ret = GST_AV1_PARSER_DROP;
889 goto error;
890 }
891 }
892
893 return GST_AV1_PARSER_OK;
894
895 error:
896 GST_WARNING ("can not identify obu, error %d", ret);
897 return ret;
898 }
899
900 /* 5.5.2 */
901 static GstAV1ParserResult
gst_av1_parse_color_config(GstAV1Parser * parser,GstBitReader * br,GstAV1SequenceHeaderOBU * seq_header,GstAV1ColorConfig * color_config)902 gst_av1_parse_color_config (GstAV1Parser * parser, GstBitReader * br,
903 GstAV1SequenceHeaderOBU * seq_header, GstAV1ColorConfig * color_config)
904 {
905 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
906
907 color_config->high_bitdepth = AV1_READ_BIT_CHECKED (br, &ret);
908 if (ret != GST_AV1_PARSER_OK)
909 goto error;
910
911 if (seq_header->seq_profile == GST_AV1_PROFILE_2
912 && color_config->high_bitdepth) {
913 color_config->twelve_bit = AV1_READ_BIT_CHECKED (br, &ret);
914 if (ret != GST_AV1_PARSER_OK)
915 goto error;
916
917 seq_header->bit_depth = color_config->twelve_bit ? 12 : 10;
918 } else if (seq_header->seq_profile <= GST_AV1_PROFILE_2) {
919 seq_header->bit_depth = color_config->high_bitdepth ? 10 : 8;
920 } else {
921 GST_INFO ("Unsupported profile/bit-depth combination");
922 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
923 goto error;
924 }
925
926 if (seq_header->seq_profile == GST_AV1_PROFILE_1)
927 color_config->mono_chrome = 0;
928 else {
929 color_config->mono_chrome = AV1_READ_BIT_CHECKED (br, &ret);
930 if (ret != GST_AV1_PARSER_OK)
931 goto error;
932 }
933 seq_header->num_planes = color_config->mono_chrome ? 1 : 3;
934
935 color_config->color_description_present_flag =
936 AV1_READ_BIT_CHECKED (br, &ret);
937 if (ret != GST_AV1_PARSER_OK)
938 goto error;
939
940 if (color_config->color_description_present_flag) {
941 if (AV1_REMAINING_BITS (br) < 8 + 8 + 8) {
942 ret = GST_AV1_PARSER_NO_MORE_DATA;
943 goto error;
944 }
945 color_config->color_primaries = AV1_READ_BITS (br, 8);
946 color_config->transfer_characteristics = AV1_READ_BITS (br, 8);
947 color_config->matrix_coefficients = AV1_READ_BITS (br, 8);
948 } else {
949 color_config->color_primaries = GST_AV1_CP_UNSPECIFIED;
950 color_config->transfer_characteristics = GST_AV1_TC_UNSPECIFIED;
951 color_config->matrix_coefficients = GST_AV1_MC_UNSPECIFIED;
952 }
953
954 if (color_config->mono_chrome) {
955 color_config->color_range = AV1_READ_BIT_CHECKED (br, &ret);
956 if (ret != GST_AV1_PARSER_OK)
957 goto error;
958
959 color_config->subsampling_x = 1;
960 color_config->subsampling_y = 1;
961 color_config->chroma_sample_position = GST_AV1_CSP_UNKNOWN;
962 color_config->separate_uv_delta_q = 0;
963 goto success;
964 } else if (color_config->color_primaries == GST_AV1_CP_BT_709 &&
965 color_config->transfer_characteristics == GST_AV1_TC_SRGB &&
966 color_config->matrix_coefficients == GST_AV1_MC_IDENTITY) {
967 color_config->color_range = 1;
968 color_config->subsampling_x = 0;
969 color_config->subsampling_y = 0;
970 if (!(seq_header->seq_profile == GST_AV1_PROFILE_1 ||
971 (seq_header->seq_profile == GST_AV1_PROFILE_2
972 && seq_header->bit_depth == 12))) {
973 GST_INFO ("sRGB colorspace not compatible with specified profile");
974 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
975 goto error;
976 }
977 } else {
978 color_config->color_range = AV1_READ_BIT_CHECKED (br, &ret);
979 if (ret != GST_AV1_PARSER_OK)
980 goto error;
981
982 if (seq_header->seq_profile == GST_AV1_PROFILE_0) {
983 /* 420 only */
984 color_config->subsampling_x = 1;
985 color_config->subsampling_y = 1;
986 } else if (seq_header->seq_profile == GST_AV1_PROFILE_1) {
987 /* 444 only */
988 color_config->subsampling_x = 0;
989 color_config->subsampling_y = 0;
990 } else {
991 g_assert (seq_header->seq_profile == GST_AV1_PROFILE_2);
992 if (seq_header->bit_depth == 12) {
993 color_config->subsampling_x = AV1_READ_BIT_CHECKED (br, &ret);
994 if (ret != GST_AV1_PARSER_OK)
995 goto error;
996
997 if (color_config->subsampling_x) {
998 /* 422 or 420 */
999 color_config->subsampling_y = AV1_READ_BIT_CHECKED (br, &ret);
1000 if (ret != GST_AV1_PARSER_OK)
1001 goto error;
1002 } else
1003 /* 444 */
1004 color_config->subsampling_y = 0;
1005 } else {
1006 /* 422 */
1007 color_config->subsampling_x = 1;
1008 color_config->subsampling_y = 0;
1009 }
1010 }
1011
1012 if (color_config->matrix_coefficients == GST_AV1_MC_IDENTITY &&
1013 (color_config->subsampling_x || color_config->subsampling_y)) {
1014 GST_INFO ("Identity CICP Matrix incompatible with"
1015 " non 4:4:4 color sampling");
1016 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
1017 goto error;
1018 }
1019
1020 if (color_config->subsampling_x && color_config->subsampling_y) {
1021 color_config->chroma_sample_position =
1022 AV1_READ_BITS_CHECKED (br, 2, &ret);
1023 if (ret != GST_AV1_PARSER_OK)
1024 goto error;
1025 }
1026 }
1027
1028 color_config->separate_uv_delta_q = AV1_READ_BIT_CHECKED (br, &ret);
1029 if (ret != GST_AV1_PARSER_OK)
1030 goto error;
1031
1032 if (!(color_config->subsampling_x == 0 && color_config->subsampling_y == 0) &&
1033 !(color_config->subsampling_x == 1 && color_config->subsampling_y == 1) &&
1034 !(color_config->subsampling_x == 1 && color_config->subsampling_y == 0)) {
1035 GST_INFO ("Only 4:4:4, 4:2:2 and 4:2:0 are currently supported, "
1036 "%d %d subsampling is not supported.\n",
1037 color_config->subsampling_x, color_config->subsampling_y);
1038 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
1039 goto error;
1040 }
1041
1042 success:
1043 return GST_AV1_PARSER_OK;
1044
1045 error:
1046 GST_WARNING ("parse color config error %d", ret);
1047 return ret;
1048 }
1049
1050 /* 5.5.3 */
1051 static GstAV1ParserResult
gst_av1_parse_timing_info(GstAV1Parser * parser,GstBitReader * br,GstAV1TimingInfo * timing_info)1052 gst_av1_parse_timing_info (GstAV1Parser * parser, GstBitReader * br,
1053 GstAV1TimingInfo * timing_info)
1054 {
1055 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
1056
1057 if (AV1_REMAINING_BITS (br) < 32 + 32 + 1) {
1058 ret = GST_AV1_PARSER_NO_MORE_DATA;
1059 goto error;
1060 }
1061
1062 timing_info->num_units_in_display_tick = AV1_READ_UINT32 (br);
1063 timing_info->time_scale = AV1_READ_UINT32 (br);
1064 if (timing_info->num_units_in_display_tick == 0 ||
1065 timing_info->time_scale == 0) {
1066 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
1067 goto error;
1068 }
1069
1070 timing_info->equal_picture_interval = AV1_READ_BIT (br);
1071 if (timing_info->equal_picture_interval) {
1072 timing_info->num_ticks_per_picture_minus_1 =
1073 av1_bitstreamfn_uvlc (br, &ret);
1074 if (ret != GST_AV1_PARSER_OK)
1075 goto error;
1076
1077 if (timing_info->num_ticks_per_picture_minus_1 == G_MAXUINT) {
1078 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
1079 goto error;
1080 }
1081 }
1082
1083 return GST_AV1_PARSER_OK;
1084
1085 error:
1086 GST_WARNING ("parse timing info error %d", ret);
1087 return ret;
1088 }
1089
1090 /* 5.5.4 */
1091 static GstAV1ParserResult
gst_av1_parse_decoder_model_info(GstAV1Parser * parser,GstBitReader * br,GstAV1DecoderModelInfo * decoder_model_info)1092 gst_av1_parse_decoder_model_info (GstAV1Parser * parser, GstBitReader * br,
1093 GstAV1DecoderModelInfo * decoder_model_info)
1094 {
1095 if (AV1_REMAINING_BITS (br) < 5 + 32 + 5 + 5)
1096 return GST_AV1_PARSER_NO_MORE_DATA;
1097
1098 decoder_model_info->buffer_delay_length_minus_1 = AV1_READ_BITS (br, 5);
1099 decoder_model_info->num_units_in_decoding_tick = AV1_READ_BITS (br, 32);
1100 decoder_model_info->buffer_removal_time_length_minus_1 =
1101 AV1_READ_BITS (br, 5);
1102 decoder_model_info->frame_presentation_time_length_minus_1 =
1103 AV1_READ_BITS (br, 5);
1104
1105 return GST_AV1_PARSER_OK;
1106 }
1107
1108 /* 5.5.5 */
1109 static GstAV1ParserResult
gst_av1_parse_operating_parameters_info(GstAV1Parser * parser,GstBitReader * br,GstAV1SequenceHeaderOBU * seq_header,GstAV1OperatingPoint * op_point)1110 gst_av1_parse_operating_parameters_info (GstAV1Parser * parser,
1111 GstBitReader * br, GstAV1SequenceHeaderOBU * seq_header,
1112 GstAV1OperatingPoint * op_point)
1113 {
1114 guint32 n = seq_header->decoder_model_info.buffer_delay_length_minus_1 + 1;
1115
1116 if (AV1_REMAINING_BITS (br) < n + n + 1)
1117 return GST_AV1_PARSER_NO_MORE_DATA;
1118
1119 op_point->decoder_buffer_delay = AV1_READ_BITS (br, n);
1120 op_point->encoder_buffer_delay = AV1_READ_BITS (br, n);
1121 op_point->low_delay_mode_flag = AV1_READ_BIT (br);
1122 return GST_AV1_PARSER_OK;
1123 }
1124
1125 /* 5.5.1 General sequence header OBU */
1126 /**
1127 * gst_av1_parser_parse_sequence_header_obu:
1128 * @parser: the #GstAV1Parser
1129 * @obu: a #GstAV1OBU to be parsed
1130 * @seq_header: a #GstAV1SequenceHeaderOBU to store the parsed result.
1131 *
1132 * Parse one sequence header @obu based on the @parser context, store the
1133 * result in the @seq_header.
1134 *
1135 * Returns: The #GstAV1ParserResult.
1136 *
1137 * Since: 1.18
1138 */
1139 GstAV1ParserResult
gst_av1_parser_parse_sequence_header_obu(GstAV1Parser * parser,GstAV1OBU * obu,GstAV1SequenceHeaderOBU * seq_header)1140 gst_av1_parser_parse_sequence_header_obu (GstAV1Parser * parser,
1141 GstAV1OBU * obu, GstAV1SequenceHeaderOBU * seq_header)
1142 {
1143 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
1144 gint i;
1145 GstBitReader bit_reader;
1146 GstBitReader *br = &bit_reader;
1147
1148 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1149 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1150 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_SEQUENCE_HEADER,
1151 GST_AV1_PARSER_INVALID_OPERATION);
1152 g_return_val_if_fail (seq_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1153
1154 av1_parser_init_sequence_header (seq_header);
1155 gst_bit_reader_init (br, obu->data, obu->obu_size);
1156
1157 if (AV1_REMAINING_BITS (br) < 8) {
1158 retval = GST_AV1_PARSER_NO_MORE_DATA;
1159 goto error;
1160 }
1161
1162 seq_header->seq_profile = AV1_READ_BITS (br, 3);
1163 if (seq_header->seq_profile > GST_AV1_PROFILE_2) {
1164 GST_INFO ("Unsupported profile %d", seq_header->seq_profile);
1165 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1166 goto error;
1167 }
1168
1169 seq_header->still_picture = AV1_READ_BIT (br);
1170 seq_header->reduced_still_picture_header = AV1_READ_BIT (br);
1171 if (!seq_header->still_picture && seq_header->reduced_still_picture_header) {
1172 GST_INFO (" If reduced_still_picture_header is equal to 1, it is a"
1173 " requirement of bitstream conformance that still_picture is equal"
1174 " to 1. ");
1175 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1176 goto error;
1177 }
1178
1179 if (seq_header->reduced_still_picture_header) {
1180 seq_header->timing_info_present_flag = 0;
1181 seq_header->decoder_model_info_present_flag = 0;
1182 seq_header->initial_display_delay_present_flag = 0;
1183 seq_header->operating_points_cnt_minus_1 = 0;
1184 seq_header->operating_points[0].idc = 0;
1185 seq_header->operating_points[0].seq_level_idx = AV1_READ_BITS (br, 5);
1186 if (!av1_seq_level_idx_is_valid
1187 (seq_header->operating_points[0].seq_level_idx)) {
1188 GST_INFO ("The seq_level_idx is unsupported");
1189 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1190 goto error;
1191 }
1192 seq_header->operating_points[0].seq_tier = 0;
1193 seq_header->operating_points[0].decoder_model_present_for_this_op = 0;
1194 seq_header->operating_points[0].initial_display_delay_present_for_this_op =
1195 0;
1196 } else {
1197 seq_header->timing_info_present_flag = AV1_READ_BIT (br);
1198
1199 if (seq_header->timing_info_present_flag) {
1200 retval =
1201 gst_av1_parse_timing_info (parser, br, &(seq_header->timing_info));
1202 if (retval != GST_AV1_PARSER_OK)
1203 goto error;
1204
1205 seq_header->decoder_model_info_present_flag =
1206 AV1_READ_BIT_CHECKED (br, &retval);
1207 if (retval != GST_AV1_PARSER_OK)
1208 goto error;
1209
1210 if (seq_header->decoder_model_info_present_flag) {
1211 retval = gst_av1_parse_decoder_model_info (parser, br,
1212 &(seq_header->decoder_model_info));
1213 if (retval != GST_AV1_PARSER_OK)
1214 goto error;
1215 }
1216 } else {
1217 seq_header->decoder_model_info_present_flag = 0;
1218 }
1219
1220 if (AV1_REMAINING_BITS (br) < 6) {
1221 retval = GST_AV1_PARSER_NO_MORE_DATA;
1222 goto error;
1223 }
1224 seq_header->initial_display_delay_present_flag = AV1_READ_BIT (br);
1225 seq_header->operating_points_cnt_minus_1 = AV1_READ_BITS (br, 5);
1226 if (seq_header->operating_points_cnt_minus_1 + 1 >
1227 GST_AV1_MAX_OPERATING_POINTS) {
1228 GST_INFO ("The operating points number %d is too big",
1229 seq_header->operating_points_cnt_minus_1 + 1);
1230 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1231 goto error;
1232 }
1233
1234 for (i = 0; i < seq_header->operating_points_cnt_minus_1 + 1; i++) {
1235 if (AV1_REMAINING_BITS (br) < 17) {
1236 retval = GST_AV1_PARSER_NO_MORE_DATA;
1237 goto error;
1238 }
1239 seq_header->operating_points[i].idc = AV1_READ_BITS (br, 12);
1240 seq_header->operating_points[i].seq_level_idx = AV1_READ_BITS (br, 5);
1241 if (!av1_seq_level_idx_is_valid
1242 (seq_header->operating_points[0].seq_level_idx)) {
1243 GST_INFO ("The seq_level_idx is unsupported");
1244 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1245 goto error;
1246 }
1247 if (seq_header->operating_points[i].seq_level_idx > GST_AV1_SEQ_LEVEL_3_3) {
1248 seq_header->operating_points[i].seq_tier = AV1_READ_BIT (br);
1249 } else {
1250 seq_header->operating_points[i].seq_tier = 0;
1251 }
1252 if (seq_header->decoder_model_info_present_flag) {
1253 seq_header->operating_points[i].decoder_model_present_for_this_op =
1254 AV1_READ_BIT (br);
1255 if (seq_header->operating_points[i].decoder_model_present_for_this_op)
1256 retval =
1257 gst_av1_parse_operating_parameters_info (parser, br, seq_header,
1258 &(seq_header->operating_points[i]));
1259 if (retval != GST_AV1_PARSER_OK)
1260 goto error;
1261 } else {
1262 seq_header->operating_points[i].decoder_model_present_for_this_op = 0;
1263 }
1264
1265 if (seq_header->initial_display_delay_present_flag) {
1266 seq_header->
1267 operating_points[i].initial_display_delay_present_for_this_op =
1268 AV1_READ_BIT_CHECKED (br, &retval);
1269 if (retval != GST_AV1_PARSER_OK)
1270 goto error;
1271
1272 if (seq_header->
1273 operating_points[i].initial_display_delay_present_for_this_op) {
1274 seq_header->operating_points[i].initial_display_delay_minus_1 =
1275 AV1_READ_BITS_CHECKED (br, 4, &retval);
1276 if (retval != GST_AV1_PARSER_OK)
1277 goto error;
1278
1279 if (seq_header->operating_points[i].initial_display_delay_minus_1 +
1280 1 > 10) {
1281 GST_INFO ("AV1 does not support more than 10 decoded frames delay");
1282 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1283 goto error;
1284 }
1285 } else {
1286 seq_header->operating_points[i].initial_display_delay_minus_1 = 9;
1287 }
1288 } else {
1289 seq_header->
1290 operating_points[i].initial_display_delay_present_for_this_op = 0;
1291 seq_header->operating_points[i].initial_display_delay_minus_1 = 9;
1292 }
1293 }
1294 }
1295
1296 /* Let user decide the operatingPoint,
1297 implemented by calling gst_av1_parser_set_operating_point()
1298 operatingPoint = choose_operating_point( )
1299 operating_point_idc = operating_point_idc[ operatingPoint ] */
1300
1301 if (AV1_REMAINING_BITS (br) < 4 + 4 +
1302 (seq_header->frame_width_bits_minus_1 + 1) +
1303 (seq_header->frame_height_bits_minus_1 + 1)) {
1304 retval = GST_AV1_PARSER_NO_MORE_DATA;
1305 goto error;
1306 }
1307
1308 seq_header->frame_width_bits_minus_1 = AV1_READ_BITS (br, 4);
1309 seq_header->frame_height_bits_minus_1 = AV1_READ_BITS (br, 4);
1310 seq_header->max_frame_width_minus_1 =
1311 AV1_READ_BITS (br, seq_header->frame_width_bits_minus_1 + 1);
1312 seq_header->max_frame_height_minus_1 =
1313 AV1_READ_BITS (br, seq_header->frame_height_bits_minus_1 + 1);
1314
1315 if (seq_header->reduced_still_picture_header)
1316 seq_header->frame_id_numbers_present_flag = 0;
1317 else {
1318 seq_header->frame_id_numbers_present_flag =
1319 AV1_READ_BIT_CHECKED (br, &retval);
1320 if (retval != GST_AV1_PARSER_OK)
1321 goto error;
1322 }
1323
1324 if (seq_header->frame_id_numbers_present_flag) {
1325 if (AV1_REMAINING_BITS (br) < 4 + 3) {
1326 retval = GST_AV1_PARSER_NO_MORE_DATA;
1327 goto error;
1328 }
1329 seq_header->delta_frame_id_length_minus_2 = AV1_READ_BITS (br, 4);
1330 seq_header->additional_frame_id_length_minus_1 = AV1_READ_BITS (br, 3);
1331
1332 if (seq_header->additional_frame_id_length_minus_1 + 1 +
1333 seq_header->delta_frame_id_length_minus_2 + 2 > 16) {
1334 GST_INFO ("Invalid frame_id_length");
1335 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
1336 goto error;
1337 }
1338 }
1339
1340 if (AV1_REMAINING_BITS (br) < 3) {
1341 retval = GST_AV1_PARSER_NO_MORE_DATA;
1342 goto error;
1343 }
1344 seq_header->use_128x128_superblock = AV1_READ_BIT (br);
1345 seq_header->enable_filter_intra = AV1_READ_BIT (br);
1346 seq_header->enable_intra_edge_filter = AV1_READ_BIT (br);
1347
1348 if (seq_header->reduced_still_picture_header) {
1349 seq_header->enable_interintra_compound = 0;
1350 seq_header->enable_masked_compound = 0;
1351 seq_header->enable_warped_motion = 0;
1352 seq_header->enable_dual_filter = 0;
1353 seq_header->enable_order_hint = 0;
1354 seq_header->enable_jnt_comp = 0;
1355 seq_header->enable_ref_frame_mvs = 0;
1356 seq_header->seq_force_screen_content_tools =
1357 GST_AV1_SELECT_SCREEN_CONTENT_TOOLS;
1358 seq_header->seq_force_integer_mv = GST_AV1_SELECT_INTEGER_MV;
1359 seq_header->order_hint_bits_minus_1 = -1;
1360 seq_header->order_hint_bits = 0;
1361 } else {
1362 if (AV1_REMAINING_BITS (br) < 5) {
1363 retval = GST_AV1_PARSER_NO_MORE_DATA;
1364 goto error;
1365 }
1366 seq_header->enable_interintra_compound = AV1_READ_BIT (br);
1367 seq_header->enable_masked_compound = AV1_READ_BIT (br);
1368 seq_header->enable_warped_motion = AV1_READ_BIT (br);
1369 seq_header->enable_dual_filter = AV1_READ_BIT (br);
1370 seq_header->enable_order_hint = AV1_READ_BIT (br);
1371 if (seq_header->enable_order_hint) {
1372 if (AV1_REMAINING_BITS (br) < 2) {
1373 retval = GST_AV1_PARSER_NO_MORE_DATA;
1374 goto error;
1375 }
1376 seq_header->enable_jnt_comp = AV1_READ_BIT (br);
1377 seq_header->enable_ref_frame_mvs = AV1_READ_BIT (br);
1378 } else {
1379 seq_header->enable_jnt_comp = 0;
1380 seq_header->enable_ref_frame_mvs = 0;
1381 }
1382
1383 seq_header->seq_choose_screen_content_tools =
1384 AV1_READ_BIT_CHECKED (br, &retval);
1385 if (retval != GST_AV1_PARSER_OK)
1386 goto error;
1387 if (seq_header->seq_choose_screen_content_tools)
1388 seq_header->seq_force_screen_content_tools =
1389 GST_AV1_SELECT_SCREEN_CONTENT_TOOLS;
1390 else {
1391 seq_header->seq_force_screen_content_tools =
1392 AV1_READ_BIT_CHECKED (br, &retval);
1393 if (retval != GST_AV1_PARSER_OK)
1394 goto error;
1395 }
1396
1397 if (seq_header->seq_force_screen_content_tools > 0) {
1398 seq_header->seq_choose_integer_mv = AV1_READ_BIT_CHECKED (br, &retval);
1399 if (retval != GST_AV1_PARSER_OK)
1400 goto error;
1401 if (seq_header->seq_choose_integer_mv)
1402 seq_header->seq_force_integer_mv = GST_AV1_SELECT_INTEGER_MV;
1403 else {
1404 seq_header->seq_force_integer_mv = AV1_READ_BIT_CHECKED (br, &retval);
1405 if (retval != GST_AV1_PARSER_OK)
1406 goto error;
1407 }
1408 } else {
1409 seq_header->seq_force_integer_mv = GST_AV1_SELECT_INTEGER_MV;
1410 }
1411 if (seq_header->enable_order_hint) {
1412 seq_header->order_hint_bits_minus_1 =
1413 AV1_READ_BITS_CHECKED (br, 3, &retval);
1414 if (retval != GST_AV1_PARSER_OK)
1415 goto error;
1416 seq_header->order_hint_bits = seq_header->order_hint_bits_minus_1 + 1;
1417 } else {
1418 seq_header->order_hint_bits_minus_1 = -1;
1419 seq_header->order_hint_bits = 0;
1420 }
1421 }
1422
1423 if (AV1_REMAINING_BITS (br) < 3) {
1424 retval = GST_AV1_PARSER_NO_MORE_DATA;
1425 goto error;
1426 }
1427 seq_header->enable_superres = AV1_READ_BIT (br);
1428 seq_header->enable_cdef = AV1_READ_BIT (br);
1429 seq_header->enable_restoration = AV1_READ_BIT (br);
1430
1431 retval = gst_av1_parse_color_config (parser, br, seq_header,
1432 &seq_header->color_config);
1433 if (retval != GST_AV1_PARSER_OK)
1434 goto error;
1435
1436 seq_header->film_grain_params_present = AV1_READ_BIT_CHECKED (br, &retval);
1437 if (retval != GST_AV1_PARSER_OK)
1438 goto error;
1439
1440 retval = av1_skip_trailing_bits (parser, br, obu);
1441 if (retval != GST_AV1_PARSER_OK)
1442 goto error;
1443
1444 if (parser->seq_header) {
1445 if (!memcmp (parser->seq_header, seq_header,
1446 sizeof (GstAV1SequenceHeaderOBU)))
1447 goto success;
1448
1449 g_slice_free (GstAV1SequenceHeaderOBU, parser->seq_header);
1450 }
1451
1452 parser->seq_header = g_slice_dup (GstAV1SequenceHeaderOBU, seq_header);
1453 gst_av1_parse_reset_state (parser, FALSE);
1454
1455 /* choose_operating_point() set the operating_point */
1456 if (parser->state.operating_point < 0 ||
1457 parser->state.operating_point >
1458 seq_header->operating_points_cnt_minus_1) {
1459 GST_WARNING ("Invalid operating_point %d set by user, just use 0",
1460 parser->state.operating_point);
1461 parser->state.operating_point_idc = seq_header->operating_points[0].idc;
1462 } else {
1463 parser->state.operating_point_idc =
1464 seq_header->operating_points[parser->state.operating_point].idc;
1465 }
1466
1467 parser->state.sequence_changed = TRUE;
1468
1469 success:
1470 return GST_AV1_PARSER_OK;
1471
1472 error:
1473 GST_WARNING ("parse sequence header error %d", retval);
1474 return retval;
1475 }
1476
1477 /* 5.6 */
1478 /**
1479 * gst_av1_parser_parse_temporal_delimiter_obu:
1480 * @parser: the #GstAV1Parser
1481 * @obu: a #GstAV1OBU to be parsed
1482 *
1483 * Parse one temporal delimiter @obu based on the @parser context.
1484 * The temporal delimiter is just delimiter and contains no content.
1485 *
1486 * Returns: The #GstAV1ParserResult.
1487 *
1488 * Since: 1.18
1489 */
1490 GstAV1ParserResult
gst_av1_parser_parse_temporal_delimiter_obu(GstAV1Parser * parser,GstAV1OBU * obu)1491 gst_av1_parser_parse_temporal_delimiter_obu (GstAV1Parser * parser,
1492 GstAV1OBU * obu)
1493 {
1494 GstBitReader bit_reader;
1495 GstAV1ParserResult ret;
1496
1497 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1498 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1499 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_TEMPORAL_DELIMITER,
1500 GST_AV1_PARSER_INVALID_OPERATION);
1501
1502 gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
1503
1504 parser->state.seen_frame_header = 0;
1505
1506 ret = av1_skip_trailing_bits (parser, &bit_reader, obu);
1507 if (ret != GST_AV1_PARSER_OK)
1508 GST_WARNING ("parse temporal delimiter error %d", ret);
1509
1510 return ret;
1511 }
1512
1513 /* 5.8.2 */
1514 static GstAV1ParserResult
gst_av1_parse_metadata_itut_t35(GstAV1Parser * parser,GstBitReader * br,GstAV1MetadataITUT_T35 * itut_t35)1515 gst_av1_parse_metadata_itut_t35 (GstAV1Parser * parser, GstBitReader * br,
1516 GstAV1MetadataITUT_T35 * itut_t35)
1517 {
1518 GstAV1ParserResult ret;
1519
1520 itut_t35->itu_t_t35_country_code = AV1_READ_BITS_CHECKED (br, 8, &ret);
1521 if (ret != GST_AV1_PARSER_OK)
1522 return ret;
1523
1524 if (itut_t35->itu_t_t35_country_code == 0xFF) {
1525 itut_t35->itu_t_t35_country_code_extention_byte =
1526 AV1_READ_BITS_CHECKED (br, 8, &ret);
1527 if (ret != GST_AV1_PARSER_OK)
1528 return ret;
1529 }
1530 /* itu_t_t35_payload_bytes is not defined in specification.
1531 Just skip this part. */
1532
1533 return GST_AV1_PARSER_OK;
1534 }
1535
1536 /* 5.8.3 */
1537 static GstAV1ParserResult
gst_av1_parse_metadata_hdr_cll(GstAV1Parser * parser,GstBitReader * br,GstAV1MetadataHdrCll * hdr_cll)1538 gst_av1_parse_metadata_hdr_cll (GstAV1Parser * parser, GstBitReader * br,
1539 GstAV1MetadataHdrCll * hdr_cll)
1540 {
1541 if (AV1_REMAINING_BITS (br) < 32)
1542 return GST_AV1_PARSER_NO_MORE_DATA;
1543
1544 hdr_cll->max_cll = AV1_READ_UINT16 (br);
1545 hdr_cll->max_fall = AV1_READ_UINT16 (br);
1546
1547 return GST_AV1_PARSER_OK;
1548 }
1549
1550 /* 5.8.4 */
1551 static GstAV1ParserResult
gst_av1_parse_metadata_hdr_mdcv(GstAV1Parser * parser,GstBitReader * br,GstAV1MetadataHdrMdcv * hdr_mdcv)1552 gst_av1_parse_metadata_hdr_mdcv (GstAV1Parser * parser, GstBitReader * br,
1553 GstAV1MetadataHdrMdcv * hdr_mdcv)
1554 {
1555 gint i;
1556
1557 if (AV1_REMAINING_BITS (br) < 3 * (16 + 16) + 16 + 16 + 32 + 32)
1558 return GST_AV1_PARSER_NO_MORE_DATA;
1559
1560 for (i = 0; i < 3; i++) {
1561 hdr_mdcv->primary_chromaticity_x[i] = AV1_READ_UINT16 (br);
1562 hdr_mdcv->primary_chromaticity_y[i] = AV1_READ_UINT16 (br);
1563 }
1564
1565 hdr_mdcv->white_point_chromaticity_x = AV1_READ_UINT16 (br);
1566 hdr_mdcv->white_point_chromaticity_y = AV1_READ_UINT16 (br);
1567
1568 hdr_mdcv->luminance_max = AV1_READ_UINT32 (br);
1569 hdr_mdcv->luminance_min = AV1_READ_UINT32 (br);
1570
1571 return GST_AV1_PARSER_OK;
1572 }
1573
1574 /* 5.8.5 */
1575 static GstAV1ParserResult
gst_av1_parse_metadata_scalability(GstAV1Parser * parser,GstBitReader * br,GstAV1MetadataScalability * scalability)1576 gst_av1_parse_metadata_scalability (GstAV1Parser * parser,
1577 GstBitReader * br, GstAV1MetadataScalability * scalability)
1578 {
1579 gint i, j;
1580 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
1581 guint8 scalability_structure_reserved_3bits;
1582
1583 scalability->scalability_mode_idc = AV1_READ_UINT8_CHECKED (br, &ret);
1584 if (ret != GST_AV1_PARSER_OK)
1585 goto error;
1586
1587 if (scalability->scalability_mode_idc != GST_AV1_SCALABILITY_SS)
1588 goto success;
1589
1590 if (AV1_REMAINING_BITS (br) < 8) {
1591 ret = GST_AV1_PARSER_NO_MORE_DATA;
1592 goto error;
1593 }
1594
1595 /* 5.8.6 */
1596 scalability->spatial_layers_cnt_minus_1 = AV1_READ_BITS (br, 2);
1597 scalability->spatial_layer_dimensions_present_flag = AV1_READ_BIT (br);
1598 scalability->spatial_layer_description_present_flag = AV1_READ_BIT (br);
1599 scalability->temporal_group_description_present_flag = AV1_READ_BIT (br);
1600 scalability_structure_reserved_3bits = AV1_READ_BITS (br, 3);
1601 /* scalability_structure_reserved_3bits: must be set to zero and
1602 be ignored by decoders. */
1603 if (scalability_structure_reserved_3bits) {
1604 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
1605 goto error;
1606 }
1607
1608 if (scalability->spatial_layer_dimensions_present_flag) {
1609 for (i = 0; i <= scalability->spatial_layers_cnt_minus_1; i++) {
1610 if (AV1_REMAINING_BITS (br) < 16 * 2) {
1611 ret = GST_AV1_PARSER_NO_MORE_DATA;
1612 goto error;
1613 }
1614
1615 scalability->spatial_layer_max_width[i] = AV1_READ_UINT16 (br);
1616 scalability->spatial_layer_max_height[i] = AV1_READ_UINT16 (br);
1617 }
1618 }
1619
1620 if (scalability->spatial_layer_description_present_flag) {
1621 for (i = 0; i <= scalability->spatial_layers_cnt_minus_1; i++) {
1622 scalability->spatial_layer_ref_id[i] = AV1_READ_UINT8_CHECKED (br, &ret);
1623 if (ret != GST_AV1_PARSER_OK)
1624 goto error;
1625 }
1626 }
1627
1628 if (scalability->temporal_group_description_present_flag) {
1629 scalability->temporal_group_size = AV1_READ_UINT8_CHECKED (br, &ret);
1630 if (ret != GST_AV1_PARSER_OK)
1631 goto error;
1632
1633 for (i = 0; i < scalability->temporal_group_size; i++) {
1634 if (AV1_REMAINING_BITS (br) < 8) {
1635 ret = GST_AV1_PARSER_NO_MORE_DATA;
1636 goto error;
1637 }
1638
1639 scalability->temporal_group_temporal_id[i] = AV1_READ_BITS (br, 3);
1640 scalability->temporal_group_temporal_switching_up_point_flag[i] =
1641 AV1_READ_BIT (br);
1642 scalability->temporal_group_spatial_switching_up_point_flag[i] =
1643 AV1_READ_BIT (br);
1644 scalability->temporal_group_ref_cnt[i] = AV1_READ_BITS (br, 3);
1645 for (j = 0; j < scalability->temporal_group_ref_cnt[i]; j++) {
1646 scalability->temporal_group_ref_pic_diff[i][j] =
1647 AV1_READ_UINT8_CHECKED (br, &ret);
1648 if (ret != GST_AV1_PARSER_OK)
1649 goto error;
1650 }
1651 }
1652 }
1653
1654 success:
1655 return GST_AV1_PARSER_OK;
1656
1657 error:
1658 GST_WARNING ("parse metadata scalability error %d", ret);
1659 return ret;
1660 }
1661
1662 /* 5.8.7 */
1663 static GstAV1ParserResult
gst_av1_parse_metadata_timecode(GstAV1Parser * parser,GstBitReader * br,GstAV1MetadataTimecode * timecode)1664 gst_av1_parse_metadata_timecode (GstAV1Parser * parser, GstBitReader * br,
1665 GstAV1MetadataTimecode * timecode)
1666 {
1667 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
1668
1669 if (AV1_REMAINING_BITS (br) < 17) {
1670 ret = GST_AV1_PARSER_NO_MORE_DATA;
1671 goto error;
1672 }
1673
1674 timecode->counting_type = AV1_READ_BITS (br, 5);
1675 timecode->full_timestamp_flag = AV1_READ_BIT (br);
1676 timecode->discontinuity_flag = AV1_READ_BIT (br);
1677 timecode->cnt_dropped_flag = AV1_READ_BIT (br);
1678 timecode->n_frames = AV1_READ_BITS (br, 9);
1679
1680 if (timecode->full_timestamp_flag) {
1681 if (AV1_REMAINING_BITS (br) < 17) {
1682 ret = GST_AV1_PARSER_NO_MORE_DATA;
1683 goto error;
1684 }
1685 timecode->seconds_value = AV1_READ_BITS (br, 6);
1686 timecode->minutes_value = AV1_READ_BITS (br, 6);
1687 timecode->hours_value = AV1_READ_BITS (br, 5);
1688 } else {
1689 timecode->seconds_flag = AV1_READ_BIT_CHECKED (br, &ret);
1690 if (ret != GST_AV1_PARSER_OK)
1691 goto error;
1692
1693 if (timecode->seconds_flag) {
1694 if (AV1_REMAINING_BITS (br) < 7) {
1695 ret = GST_AV1_PARSER_NO_MORE_DATA;
1696 goto error;
1697 }
1698 timecode->seconds_value = AV1_READ_BITS (br, 6);
1699 timecode->minutes_flag = AV1_READ_BIT (br);
1700
1701 if (timecode->minutes_flag) {
1702 if (AV1_REMAINING_BITS (br) < 7) {
1703 ret = GST_AV1_PARSER_NO_MORE_DATA;
1704 goto error;
1705 }
1706 timecode->minutes_value = AV1_READ_BITS (br, 6);
1707 timecode->hours_flag = AV1_READ_BIT (br);
1708
1709 if (timecode->hours_flag) {
1710 timecode->hours_value = AV1_READ_BITS_CHECKED (br, 6, &ret);
1711 if (ret != GST_AV1_PARSER_OK)
1712 goto error;
1713 }
1714 }
1715 }
1716 }
1717
1718 timecode->time_offset_length = AV1_READ_BITS_CHECKED (br, 5, &ret);
1719 if (ret != GST_AV1_PARSER_OK)
1720 goto error;
1721
1722 if (timecode->time_offset_length > 0) {
1723 timecode->time_offset_value =
1724 AV1_READ_BITS_CHECKED (br, timecode->time_offset_length, &ret);
1725 if (ret != GST_AV1_PARSER_OK)
1726 goto error;
1727 }
1728
1729 return GST_AV1_PARSER_OK;
1730
1731 error:
1732 GST_WARNING ("parse metadata timecode error %d", ret);
1733 return ret;
1734 }
1735
1736 /* 5.8.1 */
1737 /**
1738 * gst_av1_parser_parse_metadata_obu:
1739 * @parser: the #GstAV1Parser
1740 * @obu: a #GstAV1OBU to be parsed
1741 * @metadata: a #GstAV1MetadataOBU to store the parsed result.
1742 *
1743 * Parse one meta data @obu based on the @parser context.
1744 *
1745 * Returns: The #GstAV1ParserResult.
1746 *
1747 * Since: 1.18
1748 */
1749 GstAV1ParserResult
gst_av1_parser_parse_metadata_obu(GstAV1Parser * parser,GstAV1OBU * obu,GstAV1MetadataOBU * metadata)1750 gst_av1_parser_parse_metadata_obu (GstAV1Parser * parser, GstAV1OBU * obu,
1751 GstAV1MetadataOBU * metadata)
1752 {
1753 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
1754 GstBitReader bit_reader;
1755
1756 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1757 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1758 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_METADATA,
1759 GST_AV1_PARSER_INVALID_OPERATION);
1760 g_return_val_if_fail (metadata != NULL, GST_AV1_PARSER_INVALID_OPERATION);
1761
1762 gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
1763
1764 memset (metadata, 0, sizeof (*metadata));
1765
1766 metadata->metadata_type = av1_bitstreamfn_leb128 (&bit_reader, &retval);
1767 if (retval != GST_AV1_PARSER_OK)
1768 goto error;
1769
1770 switch (metadata->metadata_type) {
1771 case GST_AV1_METADATA_TYPE_ITUT_T35:
1772 retval = gst_av1_parse_metadata_itut_t35 (parser,
1773 &bit_reader, &(metadata->itut_t35));
1774 break;
1775 case GST_AV1_METADATA_TYPE_HDR_CLL:
1776 retval = gst_av1_parse_metadata_hdr_cll (parser,
1777 &bit_reader, &(metadata->hdr_cll));
1778 break;
1779 case GST_AV1_METADATA_TYPE_HDR_MDCV:
1780 retval = gst_av1_parse_metadata_hdr_mdcv (parser,
1781 &bit_reader, &(metadata->hdr_mdcv));
1782 break;
1783 case GST_AV1_METADATA_TYPE_SCALABILITY:
1784 retval = gst_av1_parse_metadata_scalability (parser,
1785 &bit_reader, &(metadata->scalability));
1786 break;
1787 case GST_AV1_METADATA_TYPE_TIMECODE:
1788 retval = gst_av1_parse_metadata_timecode (parser,
1789 &bit_reader, &(metadata->timecode));
1790 break;
1791 default:
1792 return GST_AV1_PARSER_BITSTREAM_ERROR;
1793 }
1794
1795 if (retval != GST_AV1_PARSER_OK)
1796 goto error;
1797
1798 retval = av1_skip_trailing_bits (parser, &bit_reader, obu);
1799 if (retval != GST_AV1_PARSER_OK) {
1800 GST_WARNING ("Metadata type %d may have wrong trailings.",
1801 metadata->metadata_type);
1802 retval = GST_AV1_PARSER_OK;
1803 }
1804
1805 return retval;
1806
1807 error:
1808 GST_WARNING ("parse metadata error %d", retval);
1809 return retval;
1810 }
1811
1812 /* 5.9.8 */
1813 static GstAV1ParserResult
gst_av1_parse_superres_params_compute_image_size(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)1814 gst_av1_parse_superres_params_compute_image_size (GstAV1Parser * parser,
1815 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
1816 {
1817 GstAV1ParserResult ret;
1818 GstAV1SequenceHeaderOBU *seq_header;
1819
1820 g_assert (parser->seq_header);
1821 seq_header = parser->seq_header;
1822
1823 if (seq_header->enable_superres) {
1824 frame_header->use_superres = AV1_READ_BIT_CHECKED (br, &ret);
1825 if (ret != GST_AV1_PARSER_OK)
1826 return ret;
1827 } else {
1828 frame_header->use_superres = 0;
1829 }
1830
1831 if (frame_header->use_superres) {
1832 guint8 coded_denom;
1833 coded_denom = AV1_READ_BITS_CHECKED (br, GST_AV1_SUPERRES_DENOM_BITS, &ret);
1834 if (ret != GST_AV1_PARSER_OK)
1835 return ret;
1836
1837 frame_header->superres_denom = coded_denom + GST_AV1_SUPERRES_DENOM_MIN;
1838 } else {
1839 frame_header->superres_denom = GST_AV1_SUPERRES_NUM;
1840 }
1841 parser->state.upscaled_width = parser->state.frame_width;
1842 parser->state.frame_width =
1843 (parser->state.upscaled_width * GST_AV1_SUPERRES_NUM +
1844 (frame_header->superres_denom / 2)) / frame_header->superres_denom;
1845
1846 /* 5.9.9 compute_image_size */
1847 parser->state.mi_cols = 2 * ((parser->state.frame_width + 7) >> 3);
1848 parser->state.mi_rows = 2 * ((parser->state.frame_height + 7) >> 3);
1849
1850 return GST_AV1_PARSER_OK;
1851 }
1852
1853 /* 5.9.5 */
1854 static GstAV1ParserResult
gst_av1_parse_frame_size(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)1855 gst_av1_parse_frame_size (GstAV1Parser * parser, GstBitReader * br,
1856 GstAV1FrameHeaderOBU * frame_header)
1857 {
1858 GstAV1ParserResult retval;
1859 GstAV1SequenceHeaderOBU *seq_header;
1860
1861 g_assert (parser->seq_header);
1862 seq_header = parser->seq_header;
1863
1864 if (frame_header->frame_size_override_flag) {
1865 guint16 frame_width_minus_1;
1866 guint16 frame_height_minus_1;
1867
1868 if (AV1_REMAINING_BITS (br) <
1869 seq_header->frame_width_bits_minus_1 + 1 +
1870 seq_header->frame_height_bits_minus_1 + 1)
1871 return GST_AV1_PARSER_NO_MORE_DATA;
1872
1873 frame_width_minus_1 =
1874 AV1_READ_BITS (br, seq_header->frame_width_bits_minus_1 + 1);
1875 frame_height_minus_1 =
1876 AV1_READ_BITS (br, seq_header->frame_height_bits_minus_1 + 1);
1877 parser->state.frame_width = frame_width_minus_1 + 1;
1878 parser->state.frame_height = frame_height_minus_1 + 1;
1879 } else {
1880 parser->state.frame_width = seq_header->max_frame_width_minus_1 + 1;
1881 parser->state.frame_height = seq_header->max_frame_height_minus_1 + 1;
1882 }
1883
1884 retval = gst_av1_parse_superres_params_compute_image_size (parser, br,
1885 frame_header);
1886 return retval;
1887 }
1888
1889 /* 5.9.6 */
1890 static GstAV1ParserResult
gst_av1_parse_render_size(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)1891 gst_av1_parse_render_size (GstAV1Parser * parser, GstBitReader * br,
1892 GstAV1FrameHeaderOBU * frame_header)
1893 {
1894 GstAV1ParserResult retval;
1895
1896 frame_header->render_and_frame_size_different =
1897 AV1_READ_BIT_CHECKED (br, &retval);
1898 if (retval != GST_AV1_PARSER_OK)
1899 return retval;
1900
1901 if (frame_header->render_and_frame_size_different) {
1902 guint16 render_width_minus_1;
1903 guint16 render_height_minus_1;
1904
1905 if (AV1_REMAINING_BITS (br) < 16 + 16)
1906 return GST_AV1_PARSER_NO_MORE_DATA;
1907
1908 render_width_minus_1 = AV1_READ_UINT16 (br);
1909 render_height_minus_1 = AV1_READ_UINT16 (br);
1910 parser->state.render_width = render_width_minus_1 + 1;
1911 parser->state.render_height = render_height_minus_1 + 1;
1912 } else {
1913 parser->state.render_width = parser->state.upscaled_width;
1914 parser->state.render_height = parser->state.frame_height;
1915 }
1916
1917 return GST_AV1_PARSER_OK;
1918 }
1919
1920 /* 5.9.7 */
1921 static GstAV1ParserResult
gst_av1_parse_frame_size_with_refs(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)1922 gst_av1_parse_frame_size_with_refs (GstAV1Parser * parser,
1923 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
1924 {
1925 GstAV1ParserResult retval;
1926 GstAV1ReferenceFrameInfo *ref_info;
1927 gboolean found_ref = FALSE;
1928 gint i;
1929
1930 ref_info = &(parser->state.ref_info);
1931
1932 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
1933 found_ref = AV1_READ_BIT_CHECKED (br, &retval);
1934 if (retval != GST_AV1_PARSER_OK)
1935 return retval;
1936
1937 if (found_ref == 1) {
1938 gint ref_idx = frame_header->ref_frame_idx[i];
1939 parser->state.upscaled_width =
1940 ref_info->entry[ref_idx].ref_upscaled_width;
1941 parser->state.frame_width = parser->state.upscaled_width;
1942 parser->state.frame_height = ref_info->entry[ref_idx].ref_frame_height;
1943 parser->state.render_width = ref_info->entry[ref_idx].ref_render_width;
1944 parser->state.render_height = ref_info->entry[ref_idx].ref_render_height;
1945 break;
1946 }
1947 }
1948 if (found_ref == 0) {
1949 retval = gst_av1_parse_frame_size (parser, br, frame_header);
1950 if (retval != GST_AV1_PARSER_OK)
1951 return retval;
1952
1953 retval = gst_av1_parse_render_size (parser, br, frame_header);
1954 if (retval != GST_AV1_PARSER_OK)
1955 return retval;
1956 } else {
1957 retval = gst_av1_parse_superres_params_compute_image_size (parser, br,
1958 frame_header);
1959 if (retval != GST_AV1_PARSER_OK)
1960 return retval;
1961 }
1962
1963 return GST_AV1_PARSER_OK;
1964 }
1965
1966 /* 5.9.12 */
1967 static GstAV1ParserResult
gst_av1_parse_quantization_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)1968 gst_av1_parse_quantization_params (GstAV1Parser * parser, GstBitReader * br,
1969 GstAV1FrameHeaderOBU * frame_header)
1970 {
1971 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
1972 GstAV1ColorConfig *color_config;
1973 GstAV1QuantizationParams *quant_params = &(frame_header->quantization_params);
1974
1975 g_assert (parser->seq_header);
1976
1977 color_config = &(parser->seq_header->color_config);
1978
1979 quant_params->base_q_idx = AV1_READ_UINT8_CHECKED (br, &retval);
1980 if (retval != GST_AV1_PARSER_OK)
1981 goto error;
1982
1983 frame_header->quantization_params.delta_q_y_dc =
1984 av1_bitstreamfn_delta_q (br, &retval);
1985 if (retval != GST_AV1_PARSER_OK)
1986 goto error;
1987
1988 if (parser->seq_header->num_planes > 1) {
1989 if (color_config->separate_uv_delta_q) {
1990 quant_params->diff_uv_delta = AV1_READ_BIT_CHECKED (br, &retval);
1991 if (retval != GST_AV1_PARSER_OK)
1992 goto error;
1993 } else {
1994 quant_params->diff_uv_delta = 0;
1995 }
1996 frame_header->quantization_params.delta_q_u_dc =
1997 av1_bitstreamfn_delta_q (br, &retval);
1998 if (retval != GST_AV1_PARSER_OK)
1999 goto error;
2000
2001 frame_header->quantization_params.delta_q_u_ac =
2002 av1_bitstreamfn_delta_q (br, &retval);
2003 if (retval != GST_AV1_PARSER_OK)
2004 goto error;
2005
2006 if (quant_params->diff_uv_delta) {
2007 frame_header->quantization_params.delta_q_v_dc =
2008 av1_bitstreamfn_delta_q (br, &retval);
2009 if (retval != GST_AV1_PARSER_OK)
2010 goto error;
2011
2012 frame_header->quantization_params.delta_q_v_ac =
2013 av1_bitstreamfn_delta_q (br, &retval);
2014 if (retval != GST_AV1_PARSER_OK)
2015 goto error;
2016 } else {
2017 frame_header->quantization_params.delta_q_v_dc =
2018 frame_header->quantization_params.delta_q_u_dc;
2019 frame_header->quantization_params.delta_q_v_ac =
2020 frame_header->quantization_params.delta_q_u_ac;
2021 }
2022 } else {
2023 frame_header->quantization_params.delta_q_u_dc = 0;
2024 frame_header->quantization_params.delta_q_u_ac = 0;
2025 frame_header->quantization_params.delta_q_v_dc = 0;
2026 frame_header->quantization_params.delta_q_v_ac = 0;
2027 }
2028
2029 quant_params->using_qmatrix = AV1_READ_BIT_CHECKED (br, &retval);
2030 if (retval != GST_AV1_PARSER_OK)
2031 goto error;
2032
2033 if (quant_params->using_qmatrix) {
2034 if (AV1_REMAINING_BITS (br) < 4 + 4) {
2035 retval = GST_AV1_PARSER_NO_MORE_DATA;
2036 goto error;
2037 }
2038
2039 quant_params->qm_y = AV1_READ_BITS (br, 4);
2040 quant_params->qm_u = AV1_READ_BITS (br, 4);
2041
2042 if (!color_config->separate_uv_delta_q) {
2043 quant_params->qm_v = quant_params->qm_u;
2044 } else {
2045 quant_params->qm_v = AV1_READ_BITS_CHECKED (br, 4, &retval);
2046 if (retval != GST_AV1_PARSER_OK)
2047 goto error;
2048 }
2049 }
2050
2051 return GST_AV1_PARSER_OK;
2052
2053 error:
2054 GST_WARNING ("parse quantization params error %d", retval);
2055 return retval;
2056 }
2057
2058 /* 5.9.14 */
2059 static GstAV1ParserResult
gst_av1_parse_segmentation_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2060 gst_av1_parse_segmentation_params (GstAV1Parser * parser, GstBitReader * br,
2061 GstAV1FrameHeaderOBU * frame_header)
2062 {
2063 gint i, j;
2064 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
2065 gint clipped_value /* clippedValue */ ;
2066 GstAV1SegmenationParams *seg_params;
2067 gint feature_value = 0;
2068
2069 const guint8 segmentation_feature_bits[GST_AV1_SEG_LVL_MAX] = {
2070 8, 6, 6, 6, 6, 3, 0, 0
2071 };
2072 const guint8 segmentation_feature_signed[GST_AV1_SEG_LVL_MAX] = {
2073 1, 1, 1, 1, 1, 0, 0, 0
2074 };
2075 const guint8 segmentation_feature_max[GST_AV1_SEG_LVL_MAX] = {
2076 255, GST_AV1_MAX_LOOP_FILTER, GST_AV1_MAX_LOOP_FILTER,
2077 GST_AV1_MAX_LOOP_FILTER, GST_AV1_MAX_LOOP_FILTER, 7, 0, 0
2078 };
2079
2080 seg_params = &frame_header->segmentation_params;
2081
2082 seg_params->segmentation_enabled = AV1_READ_BIT_CHECKED (br, &retval);
2083 if (retval != GST_AV1_PARSER_OK)
2084 goto error;
2085
2086 if (seg_params->segmentation_enabled) {
2087 if (frame_header->primary_ref_frame == GST_AV1_PRIMARY_REF_NONE) {
2088 seg_params->segmentation_update_map = 1;
2089 seg_params->segmentation_temporal_update = 0;
2090 seg_params->segmentation_update_data = 1;
2091 } else {
2092 seg_params->segmentation_update_map = AV1_READ_BIT_CHECKED (br, &retval);
2093 if (retval != GST_AV1_PARSER_OK)
2094 goto error;
2095
2096 if (seg_params->segmentation_update_map) {
2097 seg_params->segmentation_temporal_update =
2098 AV1_READ_BIT_CHECKED (br, &retval);
2099 if (retval != GST_AV1_PARSER_OK)
2100 goto error;
2101 }
2102 seg_params->segmentation_update_data = AV1_READ_BIT_CHECKED (br, &retval);
2103 if (retval != GST_AV1_PARSER_OK)
2104 goto error;
2105 }
2106
2107 if (seg_params->segmentation_update_data) {
2108 for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
2109 for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
2110 seg_params->feature_enabled[i][j] =
2111 AV1_READ_BIT_CHECKED (br, &retval);
2112 if (retval != GST_AV1_PARSER_OK)
2113 goto error;
2114
2115 clipped_value = 0;
2116 feature_value = 0;
2117 if (seg_params->feature_enabled[i][j]) {
2118 gint bits_to_read = segmentation_feature_bits[j];
2119 gint limit = segmentation_feature_max[j];
2120 if (segmentation_feature_signed[j]) {
2121 feature_value =
2122 av1_bitstreamfn_su (br, 1 + bits_to_read, &retval);
2123 if (retval != GST_AV1_PARSER_OK)
2124 goto error;
2125
2126 clipped_value = CLAMP (feature_value, limit * (-1), limit);
2127 } else {
2128 feature_value = AV1_READ_BITS_CHECKED (br, bits_to_read, &retval);
2129 if (retval != GST_AV1_PARSER_OK)
2130 goto error;
2131
2132 clipped_value = CLAMP (feature_value, 0, limit);
2133 }
2134 }
2135 seg_params->feature_data[i][j] = clipped_value;
2136 }
2137 }
2138 } else {
2139 /* Copy it from prime_ref */
2140 g_assert (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE);
2141 g_assert (parser->state.ref_info.
2142 entry[frame_header->ref_frame_idx[frame_header->primary_ref_frame]].
2143 ref_valid);
2144 memcpy (seg_params,
2145 &parser->state.ref_info.
2146 entry[frame_header->ref_frame_idx[frame_header->
2147 primary_ref_frame]].ref_segmentation_params,
2148 sizeof (GstAV1SegmenationParams));
2149
2150 seg_params->segmentation_update_map = 0;
2151 seg_params->segmentation_temporal_update = 0;
2152 seg_params->segmentation_update_data = 0;
2153 }
2154 } else {
2155 seg_params->segmentation_update_map = 0;
2156 seg_params->segmentation_temporal_update = 0;
2157 seg_params->segmentation_update_data = 0;
2158 for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
2159 for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
2160 seg_params->feature_enabled[i][j] = 0;
2161 seg_params->feature_data[i][j] = 0;
2162 }
2163 }
2164 }
2165
2166 seg_params->seg_id_pre_skip = 0;
2167 seg_params->last_active_seg_id = 0;
2168 for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
2169 for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
2170 if (seg_params->feature_enabled[i][j]) {
2171 seg_params->last_active_seg_id = i;
2172 if (j >= GST_AV1_SEG_LVL_REF_FRAME) {
2173 seg_params->seg_id_pre_skip = 1;
2174 }
2175 }
2176 }
2177 }
2178
2179 return GST_AV1_PARSER_OK;
2180
2181 error:
2182 GST_WARNING ("parse segmentation params error %d", retval);
2183 return retval;
2184 }
2185
2186 /* 5.9.15 */
2187 static GstAV1ParserResult
gst_av1_parse_tile_info(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2188 gst_av1_parse_tile_info (GstAV1Parser * parser, GstBitReader * br,
2189 GstAV1FrameHeaderOBU * frame_header)
2190 {
2191 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
2192 GstAV1SequenceHeaderOBU *seq_header;
2193 GstAV1TileInfo *tile_info;
2194 gint i;
2195 gint start_sb /* startSb */ ;
2196 gint sb_cols /* sbCols */ ;
2197 gint sb_rows /* sbRows */ ;
2198 gint sb_shift /*sbShift */ ;
2199 gint sb_size /* sbSize */ ;
2200 gint max_tile_width_sb /* maxTileWidthSb */ ;
2201 gint max_tile_height_sb /* maxTileHeightSb */ ;
2202 gint max_tile_area_sb /* maxTileAreaSb */ ;
2203 gint min_log2_tile_cols /* minLog2TileCols */ ;
2204 gint max_log2_tile_cols /* maxLog2TileCols */ ;
2205 gint min_log2_tile_rows /* minLog2TileRows */ ;
2206 gint max_log2_tile_rows /* maxLog2TileRows */ ;
2207 gint min_log2_tiles /* minLog2Tiles */ ;
2208 gint tile_width_sb /* tileWidthSb */ ;
2209 gint tile_height_sb /* tileHeightSb */ ;
2210 gint max_width /* maxWidth */ , max_height /* maxHeight */ ;
2211 gint size_sb /* sizeSb */ ;
2212 gint widest_tile_sb /* widestTileSb */ ;
2213
2214 g_assert (parser->seq_header);
2215 seq_header = parser->seq_header;
2216 tile_info = &frame_header->tile_info;
2217
2218 sb_cols = seq_header->use_128x128_superblock ?
2219 ((parser->state.mi_cols + 31) >> 5) : ((parser->state.mi_cols + 15) >> 4);
2220 sb_rows = seq_header->use_128x128_superblock ? ((parser->state.mi_rows +
2221 31) >> 5) : ((parser->state.mi_rows + 15) >> 4);
2222 sb_cols = MIN (GST_AV1_MAX_TILE_COLS, sb_cols);
2223 sb_rows = MIN (GST_AV1_MAX_TILE_ROWS, sb_rows);
2224 sb_shift = seq_header->use_128x128_superblock ? 5 : 4;
2225 sb_size = sb_shift + 2;
2226 max_tile_width_sb = GST_AV1_MAX_TILE_WIDTH >> sb_size;
2227 max_tile_area_sb = GST_AV1_MAX_TILE_AREA >> (2 * sb_size);
2228 min_log2_tile_cols = av1_helper_tile_log2 (max_tile_width_sb, sb_cols);
2229 max_log2_tile_cols = av1_helper_tile_log2 (1, MIN (sb_cols,
2230 GST_AV1_MAX_TILE_COLS));
2231 max_log2_tile_rows = av1_helper_tile_log2 (1, MIN (sb_rows,
2232 GST_AV1_MAX_TILE_ROWS));
2233 min_log2_tiles = MAX (min_log2_tile_cols,
2234 av1_helper_tile_log2 (max_tile_area_sb, sb_rows * sb_cols));
2235
2236 tile_info->uniform_tile_spacing_flag = AV1_READ_BIT_CHECKED (br, &retval);
2237 if (retval != GST_AV1_PARSER_OK)
2238 goto error;
2239
2240 if (tile_info->uniform_tile_spacing_flag) {
2241 parser->state.tile_cols_log2 = min_log2_tile_cols;
2242 while (parser->state.tile_cols_log2 < max_log2_tile_cols) {
2243 gint increment_tile_cols_log2 = AV1_READ_BIT_CHECKED (br, &retval);
2244 if (retval != GST_AV1_PARSER_OK)
2245 goto error;
2246
2247 if (increment_tile_cols_log2 == 1)
2248 parser->state.tile_cols_log2++;
2249 else
2250 break;
2251 }
2252 tile_width_sb = (sb_cols + (1 << parser->state.tile_cols_log2) -
2253 1) >> parser->state.tile_cols_log2;
2254 i = 0;
2255 for (start_sb = 0; start_sb < sb_cols; start_sb += tile_width_sb) {
2256 parser->state.mi_col_starts[i] = start_sb << sb_shift;
2257 i += 1;
2258 }
2259 parser->state.mi_col_starts[i] = parser->state.mi_cols;
2260 parser->state.tile_cols = i;
2261
2262 while (i >= 1) {
2263 tile_info->width_in_sbs_minus_1[i - 1] =
2264 ((parser->state.mi_col_starts[i] - parser->state.mi_col_starts[i - 1]
2265 + ((1 << sb_shift) - 1)) >> sb_shift) - 1;
2266 i--;
2267 }
2268
2269 min_log2_tile_rows = MAX (min_log2_tiles - parser->state.tile_cols_log2, 0);
2270 parser->state.tile_rows_log2 = min_log2_tile_rows;
2271 while (parser->state.tile_rows_log2 < max_log2_tile_rows) {
2272 tile_info->increment_tile_rows_log2 = AV1_READ_BIT_CHECKED (br, &retval);
2273 if (retval != GST_AV1_PARSER_OK)
2274 goto error;
2275
2276 if (tile_info->increment_tile_rows_log2 == 1)
2277 parser->state.tile_rows_log2++;
2278 else
2279 break;
2280 }
2281 tile_height_sb = (sb_rows + (1 << parser->state.tile_rows_log2) -
2282 1) >> parser->state.tile_rows_log2;
2283 i = 0;
2284 for (start_sb = 0; start_sb < sb_rows; start_sb += tile_height_sb) {
2285 parser->state.mi_row_starts[i] = start_sb << sb_shift;
2286 i += 1;
2287 }
2288 parser->state.mi_row_starts[i] = parser->state.mi_rows;
2289 parser->state.tile_rows = i;
2290 while (i >= 1) {
2291 tile_info->height_in_sbs_minus_1[i - 1] =
2292 ((parser->state.mi_row_starts[i] - parser->state.mi_row_starts[i - 1]
2293 + ((1 << sb_shift) - 1)) >> sb_shift) - 1;
2294 i--;
2295 }
2296 } else {
2297 widest_tile_sb = 0;
2298 start_sb = 0;
2299 for (i = 0; start_sb < sb_cols; i++) {
2300 parser->state.mi_col_starts[i] = start_sb << sb_shift;
2301 max_width = MIN (sb_cols - start_sb, max_tile_width_sb);
2302 tile_info->width_in_sbs_minus_1[i] =
2303 av1_bitstreamfn_ns (br, max_width, &retval);
2304 if (retval != GST_AV1_PARSER_OK)
2305 goto error;
2306
2307 size_sb = tile_info->width_in_sbs_minus_1[i] + 1;
2308 widest_tile_sb = MAX (size_sb, widest_tile_sb);
2309 start_sb += size_sb;
2310 }
2311 parser->state.mi_col_starts[i] = parser->state.mi_cols;
2312 parser->state.tile_cols = i;
2313 parser->state.tile_cols_log2 =
2314 av1_helper_tile_log2 (1, parser->state.tile_cols);
2315
2316 if (min_log2_tiles > 0)
2317 max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
2318 else
2319 max_tile_area_sb = sb_rows * sb_cols;
2320
2321 max_tile_height_sb = MAX (max_tile_area_sb / widest_tile_sb, 1);
2322
2323 start_sb = 0;
2324 for (i = 0; start_sb < sb_rows; i++) {
2325 parser->state.mi_row_starts[i] = start_sb << sb_shift;
2326 max_height = MIN (sb_rows - start_sb, max_tile_height_sb);
2327 tile_info->height_in_sbs_minus_1[i] =
2328 av1_bitstreamfn_ns (br, max_height, &retval);
2329 if (retval != GST_AV1_PARSER_OK)
2330 goto error;
2331
2332 size_sb = tile_info->height_in_sbs_minus_1[i] + 1;
2333 start_sb += size_sb;
2334 }
2335
2336 parser->state.mi_row_starts[i] = parser->state.mi_rows;
2337 parser->state.tile_rows = i;
2338 parser->state.tile_rows_log2 =
2339 av1_helper_tile_log2 (1, parser->state.tile_rows);
2340 }
2341
2342 if (parser->state.tile_cols_log2 > 0 || parser->state.tile_rows_log2 > 0) {
2343 tile_info->context_update_tile_id =
2344 AV1_READ_BITS_CHECKED (br,
2345 parser->state.tile_cols_log2 + parser->state.tile_rows_log2, &retval);
2346 if (retval != GST_AV1_PARSER_OK)
2347 goto error;
2348
2349 tile_info->tile_size_bytes_minus_1 = AV1_READ_BITS_CHECKED (br, 2, &retval);
2350 if (retval != GST_AV1_PARSER_OK)
2351 goto error;
2352
2353 parser->state.tile_size_bytes = tile_info->tile_size_bytes_minus_1 + 1;
2354 } else {
2355 tile_info->context_update_tile_id = 0;
2356 }
2357
2358 memcpy (tile_info->mi_col_starts, parser->state.mi_col_starts,
2359 sizeof (guint32) * (GST_AV1_MAX_TILE_COLS + 1));
2360 memcpy (tile_info->mi_row_starts, parser->state.mi_row_starts,
2361 sizeof (guint32) * (GST_AV1_MAX_TILE_ROWS + 1));
2362 tile_info->tile_cols_log2 = parser->state.tile_cols_log2;
2363 tile_info->tile_cols = parser->state.tile_cols;
2364 tile_info->tile_rows_log2 = parser->state.tile_rows_log2;
2365 tile_info->tile_rows = parser->state.tile_rows;
2366 tile_info->tile_size_bytes = parser->state.tile_size_bytes;
2367
2368 return GST_AV1_PARSER_OK;
2369
2370 error:
2371 GST_WARNING ("parse tile info error %d", retval);
2372 return retval;
2373 }
2374
2375 static GstAV1ParserResult
gst_av1_parse_loop_filter_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2376 gst_av1_parse_loop_filter_params (GstAV1Parser * parser,
2377 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
2378 {
2379 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
2380 GstAV1LoopFilterParams *lf_params;
2381 gint i;
2382 guint8 update_ref_deltas = 0;
2383 guint8 update_mode_deltas = 0;
2384
2385 g_assert (parser->seq_header);
2386
2387 lf_params = &frame_header->loop_filter_params;
2388
2389 if (frame_header->coded_lossless || frame_header->allow_intrabc) {
2390 lf_params->loop_filter_level[0] = 0;
2391 lf_params->loop_filter_level[1] = 0;
2392 lf_params->loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME] = 1;
2393 lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME] = 0;
2394 lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME] = 0;
2395 lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME] = 0;
2396 lf_params->loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME] = 0;
2397 lf_params->loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME] = -1;
2398 lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME] = -1;
2399 lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME] = -1;
2400 for (i = 0; i < 2; i++)
2401 lf_params->loop_filter_mode_deltas[i] = 0;
2402
2403 goto success;
2404 }
2405
2406 if (AV1_REMAINING_BITS (br) < 6 + 6) {
2407 retval = GST_AV1_PARSER_NO_MORE_DATA;
2408 goto error;
2409 }
2410
2411 lf_params->loop_filter_level[0] = AV1_READ_BITS (br, 6);
2412 lf_params->loop_filter_level[1] = AV1_READ_BITS (br, 6);
2413 if (parser->seq_header->num_planes > 1) {
2414 if (lf_params->loop_filter_level[0] || lf_params->loop_filter_level[1]) {
2415 if (AV1_REMAINING_BITS (br) < 6 + 6) {
2416 retval = GST_AV1_PARSER_NO_MORE_DATA;
2417 goto error;
2418 }
2419
2420 lf_params->loop_filter_level[2] = AV1_READ_BITS (br, 6);
2421 lf_params->loop_filter_level[3] = AV1_READ_BITS (br, 6);
2422 }
2423 }
2424
2425 if (AV1_REMAINING_BITS (br) < 3 + 1) {
2426 retval = GST_AV1_PARSER_NO_MORE_DATA;
2427 goto error;
2428 }
2429
2430 lf_params->loop_filter_sharpness = AV1_READ_BITS (br, 3);
2431
2432 lf_params->loop_filter_delta_enabled = AV1_READ_BIT (br);
2433 if (lf_params->loop_filter_delta_enabled) {
2434 lf_params->loop_filter_delta_update = AV1_READ_BIT_CHECKED (br, &retval);
2435 if (retval != GST_AV1_PARSER_OK)
2436 goto error;
2437
2438 if (lf_params->loop_filter_delta_update) {
2439 for (i = 0; i < GST_AV1_TOTAL_REFS_PER_FRAME; i++) {
2440 update_ref_deltas = AV1_READ_BIT_CHECKED (br, &retval);
2441 if (retval != GST_AV1_PARSER_OK)
2442 goto error;
2443
2444 if (update_ref_deltas) {
2445 lf_params->loop_filter_ref_deltas[i] =
2446 av1_bitstreamfn_su (br, 7, &retval);
2447 if (retval != GST_AV1_PARSER_OK)
2448 goto error;
2449 }
2450 }
2451 for (i = 0; i < 2; i++) {
2452 update_mode_deltas = AV1_READ_BIT_CHECKED (br, &retval);
2453 if (retval != GST_AV1_PARSER_OK)
2454 goto error;
2455
2456 if (update_mode_deltas) {
2457 lf_params->loop_filter_mode_deltas[i] =
2458 av1_bitstreamfn_su (br, 7, &retval);
2459 if (retval != GST_AV1_PARSER_OK)
2460 goto error;
2461 }
2462 }
2463 }
2464 }
2465
2466 success:
2467 return GST_AV1_PARSER_OK;
2468
2469 error:
2470 GST_WARNING ("parse loop filter params error %d", retval);
2471 return retval;
2472 }
2473
2474 /* 5.9.17 */
2475 static GstAV1ParserResult
gst_av1_parse_delta_q_params(GstAV1Parser * parser,GstBitReader * br,GstAV1QuantizationParams * quant_params)2476 gst_av1_parse_delta_q_params (GstAV1Parser * parser,
2477 GstBitReader * br, GstAV1QuantizationParams * quant_params)
2478 {
2479 GstAV1ParserResult retval;
2480
2481 quant_params->delta_q_res = 0;
2482 quant_params->delta_q_present = 0;
2483 if (quant_params->base_q_idx > 0) {
2484 quant_params->delta_q_present = AV1_READ_BIT_CHECKED (br, &retval);
2485 if (retval != GST_AV1_PARSER_OK)
2486 return retval;
2487 }
2488
2489 if (quant_params->delta_q_present) {
2490 quant_params->delta_q_res = AV1_READ_BITS_CHECKED (br, 2, &retval);
2491 if (retval != GST_AV1_PARSER_OK)
2492 return retval;
2493 }
2494
2495 return GST_AV1_PARSER_OK;
2496 }
2497
2498 /* 5.9.18 */
2499 static GstAV1ParserResult
gst_av1_parse_delta_lf_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2500 gst_av1_parse_delta_lf_params (GstAV1Parser * parser,
2501 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
2502 {
2503 GstAV1ParserResult retval;
2504 GstAV1LoopFilterParams *lf_params;
2505
2506 lf_params = &frame_header->loop_filter_params;
2507 lf_params->delta_lf_present = 0;
2508 lf_params->delta_lf_res = 0;
2509 lf_params->delta_lf_multi = 0;
2510
2511 if (frame_header->quantization_params.delta_q_present) {
2512 if (!frame_header->allow_intrabc) {
2513 lf_params->delta_lf_present = AV1_READ_BIT_CHECKED (br, &retval);
2514 if (retval != GST_AV1_PARSER_OK)
2515 return retval;
2516 }
2517 if (lf_params->delta_lf_present) {
2518 if (AV1_REMAINING_BITS (br) < 2 + 1)
2519 return GST_AV1_PARSER_NO_MORE_DATA;
2520 lf_params->delta_lf_res = AV1_READ_BITS (br, 2);
2521 lf_params->delta_lf_multi = AV1_READ_BIT (br);
2522 }
2523 }
2524
2525 return GST_AV1_PARSER_OK;
2526 }
2527
2528 /* 5.9.19 */
2529 static GstAV1ParserResult
gst_av1_parse_cdef_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2530 gst_av1_parse_cdef_params (GstAV1Parser * parser, GstBitReader * br,
2531 GstAV1FrameHeaderOBU * frame_header)
2532 {
2533 GstAV1SequenceHeaderOBU *seq_header;
2534 GstAV1CDEFParams *cdef_params;
2535 guint8 cdef_damping_minus_3;
2536 gint i;
2537
2538 g_assert (parser->seq_header);
2539
2540 cdef_params = &frame_header->cdef_params;
2541 seq_header = parser->seq_header;
2542
2543 if (frame_header->coded_lossless || frame_header->allow_intrabc
2544 || !seq_header->enable_cdef) {
2545 cdef_params->cdef_bits = 0;
2546 cdef_params->cdef_y_pri_strength[0] = 0;
2547 cdef_params->cdef_y_sec_strength[0] = 0;
2548 cdef_params->cdef_uv_pri_strength[0] = 0;
2549 cdef_params->cdef_uv_sec_strength[0] = 0;
2550 cdef_params->cdef_damping = 3;
2551 return GST_AV1_PARSER_OK;
2552 }
2553
2554 if (AV1_REMAINING_BITS (br) < 2 + 2)
2555 return GST_AV1_PARSER_NO_MORE_DATA;
2556
2557 cdef_damping_minus_3 = AV1_READ_BITS (br, 2);
2558 cdef_params->cdef_damping = cdef_damping_minus_3 + 3;
2559 cdef_params->cdef_bits = AV1_READ_BITS (br, 2);
2560 for (i = 0; i < (1 << cdef_params->cdef_bits); i++) {
2561 if (AV1_REMAINING_BITS (br) < 4 + 2)
2562 return GST_AV1_PARSER_NO_MORE_DATA;
2563
2564 cdef_params->cdef_y_pri_strength[i] = AV1_READ_BITS (br, 4);
2565 cdef_params->cdef_y_sec_strength[i] = AV1_READ_BITS (br, 2);
2566 if (cdef_params->cdef_y_sec_strength[i] == 3)
2567 cdef_params->cdef_y_sec_strength[i] += 1;
2568
2569 if (parser->seq_header->num_planes > 1) {
2570 if (AV1_REMAINING_BITS (br) < 4 + 2)
2571 return GST_AV1_PARSER_NO_MORE_DATA;
2572
2573 cdef_params->cdef_uv_pri_strength[i] = AV1_READ_BITS (br, 4);
2574 cdef_params->cdef_uv_sec_strength[i] = AV1_READ_BITS (br, 2);
2575 if (cdef_params->cdef_uv_sec_strength[i] == 3)
2576 cdef_params->cdef_uv_sec_strength[i] += 1;
2577 }
2578 }
2579
2580 return GST_AV1_PARSER_OK;
2581 }
2582
2583 /* 5.9.20 */
2584 static GstAV1ParserResult
gst_av1_parse_loop_restoration_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2585 gst_av1_parse_loop_restoration_params (GstAV1Parser * parser,
2586 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
2587 {
2588 GstAV1LoopRestorationParams *lr_params;
2589 GstAV1SequenceHeaderOBU *seq_header;
2590 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
2591 guint8 lr_type;
2592 gint i;
2593 guint8 use_chroma_lr /* useChromaLr */ ;
2594 const GstAV1FrameRestorationType remap_lr_type /* Remap_Lr_Type */ [4] = {
2595 GST_AV1_FRAME_RESTORE_NONE,
2596 GST_AV1_FRAME_RESTORE_SWITCHABLE,
2597 GST_AV1_FRAME_RESTORE_WIENER, GST_AV1_FRAME_RESTORE_SGRPROJ
2598 };
2599
2600 g_assert (parser->seq_header);
2601
2602 lr_params = &frame_header->loop_restoration_params;
2603 seq_header = parser->seq_header;
2604
2605 if (frame_header->all_lossless || frame_header->allow_intrabc
2606 || !seq_header->enable_restoration) {
2607 for (i = 0; i < GST_AV1_MAX_NUM_PLANES; i++)
2608 lr_params->frame_restoration_type[i] = GST_AV1_FRAME_RESTORE_NONE;
2609
2610 lr_params->uses_lr = 0;
2611 goto success;
2612 }
2613
2614 lr_params->uses_lr = 0;
2615 use_chroma_lr = 0;
2616 for (i = 0; i < seq_header->num_planes; i++) {
2617 lr_type = AV1_READ_BITS_CHECKED (br, 2, &retval);
2618 if (retval != GST_AV1_PARSER_OK)
2619 goto error;
2620
2621 lr_params->frame_restoration_type[i] = remap_lr_type[lr_type];
2622 if (lr_params->frame_restoration_type[i] != GST_AV1_FRAME_RESTORE_NONE) {
2623 lr_params->uses_lr = 1;
2624 if (i > 0) {
2625 use_chroma_lr = 1;
2626 }
2627 }
2628 }
2629
2630 if (lr_params->uses_lr) {
2631 if (seq_header->use_128x128_superblock) {
2632 lr_params->lr_unit_shift = AV1_READ_BIT_CHECKED (br, &retval);
2633 if (retval != GST_AV1_PARSER_OK)
2634 goto error;
2635
2636 lr_params->lr_unit_shift++;
2637 } else {
2638 guint8 lr_unit_extra_shift;
2639
2640 lr_params->lr_unit_shift = AV1_READ_BIT_CHECKED (br, &retval);
2641 if (retval != GST_AV1_PARSER_OK)
2642 goto error;
2643
2644 if (lr_params->lr_unit_shift) {
2645 lr_unit_extra_shift = AV1_READ_BIT_CHECKED (br, &retval);
2646 if (retval != GST_AV1_PARSER_OK)
2647 goto error;
2648
2649 lr_params->lr_unit_shift += lr_unit_extra_shift;
2650 }
2651 }
2652
2653 lr_params->loop_restoration_size[0] =
2654 GST_AV1_RESTORATION_TILESIZE_MAX >> (2 - lr_params->lr_unit_shift);
2655 if (seq_header->color_config.subsampling_x
2656 && seq_header->color_config.subsampling_y && use_chroma_lr) {
2657 lr_params->lr_uv_shift = AV1_READ_BIT_CHECKED (br, &retval);
2658 if (retval != GST_AV1_PARSER_OK)
2659 goto error;
2660 } else {
2661 lr_params->lr_uv_shift = 0;
2662 }
2663
2664 lr_params->loop_restoration_size[1] =
2665 lr_params->loop_restoration_size[0] >> lr_params->lr_uv_shift;
2666 lr_params->loop_restoration_size[2] =
2667 lr_params->loop_restoration_size[0] >> lr_params->lr_uv_shift;
2668 }
2669
2670 success:
2671 return GST_AV1_PARSER_OK;
2672
2673 error:
2674 GST_WARNING ("parse loop restoration params error %d", retval);
2675 return retval;
2676 }
2677
2678 /* 5.9.21 */
2679 static GstAV1ParserResult
gst_av1_parse_tx_mode(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2680 gst_av1_parse_tx_mode (GstAV1Parser * parser, GstBitReader * br,
2681 GstAV1FrameHeaderOBU * frame_header)
2682 {
2683 GstAV1ParserResult retval;
2684
2685 if (frame_header->coded_lossless == 1) {
2686 frame_header->tx_mode = GST_AV1_TX_MODE_ONLY_4x4;
2687 } else {
2688 frame_header->tx_mode_select = AV1_READ_BIT_CHECKED (br, &retval);
2689 if (retval != GST_AV1_PARSER_OK)
2690 return retval;
2691
2692 if (frame_header->tx_mode_select) {
2693 frame_header->tx_mode = GST_AV1_TX_MODE_SELECT;
2694 } else {
2695 frame_header->tx_mode = GST_AV1_TX_MODE_LARGEST;
2696 }
2697 }
2698
2699 return GST_AV1_PARSER_OK;
2700 }
2701
2702 /* 5.9.3 */
2703 static gint
gst_av1_get_relative_dist(GstAV1SequenceHeaderOBU * seq_header,gint a,gint b)2704 gst_av1_get_relative_dist (GstAV1SequenceHeaderOBU * seq_header, gint a, gint b)
2705 {
2706 gint m, diff;
2707 if (!seq_header->enable_order_hint)
2708 return 0;
2709 diff = a - b;
2710 m = 1 << seq_header->order_hint_bits_minus_1;
2711 diff = (diff & (m - 1)) - (diff & m);
2712 return diff;
2713 }
2714
2715 /* 5.9.22 */
2716 static GstAV1ParserResult
gst_av1_parse_skip_mode_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2717 gst_av1_parse_skip_mode_params (GstAV1Parser * parser, GstBitReader * br,
2718 GstAV1FrameHeaderOBU * frame_header)
2719 {
2720 GstAV1ReferenceFrameInfo *ref_info;
2721 GstAV1SequenceHeaderOBU *seq_header;
2722 gint i;
2723 gint skip_mode_allowed /* skipModeAllowed */ ;
2724 GstAV1ParserResult retval;
2725
2726 g_assert (parser->seq_header);
2727
2728 seq_header = parser->seq_header;
2729 ref_info = &(parser->state.ref_info);
2730 skip_mode_allowed = 0;
2731 if (frame_header->frame_is_intra || !frame_header->reference_select
2732 || !seq_header->enable_order_hint) {
2733 skip_mode_allowed = 0;
2734 } else {
2735 gint forward_idx = -1 /* forwardIdx */ ;
2736 gint forward_hint = 0 /* forwardHint */ ;
2737 gint backward_idx = -1 /* backwardIdx */ ;
2738 gint backward_hint = 0 /* backwardHint */ ;
2739 gint ref_hint = 0 /* refHint */ ;
2740
2741 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
2742 ref_hint = ref_info->entry[frame_header->ref_frame_idx[i]].ref_order_hint;
2743 if (gst_av1_get_relative_dist (parser->seq_header, ref_hint,
2744 frame_header->order_hint) < 0) {
2745 if (forward_idx < 0
2746 || gst_av1_get_relative_dist (parser->seq_header, ref_hint,
2747 forward_hint) > 0) {
2748 forward_idx = i;
2749 forward_hint = ref_hint;
2750 }
2751 } else
2752 if (gst_av1_get_relative_dist (parser->seq_header, ref_hint,
2753 frame_header->order_hint) > 0) {
2754 if (backward_idx < 0
2755 || gst_av1_get_relative_dist (parser->seq_header, ref_hint,
2756 backward_hint) < 0) {
2757 backward_idx = i;
2758 backward_hint = ref_hint;
2759 }
2760 }
2761 }
2762
2763 if (forward_idx < 0) {
2764 skip_mode_allowed = 0;
2765 } else if (backward_idx >= 0) {
2766 skip_mode_allowed = 1;
2767 frame_header->skip_mode_frame[0] =
2768 GST_AV1_REF_LAST_FRAME + MIN (forward_idx, backward_idx);
2769 frame_header->skip_mode_frame[1] =
2770 GST_AV1_REF_LAST_FRAME + MAX (forward_idx, backward_idx);
2771 } else {
2772 gint second_forward_idx = -1 /* secondForwardIdx */ ;
2773 gint second_forward_hint = 0 /* secondForwardHint */ ;
2774 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
2775 ref_hint =
2776 ref_info->entry[frame_header->ref_frame_idx[i]].ref_order_hint;
2777 if (gst_av1_get_relative_dist (parser->seq_header, ref_hint,
2778 forward_hint) < 0) {
2779 if (second_forward_idx < 0
2780 || gst_av1_get_relative_dist (parser->seq_header, ref_hint,
2781 second_forward_hint) > 0) {
2782 second_forward_idx = i;
2783 second_forward_hint = ref_hint;
2784 }
2785 }
2786 }
2787
2788 if (second_forward_idx < 0) {
2789 skip_mode_allowed = 0;
2790 } else {
2791 skip_mode_allowed = 1;
2792 frame_header->skip_mode_frame[0] =
2793 GST_AV1_REF_LAST_FRAME + MIN (forward_idx, second_forward_idx);
2794 frame_header->skip_mode_frame[1] =
2795 GST_AV1_REF_LAST_FRAME + MAX (forward_idx, second_forward_idx);
2796 }
2797 }
2798 }
2799
2800 if (skip_mode_allowed) {
2801 frame_header->skip_mode_present = AV1_READ_BIT_CHECKED (br, &retval);
2802 if (retval != GST_AV1_PARSER_OK)
2803 return retval;
2804 } else {
2805 frame_header->skip_mode_present = 0;
2806 }
2807
2808 return GST_AV1_PARSER_OK;
2809 }
2810
2811 /* 5.9.28 */
2812 static gint
gst_av1_decode_subexp(GstBitReader * br,gint numSyms,GstAV1ParserResult * retval)2813 gst_av1_decode_subexp (GstBitReader * br, gint numSyms,
2814 GstAV1ParserResult * retval)
2815 {
2816 gint i = 0;
2817 gint mk = 0;
2818 gint k = 3;
2819 gint subexp_final_bits = 0;
2820 gint subexp_more_bits = 0;
2821 gint subexp_bits = 0;
2822
2823 while (1) {
2824 gint b2 = i ? k + i - 1 : k;
2825 gint a = 1 << b2;
2826 if (numSyms <= mk + 3 * a) {
2827 subexp_final_bits = av1_bitstreamfn_ns (br, numSyms - mk, retval);
2828 if (*retval != GST_AV1_PARSER_OK)
2829 return 0;
2830 return subexp_final_bits + mk;
2831 } else {
2832 subexp_more_bits = AV1_READ_BITS_CHECKED (br, 1, retval);
2833 if (*retval != GST_AV1_PARSER_OK)
2834 return 0;
2835 if (subexp_more_bits) {
2836 i++;
2837 mk += a;
2838 } else {
2839 subexp_bits = AV1_READ_BITS_CHECKED (br, b2, retval);
2840 if (*retval != GST_AV1_PARSER_OK)
2841 return 0;
2842 return subexp_bits + mk;
2843 }
2844 }
2845 }
2846 }
2847
2848 /* 5.9.27 */
2849 static gint
gst_av1_decode_unsigned_subexp_with_ref(GstBitReader * br,gint mx,gint r,GstAV1ParserResult * retval)2850 gst_av1_decode_unsigned_subexp_with_ref (GstBitReader * br, gint mx,
2851 gint r, GstAV1ParserResult * retval)
2852 {
2853 gint v;
2854
2855 v = gst_av1_decode_subexp (br, mx, retval);
2856 if ((r << 1) <= mx) {
2857 return av1_helper_inverse_recenter (r, v);
2858 } else {
2859 return mx - 1 - av1_helper_inverse_recenter (mx - 1 - r, v);
2860 }
2861 }
2862
2863 /* 5.9.26 */
2864 static gint
gst_av1_decode_signed_subexp_with_ref(GstBitReader * br,gint low,gint high,gint r,GstAV1ParserResult * retval)2865 gst_av1_decode_signed_subexp_with_ref (GstBitReader * br, gint low,
2866 gint high, gint r, GstAV1ParserResult * retval)
2867 {
2868 return gst_av1_decode_unsigned_subexp_with_ref (br,
2869 high - low, r - low, retval) + low;
2870 }
2871
2872 /* 5.9.25 */
2873 static GstAV1ParserResult
gst_av1_parse_global_param(GstAV1Parser * parser,GstAV1FrameHeaderOBU * frame_header,GstBitReader * br,GstAV1GlobalMotionParams * gm_params,GstAV1WarpModelType type,gint32 prev_gm_params[GST_AV1_NUM_REF_FRAMES][6],gint ref,gint idx)2874 gst_av1_parse_global_param (GstAV1Parser * parser,
2875 GstAV1FrameHeaderOBU * frame_header, GstBitReader * br,
2876 GstAV1GlobalMotionParams * gm_params, GstAV1WarpModelType type,
2877 gint32 prev_gm_params[GST_AV1_NUM_REF_FRAMES][6], gint ref, gint idx)
2878 {
2879 GstAV1ParserResult retval;
2880 gint prec_diff /* precDiff */ , wm_round, mx, r;
2881 gint abs_bits /* absBits */ = GST_AV1_GM_ABS_ALPHA_BITS;
2882 gint prec_bits /* precBits */ = GST_AV1_GM_ALPHA_PREC_BITS;
2883 gint sub;
2884
2885 if (idx < 2) {
2886 if (type == GST_AV1_WARP_MODEL_TRANSLATION) {
2887 abs_bits =
2888 GST_AV1_GM_ABS_TRANS_ONLY_BITS -
2889 (frame_header->allow_high_precision_mv ? 0 : 1);
2890 prec_bits =
2891 GST_AV1_GM_TRANS_ONLY_PREC_BITS -
2892 (frame_header->allow_high_precision_mv ? 0 : 1);
2893 } else {
2894 abs_bits = GST_AV1_GM_ABS_TRANS_BITS;
2895 prec_bits = GST_AV1_GM_TRANS_PREC_BITS;
2896 }
2897 }
2898
2899 prec_diff = GST_AV1_WARPEDMODEL_PREC_BITS - prec_bits;
2900 wm_round = (idx % 3) == 2 ? (1 << GST_AV1_WARPEDMODEL_PREC_BITS) : 0;
2901 sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
2902 mx = (1 << abs_bits);
2903 r = (prev_gm_params[ref][idx] >> prec_diff) - sub;
2904 gm_params->gm_params[ref][idx] =
2905 (gst_av1_decode_signed_subexp_with_ref (br, -mx, mx + 1, r,
2906 &retval) << prec_diff) + wm_round;
2907 if (retval != GST_AV1_PARSER_OK)
2908 return retval;
2909 return GST_AV1_PARSER_OK;
2910 }
2911
2912 static gboolean
gst_av1_parser_is_shear_params_valid(gint32 gm_params[6])2913 gst_av1_parser_is_shear_params_valid (gint32 gm_params[6])
2914 {
2915 const gint32 *mat = gm_params;
2916 gint16 alpha, beta, gamma, delta;
2917 gint16 shift;
2918 gint16 y;
2919 gint16 v;
2920 guint i;
2921 gboolean default_warp_params;
2922
2923 if (!(mat[2] > 0))
2924 return FALSE;
2925
2926 default_warp_params = TRUE;
2927 for (i = 0; i < 6; i++) {
2928 if (gm_params[i] != ((i % 3 == 2) ? 1 << GST_AV1_WARPEDMODEL_PREC_BITS : 0)) {
2929 default_warp_params = FALSE;
2930 break;
2931 }
2932 }
2933 if (default_warp_params)
2934 return TRUE;
2935
2936 alpha = CLAMP (mat[2] - (1 << GST_AV1_WARPEDMODEL_PREC_BITS),
2937 G_MININT16, G_MAXINT16);
2938 beta = CLAMP (mat[3], G_MININT16, G_MAXINT16);
2939 y = av1_helper_resolve_divisor_32 (ABS (mat[2]), &shift)
2940 * (mat[2] < 0 ? -1 : 1);
2941 v = ((gint64) mat[4] * (1 << GST_AV1_WARPEDMODEL_PREC_BITS)) * y;
2942 gamma =
2943 CLAMP ((gint) av1_helper_round_power_of_two_signed (v, shift), G_MININT16,
2944 G_MAXINT16);
2945 v = ((gint64) mat[3] * mat[4]) * y;
2946 delta =
2947 CLAMP (mat[5] - (gint) av1_helper_round_power_of_two_signed (v,
2948 shift) - (1 << GST_AV1_WARPEDMODEL_PREC_BITS), G_MININT16,
2949 G_MAXINT16);
2950
2951 alpha =
2952 av1_helper_round_power_of_two_signed (alpha,
2953 GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
2954 beta =
2955 av1_helper_round_power_of_two_signed (beta,
2956 GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
2957 gamma =
2958 av1_helper_round_power_of_two_signed (gamma,
2959 GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
2960 delta =
2961 av1_helper_round_power_of_two_signed (delta,
2962 GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
2963
2964 if ((4 * ABS (alpha) + 7 * ABS (beta) >= (1 << GST_AV1_WARPEDMODEL_PREC_BITS))
2965 || (4 * ABS (gamma) + 4 * ABS (delta) >=
2966 (1 << GST_AV1_WARPEDMODEL_PREC_BITS)))
2967 return FALSE;
2968
2969 return TRUE;
2970 }
2971
2972 /* 5.9.24 */
2973 static GstAV1ParserResult
gst_av1_parse_global_motion_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)2974 gst_av1_parse_global_motion_params (GstAV1Parser * parser,
2975 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
2976 {
2977 GstAV1WarpModelType type;
2978 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
2979 gint i, ref;
2980 GstAV1GlobalMotionParams *gm_params = &(frame_header->global_motion_params);
2981 gint32 prev_gm_params[GST_AV1_NUM_REF_FRAMES][6] /* PrevGmParams */ ;
2982
2983 /* init value */
2984 gm_params->gm_type[GST_AV1_REF_INTRA_FRAME] = GST_AV1_WARP_MODEL_IDENTITY;
2985 for (ref = GST_AV1_REF_LAST_FRAME; ref <= GST_AV1_REF_ALTREF_FRAME; ref++) {
2986 gm_params->invalid[ref] = 0;
2987 gm_params->gm_type[ref] = GST_AV1_WARP_MODEL_IDENTITY;
2988 for (i = 0; i < 6; i++) {
2989 gm_params->gm_params[ref][i] =
2990 ((i % 3 == 2) ? 1 << GST_AV1_WARPEDMODEL_PREC_BITS : 0);
2991 }
2992 }
2993
2994 if (frame_header->frame_is_intra)
2995 goto success;
2996
2997 if (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE) {
2998 GstAV1GlobalMotionParams *ref_global_motion_params =
2999 &parser->state.ref_info.entry[frame_header->
3000 ref_frame_idx[frame_header->primary_ref_frame]].
3001 ref_global_motion_params;
3002 memcpy (prev_gm_params, ref_global_motion_params->gm_params,
3003 sizeof (gint32) * GST_AV1_NUM_REF_FRAMES * 6);
3004 } else {
3005 for (ref = GST_AV1_REF_INTRA_FRAME; ref < GST_AV1_NUM_REF_FRAMES; ref++)
3006 for (i = 0; i < 6; i++)
3007 prev_gm_params[ref][i] =
3008 ((i % 3 == 2) ? 1 << GST_AV1_WARPEDMODEL_PREC_BITS : 0);
3009 }
3010
3011 for (ref = GST_AV1_REF_LAST_FRAME; ref <= GST_AV1_REF_ALTREF_FRAME; ref++) {
3012 gm_params->is_global[ref] = AV1_READ_BIT_CHECKED (br, &retval);
3013 if (retval != GST_AV1_PARSER_OK)
3014 goto error;
3015
3016 if (gm_params->is_global[ref]) {
3017 gm_params->is_rot_zoom[ref] = AV1_READ_BIT_CHECKED (br, &retval);
3018 if (retval != GST_AV1_PARSER_OK)
3019 goto error;
3020
3021 if (gm_params->is_rot_zoom[ref]) {
3022 type = GST_AV1_WARP_MODEL_ROTZOOM;
3023 } else {
3024 gm_params->is_translation[ref] = AV1_READ_BIT_CHECKED (br, &retval);
3025 if (retval != GST_AV1_PARSER_OK)
3026 goto error;
3027 type =
3028 gm_params->is_translation[ref] ? GST_AV1_WARP_MODEL_TRANSLATION :
3029 GST_AV1_WARP_MODEL_AFFINE;
3030 }
3031 } else {
3032 type = GST_AV1_WARP_MODEL_IDENTITY;
3033 }
3034 gm_params->gm_type[ref] = type;
3035
3036 if (type >= GST_AV1_WARP_MODEL_ROTZOOM) {
3037 retval =
3038 gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
3039 prev_gm_params, ref, 2);
3040 if (retval != GST_AV1_PARSER_OK)
3041 goto error;
3042
3043 retval =
3044 gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
3045 prev_gm_params, ref, 3);
3046 if (retval != GST_AV1_PARSER_OK)
3047 goto error;
3048
3049 if (type == GST_AV1_WARP_MODEL_AFFINE) {
3050 retval =
3051 gst_av1_parse_global_param (parser, frame_header, br, gm_params,
3052 type, prev_gm_params, ref, 4);
3053 if (retval != GST_AV1_PARSER_OK)
3054 goto error;
3055
3056 retval =
3057 gst_av1_parse_global_param (parser, frame_header, br, gm_params,
3058 type, prev_gm_params, ref, 5);
3059 if (retval != GST_AV1_PARSER_OK)
3060 goto error;
3061 } else {
3062 gm_params->gm_params[ref][4] = gm_params->gm_params[ref][3] * (-1);
3063 gm_params->gm_params[ref][5] = gm_params->gm_params[ref][2];
3064 }
3065 }
3066 if (type >= GST_AV1_WARP_MODEL_TRANSLATION) {
3067 retval =
3068 gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
3069 prev_gm_params, ref, 0);
3070 if (retval != GST_AV1_PARSER_OK)
3071 goto error;
3072 retval =
3073 gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
3074 prev_gm_params, ref, 1);
3075 if (retval != GST_AV1_PARSER_OK)
3076 goto error;
3077 }
3078
3079 if (type <= GST_AV1_WARP_MODEL_AFFINE)
3080 gm_params->invalid[ref] =
3081 !gst_av1_parser_is_shear_params_valid (gm_params->gm_params[ref]);
3082 }
3083
3084 success:
3085 return GST_AV1_PARSER_OK;
3086
3087 error:
3088 GST_WARNING ("parse global motion params error %d", retval);
3089 return retval;
3090 }
3091
3092 /* 5.9.30 */
3093 static GstAV1ParserResult
gst_av1_parse_film_grain_params(GstAV1Parser * parser,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)3094 gst_av1_parse_film_grain_params (GstAV1Parser * parser, GstBitReader * br,
3095 GstAV1FrameHeaderOBU * frame_header)
3096 {
3097 GstAV1FilmGrainParams *fg_params;
3098 GstAV1SequenceHeaderOBU *seq_header;
3099 gint i;
3100 gint num_pos_chroma /* numPosChroma */ , num_pos_luma /* numPosLuma */ ;
3101 GstAV1ParserResult ret = GST_AV1_PARSER_OK;
3102
3103 g_assert (parser->seq_header);
3104
3105 fg_params = &frame_header->film_grain_params;
3106 seq_header = parser->seq_header;
3107 if (!seq_header->film_grain_params_present || (!frame_header->show_frame
3108 && !frame_header->showable_frame)) {
3109 /* reset_grain_params() is a function call that indicates that all the
3110 syntax elements read in film_grain_params should be set equal to 0. */
3111 memset (fg_params, 0, sizeof (*fg_params));
3112 goto success;
3113 }
3114
3115 fg_params->apply_grain = AV1_READ_BIT_CHECKED (br, &ret);
3116 if (ret != GST_AV1_PARSER_OK)
3117 goto error;
3118 if (!fg_params->apply_grain) {
3119 /* reset_grain_params() */
3120 memset (fg_params, 0, sizeof (*fg_params));
3121 goto success;
3122 }
3123
3124 fg_params->grain_seed = AV1_READ_UINT16_CHECKED (br, &ret);
3125 if (ret != GST_AV1_PARSER_OK)
3126 goto error;
3127
3128 if (frame_header->frame_type == GST_AV1_INTER_FRAME) {
3129 fg_params->update_grain = AV1_READ_BIT_CHECKED (br, &ret);
3130 if (ret != GST_AV1_PARSER_OK)
3131 goto error;
3132 } else {
3133 fg_params->update_grain = 1;
3134 }
3135
3136 if (!fg_params->update_grain) {
3137 guint16 temp_grain_seed /* tempGrainSeed */ ;
3138 gint j;
3139 gboolean found = FALSE;
3140
3141 fg_params->film_grain_params_ref_idx = AV1_READ_BITS_CHECKED (br, 3, &ret);
3142 if (ret != GST_AV1_PARSER_OK)
3143 goto error;
3144
3145 for (j = 0; j < GST_AV1_REFS_PER_FRAME; j++) {
3146 if (frame_header->ref_frame_idx[j] ==
3147 fg_params->film_grain_params_ref_idx) {
3148 found = TRUE;
3149 break;
3150 }
3151 }
3152
3153 if (!found) {
3154 GST_INFO ("Invalid film grain reference idx %d.",
3155 fg_params->film_grain_params_ref_idx);
3156 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
3157 goto error;
3158 }
3159
3160 if (!parser->state.ref_info.entry[fg_params->film_grain_params_ref_idx].
3161 ref_valid) {
3162 GST_INFO ("Invalid ref info of film grain idx %d.",
3163 fg_params->film_grain_params_ref_idx);
3164 ret = GST_AV1_PARSER_BITSTREAM_ERROR;
3165 goto error;
3166 }
3167
3168 temp_grain_seed = fg_params->grain_seed;
3169 memcpy (fg_params,
3170 &parser->state.ref_info.entry[fg_params->film_grain_params_ref_idx].
3171 ref_film_grain_params, sizeof (GstAV1FilmGrainParams));
3172 fg_params->grain_seed = temp_grain_seed;
3173
3174 goto success;
3175 }
3176
3177 fg_params->num_y_points = AV1_READ_BITS_CHECKED (br, 4, &ret);
3178 if (ret != GST_AV1_PARSER_OK)
3179 goto error;
3180
3181 for (i = 0; i < fg_params->num_y_points; i++) {
3182 if (AV1_REMAINING_BITS (br) < 8 + 8) {
3183 ret = GST_AV1_PARSER_NO_MORE_DATA;
3184 goto error;
3185 }
3186 fg_params->point_y_value[i] = AV1_READ_UINT8 (br);
3187 fg_params->point_y_scaling[i] = AV1_READ_UINT8 (br);
3188 }
3189
3190 if (seq_header->color_config.mono_chrome) {
3191 fg_params->chroma_scaling_from_luma = 0;
3192 } else {
3193 fg_params->chroma_scaling_from_luma = AV1_READ_BIT_CHECKED (br, &ret);
3194 if (ret != GST_AV1_PARSER_OK)
3195 goto error;
3196 }
3197
3198 if (seq_header->color_config.mono_chrome
3199 || fg_params->chroma_scaling_from_luma
3200 || (seq_header->color_config.subsampling_x == 1
3201 && seq_header->color_config.subsampling_y == 1
3202 && fg_params->num_y_points == 0)) {
3203 fg_params->num_cb_points = 0;
3204 fg_params->num_cr_points = 0;
3205 } else {
3206 fg_params->num_cb_points = AV1_READ_BITS_CHECKED (br, 4, &ret);
3207 if (ret != GST_AV1_PARSER_OK)
3208 goto error;
3209 for (i = 0; i < fg_params->num_cb_points; i++) {
3210 if (AV1_REMAINING_BITS (br) < 8 + 8) {
3211 ret = GST_AV1_PARSER_NO_MORE_DATA;
3212 goto error;
3213 }
3214 fg_params->point_cb_value[i] = AV1_READ_UINT8 (br);
3215 fg_params->point_cb_scaling[i] = AV1_READ_UINT8 (br);
3216 }
3217
3218 fg_params->num_cr_points = AV1_READ_BITS_CHECKED (br, 4, &ret);
3219 if (ret != GST_AV1_PARSER_OK)
3220 goto error;
3221 for (i = 0; i < fg_params->num_cr_points; i++) {
3222 if (AV1_REMAINING_BITS (br) < 8 + 8) {
3223 ret = GST_AV1_PARSER_NO_MORE_DATA;
3224 goto error;
3225 }
3226 fg_params->point_cr_value[i] = AV1_READ_UINT8 (br);
3227 fg_params->point_cr_scaling[i] = AV1_READ_UINT8 (br);
3228 }
3229 }
3230
3231 fg_params->grain_scaling_minus_8 = AV1_READ_BITS_CHECKED (br, 2, &ret);
3232 if (ret != GST_AV1_PARSER_OK)
3233 goto error;
3234
3235 fg_params->ar_coeff_lag = AV1_READ_BITS_CHECKED (br, 2, &ret);
3236 if (ret != GST_AV1_PARSER_OK)
3237 goto error;
3238
3239 num_pos_luma = 2 * fg_params->ar_coeff_lag * (fg_params->ar_coeff_lag + 1);
3240 if (fg_params->num_y_points) {
3241 num_pos_chroma = num_pos_luma + 1;
3242 for (i = 0; i < num_pos_luma; i++) {
3243 fg_params->ar_coeffs_y_plus_128[i] = AV1_READ_UINT8_CHECKED (br, &ret);
3244 if (ret != GST_AV1_PARSER_OK)
3245 goto error;
3246 }
3247 } else {
3248 num_pos_chroma = num_pos_luma;
3249 }
3250
3251 if (fg_params->chroma_scaling_from_luma || fg_params->num_cb_points) {
3252 for (i = 0; i < num_pos_chroma; i++) {
3253 fg_params->ar_coeffs_cb_plus_128[i] = AV1_READ_UINT8_CHECKED (br, &ret);
3254 if (ret != GST_AV1_PARSER_OK)
3255 goto error;
3256 }
3257 }
3258
3259 if (fg_params->chroma_scaling_from_luma || fg_params->num_cr_points) {
3260 for (i = 0; i < num_pos_chroma; i++) {
3261 fg_params->ar_coeffs_cr_plus_128[i] = AV1_READ_UINT8_CHECKED (br, &ret);
3262 if (ret != GST_AV1_PARSER_OK)
3263 goto error;
3264 }
3265 }
3266
3267 if (AV1_REMAINING_BITS (br) < 2 + 2) {
3268 ret = GST_AV1_PARSER_NO_MORE_DATA;
3269 goto error;
3270 }
3271 fg_params->ar_coeff_shift_minus_6 = AV1_READ_BITS (br, 2);
3272 fg_params->grain_scale_shift = AV1_READ_BITS (br, 2);
3273
3274 if (fg_params->num_cb_points) {
3275 if (AV1_REMAINING_BITS (br) < 8 + 8 + 9) {
3276 ret = GST_AV1_PARSER_NO_MORE_DATA;
3277 goto error;
3278 }
3279 fg_params->cb_mult = AV1_READ_BITS (br, 8);
3280 fg_params->cb_luma_mult = AV1_READ_BITS (br, 8);
3281 fg_params->cb_offset = AV1_READ_BITS (br, 9);
3282 }
3283
3284 if (fg_params->num_cr_points) {
3285 if (AV1_REMAINING_BITS (br) < 8 + 8 + 9) {
3286 ret = GST_AV1_PARSER_NO_MORE_DATA;
3287 goto error;
3288 }
3289 fg_params->cr_mult = AV1_READ_BITS (br, 8);
3290 fg_params->cr_luma_mult = AV1_READ_BITS (br, 8);
3291 fg_params->cr_offset = AV1_READ_BITS (br, 9);
3292 }
3293
3294 if (AV1_REMAINING_BITS (br) < 2) {
3295 ret = GST_AV1_PARSER_NO_MORE_DATA;
3296 goto error;
3297 }
3298 fg_params->overlap_flag = AV1_READ_BIT (br);
3299 fg_params->clip_to_restricted_range = AV1_READ_BIT (br);
3300
3301 success:
3302 return GST_AV1_PARSER_OK;
3303
3304 error:
3305 GST_WARNING ("parse film grain params error %d", ret);
3306 return ret;
3307 }
3308
3309 /* 5.9.4 */
3310 static void
gst_av1_mark_ref_frames(GstAV1Parser * parser,GstBitReader * br,gint idLen)3311 gst_av1_mark_ref_frames (GstAV1Parser * parser, GstBitReader * br, gint idLen)
3312 {
3313 GstAV1ReferenceFrameInfo *ref_info;
3314 GstAV1SequenceHeaderOBU *seq_header;
3315 gint i, diff_len /* diffLen */ ;
3316
3317 seq_header = parser->seq_header;
3318 ref_info = &(parser->state.ref_info);
3319 diff_len = seq_header->delta_frame_id_length_minus_2 + 2;
3320
3321 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3322 if (parser->state.current_frame_id > (1 << diff_len)) {
3323 if (ref_info->entry[i].ref_frame_id > parser->state.current_frame_id
3324 || ref_info->entry[i].ref_frame_id <
3325 (parser->state.current_frame_id - (1 << diff_len)))
3326 ref_info->entry[i].ref_valid = 0;
3327 } else {
3328 if (ref_info->entry[i].ref_frame_id > parser->state.current_frame_id
3329 && ref_info->entry[i].ref_frame_id <
3330 ((1 << idLen) + parser->state.current_frame_id - (1 << diff_len)))
3331 ref_info->entry[i].ref_valid = 0;
3332 }
3333 }
3334 }
3335
3336 /* 5.11.14 */
3337 static gboolean
gst_av1_seg_feature_active_idx(GstAV1Parser * parser,GstAV1FrameHeaderOBU * frame_header,gint idx,gint feature)3338 gst_av1_seg_feature_active_idx (GstAV1Parser * parser,
3339 GstAV1FrameHeaderOBU * frame_header, gint idx, gint feature)
3340 {
3341 return frame_header->segmentation_params.segmentation_enabled
3342 && frame_header->segmentation_params.feature_enabled[idx][feature];
3343 }
3344
3345 /* 7.12.2 */
3346 static gint
gst_av1_get_qindex(GstAV1Parser * parser,GstAV1FrameHeaderOBU * frame_header,gboolean ignoreDeltaQ,gint segmentId)3347 gst_av1_get_qindex (GstAV1Parser * parser,
3348 GstAV1FrameHeaderOBU * frame_header, gboolean ignoreDeltaQ, gint segmentId)
3349 {
3350 gint qindex;
3351 if (gst_av1_seg_feature_active_idx (parser, frame_header, segmentId,
3352 GST_AV1_SEG_LVL_ALT_Q)) {
3353 gint data =
3354 frame_header->
3355 segmentation_params.feature_data[segmentId][GST_AV1_SEG_LVL_ALT_Q];
3356 qindex = frame_header->quantization_params.base_q_idx + data;
3357 if (ignoreDeltaQ == 0 && frame_header->quantization_params.delta_q_present)
3358 qindex = qindex + frame_header->quantization_params.delta_q_res;
3359 return CLAMP (qindex, 0, 255);
3360 } else
3361 return frame_header->quantization_params.base_q_idx;
3362 }
3363
3364 /* 7.8 */
3365 static void
gst_av1_set_frame_refs(GstAV1Parser * parser,GstAV1SequenceHeaderOBU * seq_header,GstAV1FrameHeaderOBU * frame_header)3366 gst_av1_set_frame_refs (GstAV1Parser * parser,
3367 GstAV1SequenceHeaderOBU * seq_header, GstAV1FrameHeaderOBU * frame_header)
3368 {
3369 const GstAV1ReferenceFrame ref_frame_list[GST_AV1_REFS_PER_FRAME - 2] = {
3370 GST_AV1_REF_LAST2_FRAME,
3371 GST_AV1_REF_LAST3_FRAME,
3372 GST_AV1_REF_BWDREF_FRAME,
3373 GST_AV1_REF_ALTREF2_FRAME,
3374 GST_AV1_REF_ALTREF_FRAME
3375 };
3376 gboolean used_frame[GST_AV1_NUM_REF_FRAMES];
3377 gint shifted_order_hints[GST_AV1_NUM_REF_FRAMES];
3378 gint cur_frame_hint = 1 << (seq_header->order_hint_bits - 1);
3379 gint last_order_hint, earliest_order_hint;
3380 gint ref, hint;
3381 gint i, j;
3382
3383 g_assert (seq_header->enable_order_hint);
3384 g_assert (seq_header->order_hint_bits_minus_1 >= 0);
3385
3386 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
3387 frame_header->ref_frame_idx[i] = -1;
3388 frame_header->ref_frame_idx[GST_AV1_REF_LAST_FRAME -
3389 GST_AV1_REF_LAST_FRAME] = frame_header->last_frame_idx;
3390 frame_header->ref_frame_idx[GST_AV1_REF_GOLDEN_FRAME -
3391 GST_AV1_REF_LAST_FRAME] = frame_header->gold_frame_idx;
3392
3393 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++)
3394 used_frame[i] = 0;
3395 used_frame[frame_header->last_frame_idx] = 1;
3396 used_frame[frame_header->gold_frame_idx] = 1;
3397
3398 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++)
3399 shifted_order_hints[i] = cur_frame_hint +
3400 gst_av1_get_relative_dist (seq_header,
3401 parser->state.ref_info.entry[i].ref_order_hint,
3402 frame_header->order_hint);
3403
3404 last_order_hint = shifted_order_hints[frame_header->last_frame_idx];
3405
3406 /* === Backward Reference Frames === */
3407 /* The ALTREF_FRAME reference is set to be a backward
3408 reference to the frame with highest output order. */
3409 ref = -1;
3410 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3411 hint = shifted_order_hints[i];
3412 if (!used_frame[i] && hint >= cur_frame_hint
3413 && (ref < 0 || hint >= last_order_hint)) {
3414 ref = i;
3415 last_order_hint = hint;
3416 }
3417 }
3418 if (ref >= 0) {
3419 frame_header->ref_frame_idx[GST_AV1_REF_ALTREF_FRAME -
3420 GST_AV1_REF_LAST_FRAME] = ref;
3421 used_frame[ref] = 1;
3422 }
3423
3424 /* The BWDREF_FRAME reference is set to be a backward reference
3425 to the closest frame. */
3426 ref = -1;
3427 earliest_order_hint = last_order_hint;
3428 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3429 hint = shifted_order_hints[i];
3430 if (!used_frame[i] && hint >= cur_frame_hint
3431 && (ref < 0 || hint < earliest_order_hint)) {
3432 ref = i;
3433 earliest_order_hint = hint;
3434 }
3435 }
3436 if (ref >= 0) {
3437 frame_header->ref_frame_idx[GST_AV1_REF_BWDREF_FRAME -
3438 GST_AV1_REF_LAST_FRAME] = ref;
3439 used_frame[ref] = 1;
3440 }
3441
3442 /* The ALTREF2_FRAME reference is set to the next closest
3443 backward reference. */
3444 ref = -1;
3445 earliest_order_hint = last_order_hint;
3446 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3447 hint = shifted_order_hints[i];
3448 if (!used_frame[i] && hint >= cur_frame_hint
3449 && (ref < 0 || hint < earliest_order_hint)) {
3450 ref = i;
3451 earliest_order_hint = hint;
3452 }
3453 }
3454 if (ref >= 0) {
3455 frame_header->ref_frame_idx[GST_AV1_REF_ALTREF2_FRAME -
3456 GST_AV1_REF_LAST_FRAME] = ref;
3457 used_frame[ref] = 1;
3458 }
3459
3460 /* === Forward Reference Frames === */
3461
3462 /* The remaining references are set to be forward references
3463 in anti-chronological order. */
3464 last_order_hint = 0;
3465 for (i = 0; i < GST_AV1_REFS_PER_FRAME - 2; i++) {
3466 GstAV1ReferenceFrame ref_frame = ref_frame_list[i];
3467 if (frame_header->ref_frame_idx[ref_frame - GST_AV1_REF_LAST_FRAME] < 0) {
3468 ref = -1;
3469 for (j = 0; j < GST_AV1_NUM_REF_FRAMES; j++) {
3470 hint = shifted_order_hints[j];
3471 if (!used_frame[j] && hint < cur_frame_hint &&
3472 (ref < 0 || hint >= last_order_hint)) {
3473 ref = j;
3474 last_order_hint = hint;
3475 }
3476 }
3477
3478 if (ref >= 0) {
3479 frame_header->ref_frame_idx[ref_frame - GST_AV1_REF_LAST_FRAME] = ref;
3480 used_frame[ref] = 1;
3481 }
3482 }
3483 }
3484
3485 /* Finally, any remaining references are set to the reference frame
3486 with smallest output order. */
3487 ref = -1;
3488 earliest_order_hint = cur_frame_hint * 2;
3489 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3490 hint = shifted_order_hints[i];
3491 if (ref < 0 || hint < earliest_order_hint) {
3492 ref = i;
3493 earliest_order_hint = hint;
3494 }
3495 }
3496 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
3497 if (frame_header->ref_frame_idx[i] < 0)
3498 frame_header->ref_frame_idx[i] = ref;
3499 }
3500
3501 /* 5.9.2 */
3502 static GstAV1ParserResult
gst_av1_parse_uncompressed_frame_header(GstAV1Parser * parser,GstAV1OBU * obu,GstBitReader * br,GstAV1FrameHeaderOBU * frame_header)3503 gst_av1_parse_uncompressed_frame_header (GstAV1Parser * parser, GstAV1OBU * obu,
3504 GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
3505 {
3506 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
3507 GstAV1ReferenceFrameInfo *ref_info;
3508 GstAV1SequenceHeaderOBU *seq_header;
3509 gint i, op_num /* opNum */ ;
3510 gint segment_id /* segmentId */ , all_frames /* allFrames */ ;
3511 gint id_len /* idLen */ = 0;
3512
3513 if (!parser->seq_header) {
3514 GST_WARNING ("Missing OBU Reference: seq_header");
3515 retval = GST_AV1_PARSER_MISSING_OBU_REFERENCE;
3516 goto error;
3517 }
3518
3519 seq_header = parser->seq_header;
3520 ref_info = &(parser->state.ref_info);
3521 if (seq_header->frame_id_numbers_present_flag)
3522 id_len = seq_header->additional_frame_id_length_minus_1 + 1 +
3523 seq_header->delta_frame_id_length_minus_2 + 2;
3524 all_frames = (1 << GST_AV1_NUM_REF_FRAMES) - 1;
3525
3526 if (seq_header->reduced_still_picture_header) {
3527 frame_header->show_existing_frame = 0;
3528 frame_header->frame_type = GST_AV1_KEY_FRAME;
3529 frame_header->frame_is_intra = 1;
3530 frame_header->show_frame = 1;
3531 frame_header->showable_frame = 0;
3532 if (parser->state.sequence_changed) {
3533 /* This is the start of a new coded video sequence. */
3534 parser->state.sequence_changed = 0;
3535 parser->state.begin_first_frame = 1;
3536 }
3537 } else {
3538 frame_header->show_existing_frame = AV1_READ_BIT_CHECKED (br, &retval);
3539 if (retval != GST_AV1_PARSER_OK)
3540 goto error;
3541
3542 if (frame_header->show_existing_frame) {
3543 if (parser->state.sequence_changed) {
3544 GST_INFO ("New sequence header starts with a show_existing_frame.");
3545 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3546 goto error;
3547 }
3548
3549 frame_header->frame_to_show_map_idx =
3550 AV1_READ_BITS_CHECKED (br, 3, &retval);
3551 if (retval != GST_AV1_PARSER_OK)
3552 goto error;
3553
3554 if (!ref_info->entry[frame_header->frame_to_show_map_idx].ref_valid) {
3555 GST_INFO ("The frame_to_show %d is invalid.",
3556 frame_header->frame_to_show_map_idx);
3557 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3558 goto error;
3559 }
3560
3561 if (seq_header->decoder_model_info_present_flag
3562 && !seq_header->timing_info.equal_picture_interval)
3563 frame_header->frame_presentation_time =
3564 AV1_READ_BITS_CHECKED (br,
3565 seq_header->
3566 decoder_model_info.frame_presentation_time_length_minus_1 + 1,
3567 &retval);
3568 if (retval != GST_AV1_PARSER_OK)
3569 goto error;
3570
3571 frame_header->refresh_frame_flags = 0;
3572 if (seq_header->frame_id_numbers_present_flag) {
3573 g_assert (id_len > 0);
3574 frame_header->display_frame_id =
3575 AV1_READ_BITS_CHECKED (br, id_len, &retval);
3576 if (retval != GST_AV1_PARSER_OK)
3577 goto error;
3578 if (frame_header->display_frame_id !=
3579 ref_info->entry[frame_header->frame_to_show_map_idx].ref_frame_id) {
3580 GST_INFO ("Reference frame ID mismatch");
3581 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3582 goto error;
3583 }
3584 }
3585
3586 frame_header->frame_type =
3587 ref_info->entry[frame_header->frame_to_show_map_idx].ref_frame_type;
3588 if (frame_header->frame_type == GST_AV1_KEY_FRAME) {
3589 frame_header->refresh_frame_flags = all_frames;
3590 }
3591
3592 /* just use the frame_to_show's grain_params
3593 * if (seq_header->film_grain_params_present)
3594 * load_grain_params () */
3595
3596 goto success;
3597 }
3598
3599 frame_header->frame_type = AV1_READ_BITS_CHECKED (br, 2, &retval);
3600 if (retval != GST_AV1_PARSER_OK)
3601 goto error;
3602
3603 if (parser->state.sequence_changed) {
3604 if (frame_header->frame_type == GST_AV1_KEY_FRAME) {
3605 /* This is the start of a new coded video sequence. */
3606 parser->state.sequence_changed = FALSE;
3607 parser->state.begin_first_frame = TRUE;
3608 } else {
3609 GST_INFO ("Sequence header has changed without a keyframe.");
3610 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3611 goto error;
3612 }
3613 }
3614
3615 frame_header->frame_is_intra =
3616 (frame_header->frame_type == GST_AV1_INTRA_ONLY_FRAME
3617 || frame_header->frame_type == GST_AV1_KEY_FRAME);
3618
3619 frame_header->show_frame = AV1_READ_BIT_CHECKED (br, &retval);
3620 if (retval != GST_AV1_PARSER_OK)
3621 goto error;
3622
3623 if (seq_header->still_picture &&
3624 (frame_header->frame_type != GST_AV1_KEY_FRAME
3625 || !frame_header->show_frame)) {
3626 GST_INFO ("Still pictures must be coded as shown keyframes");
3627 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3628 goto error;
3629 }
3630
3631 if (frame_header->show_frame
3632 && seq_header->decoder_model_info_present_flag
3633 && !seq_header->timing_info.equal_picture_interval) {
3634 frame_header->frame_presentation_time =
3635 AV1_READ_BITS_CHECKED (br,
3636 seq_header->decoder_model_info.
3637 frame_presentation_time_length_minus_1 + 1, &retval);
3638 if (retval != GST_AV1_PARSER_OK)
3639 goto error;
3640 }
3641
3642 if (frame_header->show_frame) {
3643 frame_header->showable_frame =
3644 (frame_header->frame_type != GST_AV1_KEY_FRAME);
3645 } else {
3646 frame_header->showable_frame = AV1_READ_BIT_CHECKED (br, &retval);
3647 if (retval != GST_AV1_PARSER_OK)
3648 goto error;
3649 }
3650
3651 if (frame_header->frame_type == GST_AV1_SWITCH_FRAME
3652 || (frame_header->frame_type == GST_AV1_KEY_FRAME
3653 && frame_header->show_frame))
3654 frame_header->error_resilient_mode = 1;
3655 else {
3656 frame_header->error_resilient_mode = AV1_READ_BIT_CHECKED (br, &retval);
3657 if (retval != GST_AV1_PARSER_OK)
3658 goto error;
3659 }
3660 }
3661
3662 if (frame_header->frame_type == GST_AV1_KEY_FRAME && frame_header->show_frame) {
3663 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3664 ref_info->entry[i].ref_valid = 0;
3665 ref_info->entry[i].ref_order_hint = 0;
3666 }
3667 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
3668 frame_header->order_hints[GST_AV1_REF_LAST_FRAME + i] = 0;
3669 }
3670 }
3671
3672 frame_header->disable_cdf_update = AV1_READ_BIT_CHECKED (br, &retval);
3673 if (retval != GST_AV1_PARSER_OK)
3674 goto error;
3675
3676 if (seq_header->seq_force_screen_content_tools ==
3677 GST_AV1_SELECT_SCREEN_CONTENT_TOOLS) {
3678 frame_header->allow_screen_content_tools =
3679 AV1_READ_BIT_CHECKED (br, &retval);
3680 if (retval != GST_AV1_PARSER_OK)
3681 goto error;
3682 } else {
3683 frame_header->allow_screen_content_tools =
3684 seq_header->seq_force_screen_content_tools;
3685 }
3686
3687 if (frame_header->allow_screen_content_tools) {
3688 if (seq_header->seq_force_integer_mv == GST_AV1_SELECT_INTEGER_MV) {
3689 frame_header->force_integer_mv = AV1_READ_BIT_CHECKED (br, &retval);
3690 if (retval != GST_AV1_PARSER_OK)
3691 goto error;
3692 } else {
3693 frame_header->force_integer_mv = seq_header->seq_force_integer_mv;
3694 }
3695 } else {
3696 frame_header->force_integer_mv = 0;
3697 }
3698
3699 if (frame_header->frame_is_intra) {
3700 frame_header->force_integer_mv = 1;
3701 }
3702
3703 if (seq_header->frame_id_numbers_present_flag) {
3704 gboolean have_prev_frame_id =
3705 !parser->state.begin_first_frame &&
3706 (!(frame_header->frame_type == GST_AV1_KEY_FRAME
3707 && frame_header->show_frame));
3708 if (have_prev_frame_id)
3709 parser->state.prev_frame_id = parser->state.current_frame_id;
3710
3711 g_assert (id_len > 0);
3712 frame_header->current_frame_id =
3713 AV1_READ_BITS_CHECKED (br, id_len, &retval);
3714 if (retval != GST_AV1_PARSER_OK)
3715 goto error;
3716
3717 parser->state.current_frame_id = frame_header->current_frame_id;
3718 /* Check whether the id and id diff is valid */
3719 if (have_prev_frame_id) {
3720 gint32 diff_frame_id;
3721 if (parser->state.current_frame_id > parser->state.prev_frame_id) {
3722 diff_frame_id =
3723 parser->state.current_frame_id - parser->state.prev_frame_id;
3724 } else {
3725 diff_frame_id = (1 << id_len) +
3726 parser->state.current_frame_id - parser->state.prev_frame_id;
3727 }
3728 if (parser->state.current_frame_id == parser->state.prev_frame_id ||
3729 diff_frame_id >= (1 << (id_len - 1))) {
3730 GST_INFO ("Invalid value of current_frame_id");
3731 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3732 goto error;
3733 }
3734 }
3735
3736 gst_av1_mark_ref_frames (parser, br, id_len);
3737 } else {
3738 frame_header->current_frame_id = 0;
3739 parser->state.prev_frame_id = parser->state.current_frame_id;
3740 parser->state.current_frame_id = frame_header->current_frame_id;
3741 }
3742
3743 if (frame_header->frame_type == GST_AV1_SWITCH_FRAME) {
3744 frame_header->frame_size_override_flag = 1;
3745 } else if (seq_header->reduced_still_picture_header) {
3746 frame_header->frame_size_override_flag = 0;
3747 } else {
3748 frame_header->frame_size_override_flag = AV1_READ_BIT_CHECKED (br, &retval);
3749 if (retval != GST_AV1_PARSER_OK)
3750 goto error;
3751 }
3752
3753 frame_header->order_hint =
3754 AV1_READ_BITS_CHECKED (br, seq_header->order_hint_bits_minus_1 + 1,
3755 &retval);
3756 if (retval != GST_AV1_PARSER_OK)
3757 goto error;
3758
3759 if (frame_header->frame_is_intra || frame_header->error_resilient_mode) {
3760 frame_header->primary_ref_frame = GST_AV1_PRIMARY_REF_NONE;
3761 } else {
3762 frame_header->primary_ref_frame = AV1_READ_BITS_CHECKED (br, 3, &retval);
3763 if (retval != GST_AV1_PARSER_OK)
3764 goto error;
3765 }
3766
3767 if (seq_header->decoder_model_info_present_flag) {
3768 frame_header->buffer_removal_time_present_flag =
3769 AV1_READ_BIT_CHECKED (br, &retval);
3770 if (retval != GST_AV1_PARSER_OK)
3771 goto error;
3772
3773 if (frame_header->buffer_removal_time_present_flag) {
3774 for (op_num = 0; op_num <= seq_header->operating_points_cnt_minus_1;
3775 op_num++) {
3776 if (seq_header->
3777 operating_points[op_num].decoder_model_present_for_this_op) {
3778 gint op_pt_idc = seq_header->operating_points[op_num].idc;
3779 gint in_temporal_layer =
3780 (op_pt_idc >> obu->header.obu_temporal_id) & 1;
3781 gint in_spatial_layer =
3782 (op_pt_idc >> (obu->header.obu_spatial_id + 8)) & 1;
3783 if (op_pt_idc == 0 || (in_temporal_layer && in_spatial_layer)) {
3784 frame_header->buffer_removal_time[op_num] =
3785 AV1_READ_BITS_CHECKED (br,
3786 seq_header->decoder_model_info.
3787 buffer_removal_time_length_minus_1 + 1, &retval);
3788 if (retval != GST_AV1_PARSER_OK)
3789 goto error;
3790 } else {
3791 frame_header->buffer_removal_time[op_num] = 0;
3792 }
3793 } else {
3794 frame_header->buffer_removal_time[op_num] = 0;
3795 }
3796 }
3797 }
3798 }
3799
3800 frame_header->allow_high_precision_mv = 0;
3801 frame_header->use_ref_frame_mvs = 0;
3802 frame_header->allow_intrabc = 0;
3803 if (frame_header->frame_type == GST_AV1_SWITCH_FRAME ||
3804 (frame_header->frame_type == GST_AV1_KEY_FRAME
3805 && frame_header->show_frame)) {
3806 frame_header->refresh_frame_flags = all_frames;
3807 } else {
3808 frame_header->refresh_frame_flags = AV1_READ_UINT8_CHECKED (br, &retval);
3809 if (retval != GST_AV1_PARSER_OK)
3810 goto error;
3811 }
3812 if (frame_header->frame_type == GST_AV1_INTRA_ONLY_FRAME) {
3813 if (frame_header->refresh_frame_flags == 0xFF) {
3814 GST_INFO ("Intra only frames cannot have refresh flags 0xFF");
3815 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3816 goto error;
3817 }
3818 }
3819
3820 if (!frame_header->frame_is_intra
3821 || frame_header->refresh_frame_flags != all_frames) {
3822 if (frame_header->error_resilient_mode && seq_header->enable_order_hint) {
3823 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
3824 frame_header->ref_order_hint[i] = AV1_READ_BITS_CHECKED (br,
3825 seq_header->order_hint_bits_minus_1 + 1, &retval);
3826 if (retval != GST_AV1_PARSER_OK)
3827 goto error;
3828
3829 if (frame_header->ref_order_hint[i] !=
3830 ref_info->entry[i].ref_order_hint)
3831 ref_info->entry[i].ref_valid = 0;
3832 }
3833 }
3834 }
3835
3836 if (frame_header->frame_is_intra) {
3837 retval = gst_av1_parse_frame_size (parser, br, frame_header);
3838 if (retval != GST_AV1_PARSER_OK)
3839 goto error;
3840 retval = gst_av1_parse_render_size (parser, br, frame_header);
3841 if (retval != GST_AV1_PARSER_OK)
3842 goto error;
3843 if (frame_header->allow_screen_content_tools
3844 && parser->state.upscaled_width == parser->state.frame_width) {
3845 frame_header->allow_intrabc = AV1_READ_BIT_CHECKED (br, &retval);
3846 if (retval != GST_AV1_PARSER_OK)
3847 goto error;
3848 }
3849
3850 frame_header->upscaled_width = parser->state.upscaled_width;
3851 frame_header->frame_width = parser->state.frame_width;
3852 frame_header->frame_height = parser->state.frame_height;
3853 frame_header->render_width = parser->state.render_width;
3854 frame_header->render_height = parser->state.render_height;
3855 } else {
3856 if (!seq_header->enable_order_hint) {
3857 frame_header->frame_refs_short_signaling = 0;
3858 } else {
3859 frame_header->frame_refs_short_signaling =
3860 AV1_READ_BIT_CHECKED (br, &retval);
3861 if (retval != GST_AV1_PARSER_OK)
3862 goto error;
3863
3864 if (frame_header->frame_refs_short_signaling) {
3865 if (AV1_REMAINING_BITS (br) < 3 + 3) {
3866 retval = GST_AV1_PARSER_NO_MORE_DATA;
3867 goto error;
3868 }
3869 frame_header->last_frame_idx = AV1_READ_BITS (br, 3);
3870 frame_header->gold_frame_idx = AV1_READ_BITS (br, 3);
3871 gst_av1_set_frame_refs (parser, seq_header, frame_header);
3872 }
3873 }
3874
3875 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
3876 if (!frame_header->frame_refs_short_signaling) {
3877 frame_header->ref_frame_idx[i] = AV1_READ_BITS_CHECKED (br, 3, &retval);
3878 if (retval != GST_AV1_PARSER_OK)
3879 goto error;
3880 }
3881
3882 if (seq_header->frame_id_numbers_present_flag) {
3883 gint32 delta_frame_id /* DeltaFrameId */ ;
3884 gint32 expected_frame_id;
3885 guint32 delta_frame_id_minus_1;
3886
3887 g_assert (id_len > 0);
3888
3889 delta_frame_id_minus_1 = AV1_READ_BITS_CHECKED (br,
3890 seq_header->delta_frame_id_length_minus_2 + 2, &retval);
3891 if (retval != GST_AV1_PARSER_OK)
3892 goto error;
3893
3894 delta_frame_id = delta_frame_id_minus_1 + 1;
3895 expected_frame_id = (frame_header->current_frame_id + (1 << id_len) -
3896 delta_frame_id) % (1 << id_len);
3897 if (expected_frame_id !=
3898 parser->state.ref_info.entry[frame_header->
3899 ref_frame_idx[i]].ref_frame_id) {
3900 GST_INFO ("Reference buffer frame ID mismatch, expectedFrameId"
3901 " is %d wihle ref frame id is %d", expected_frame_id,
3902 parser->state.ref_info.entry[frame_header->
3903 ref_frame_idx[i]].ref_frame_id);
3904 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3905 goto error;
3906 }
3907 }
3908 }
3909
3910 if (frame_header->frame_size_override_flag
3911 && !frame_header->error_resilient_mode) {
3912 retval = gst_av1_parse_frame_size_with_refs (parser, br, frame_header);
3913 if (retval != GST_AV1_PARSER_OK)
3914 goto error;
3915 } else {
3916 retval = gst_av1_parse_frame_size (parser, br, frame_header);
3917 if (retval != GST_AV1_PARSER_OK)
3918 goto error;
3919 retval = gst_av1_parse_render_size (parser, br, frame_header);
3920 if (retval != GST_AV1_PARSER_OK)
3921 goto error;
3922 }
3923 frame_header->upscaled_width = parser->state.upscaled_width;
3924 frame_header->frame_width = parser->state.frame_width;
3925 frame_header->frame_height = parser->state.frame_height;
3926 frame_header->render_width = parser->state.render_width;
3927 frame_header->render_height = parser->state.render_height;
3928
3929 if (frame_header->force_integer_mv) {
3930 frame_header->allow_high_precision_mv = 0;
3931 } else {
3932 frame_header->allow_high_precision_mv =
3933 AV1_READ_BIT_CHECKED (br, &retval);
3934 if (retval != GST_AV1_PARSER_OK)
3935 goto error;
3936 }
3937
3938 /* read_interpolation_filter() expand */
3939 frame_header->is_filter_switchable = AV1_READ_BIT_CHECKED (br, &retval);
3940 if (retval != GST_AV1_PARSER_OK)
3941 goto error;
3942
3943 if (frame_header->is_filter_switchable) {
3944 frame_header->interpolation_filter =
3945 GST_AV1_INTERPOLATION_FILTER_SWITCHABLE;
3946 } else {
3947 frame_header->interpolation_filter =
3948 AV1_READ_BITS_CHECKED (br, 2, &retval);
3949 if (retval != GST_AV1_PARSER_OK)
3950 goto error;
3951 }
3952
3953 frame_header->is_motion_mode_switchable =
3954 AV1_READ_BIT_CHECKED (br, &retval);
3955 if (retval != GST_AV1_PARSER_OK)
3956 goto error;
3957
3958 if (frame_header->error_resilient_mode || !seq_header->enable_ref_frame_mvs) {
3959 frame_header->use_ref_frame_mvs = 0;
3960 } else {
3961 frame_header->use_ref_frame_mvs = AV1_READ_BIT_CHECKED (br, &retval);
3962 if (retval != GST_AV1_PARSER_OK)
3963 goto error;
3964 }
3965 }
3966
3967 if (!frame_header->frame_is_intra) {
3968 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
3969 gint refFrame = GST_AV1_REF_LAST_FRAME + i;
3970 gint hint =
3971 ref_info->entry[frame_header->ref_frame_idx[i]].ref_order_hint;
3972 frame_header->order_hints[refFrame] = hint;
3973 if (!seq_header->enable_order_hint) {
3974 frame_header->ref_frame_sign_bias[refFrame] = 0;
3975 } else {
3976 frame_header->ref_frame_sign_bias[refFrame] =
3977 (gst_av1_get_relative_dist (parser->seq_header, hint,
3978 frame_header->order_hint) > 0);
3979 }
3980 }
3981 }
3982
3983 if (seq_header->reduced_still_picture_header
3984 || frame_header->disable_cdf_update)
3985 frame_header->disable_frame_end_update_cdf = 1;
3986 else {
3987 frame_header->disable_frame_end_update_cdf =
3988 AV1_READ_BIT_CHECKED (br, &retval);
3989 if (retval != GST_AV1_PARSER_OK)
3990 goto error;
3991 }
3992
3993 if (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE &&
3994 !ref_info->entry[frame_header->ref_frame_idx[frame_header->
3995 primary_ref_frame]].ref_valid) {
3996 GST_INFO ("Primary ref point to an invalid frame");
3997 retval = GST_AV1_PARSER_BITSTREAM_ERROR;
3998 goto error;
3999 }
4000
4001 if (frame_header->primary_ref_frame == GST_AV1_PRIMARY_REF_NONE) {
4002 /* do something in setup_past_independence() of parser level */
4003 gint8 *loop_filter_ref_deltas =
4004 frame_header->loop_filter_params.loop_filter_ref_deltas;
4005
4006 frame_header->loop_filter_params.loop_filter_delta_enabled = 1;
4007 loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME] = 1;
4008 loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME] = 0;
4009 loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME] = 0;
4010 loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME] = 0;
4011 loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME] = 0;
4012 loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME] = -1;
4013 loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME] = -1;
4014 loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME] = -1;
4015 frame_header->loop_filter_params.loop_filter_mode_deltas[0] = 0;
4016 frame_header->loop_filter_params.loop_filter_mode_deltas[1] = 0;
4017 } else {
4018 /* do something in load_previous() of parser level */
4019 /* load_loop_filter_params() */
4020 GstAV1LoopFilterParams *ref_lf_params =
4021 &parser->state.ref_info.entry[frame_header->
4022 ref_frame_idx[frame_header->primary_ref_frame]].ref_lf_params;
4023 gint8 *loop_filter_ref_deltas =
4024 frame_header->loop_filter_params.loop_filter_ref_deltas;
4025
4026 /* Copy all from prime_ref */
4027 g_assert (parser->state.ref_info.
4028 entry[frame_header->ref_frame_idx[frame_header->primary_ref_frame]].
4029 ref_valid);
4030 loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME] =
4031 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME];
4032 loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME] =
4033 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME];
4034 loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME] =
4035 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME];
4036 loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME] =
4037 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME];
4038 loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME] =
4039 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME];
4040 loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME] =
4041 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME];
4042 loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME] =
4043 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME];
4044 loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME] =
4045 ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME];
4046 for (i = 0; i < 2; i++)
4047 frame_header->loop_filter_params.loop_filter_mode_deltas[i] =
4048 ref_lf_params->loop_filter_mode_deltas[i];
4049 }
4050
4051 /* @TODO:
4052 if ( primary_ref_frame == PRIMARY_REF_NONE ) {
4053 init_non_coeff_cdfs( )
4054 } else {
4055 load_cdfs( ref_frame_idx[primary_ref_frame] )
4056 }
4057 */
4058 /* @TODO:
4059 if ( use_ref_frame_mvs == 1 )
4060 motion_field_estimation( )
4061 */
4062
4063 retval = gst_av1_parse_tile_info (parser, br, frame_header);
4064 if (retval != GST_AV1_PARSER_OK)
4065 goto error;
4066
4067 retval = gst_av1_parse_quantization_params (parser, br, frame_header);
4068 if (retval != GST_AV1_PARSER_OK)
4069 goto error;
4070
4071 retval = gst_av1_parse_segmentation_params (parser, br, frame_header);
4072 if (retval != GST_AV1_PARSER_OK)
4073 goto error;
4074
4075 retval = gst_av1_parse_delta_q_params (parser, br,
4076 &(frame_header->quantization_params));
4077 if (retval != GST_AV1_PARSER_OK)
4078 goto error;
4079
4080 retval = gst_av1_parse_delta_lf_params (parser, br, frame_header);
4081 if (retval != GST_AV1_PARSER_OK)
4082 goto error;
4083
4084 /* @TODO:
4085 if ( primary_ref_frame == PRIMARY_REF_NONE ) {
4086 init_coeff_cdfs( )
4087 } else {
4088 load_previous_segment_ids( )
4089 }
4090 */
4091
4092 frame_header->coded_lossless = 1;
4093 for (segment_id = 0; segment_id < GST_AV1_MAX_SEGMENTS; segment_id++) {
4094 gint qindex = gst_av1_get_qindex (parser, frame_header, 1, segment_id);
4095 frame_header->lossless_array[segment_id] = (qindex == 0)
4096 && (frame_header->quantization_params.delta_q_y_dc == 0)
4097 && (frame_header->quantization_params.delta_q_u_ac == 0)
4098 && (frame_header->quantization_params.delta_q_u_dc == 0)
4099 && (frame_header->quantization_params.delta_q_v_ac == 0)
4100 && (frame_header->quantization_params.delta_q_v_dc == 0);
4101 if (!frame_header->lossless_array[segment_id])
4102 frame_header->coded_lossless = 0;
4103 if (frame_header->quantization_params.using_qmatrix) {
4104 if (frame_header->lossless_array[segment_id]) {
4105 frame_header->seg_qm_Level[0][segment_id] = 15;
4106 frame_header->seg_qm_Level[1][segment_id] = 15;
4107 frame_header->seg_qm_Level[2][segment_id] = 15;
4108 } else {
4109 frame_header->seg_qm_Level[0][segment_id] =
4110 frame_header->quantization_params.qm_y;
4111 frame_header->seg_qm_Level[1][segment_id] =
4112 frame_header->quantization_params.qm_u;
4113 frame_header->seg_qm_Level[2][segment_id] =
4114 frame_header->quantization_params.qm_v;
4115 }
4116 }
4117 }
4118 frame_header->all_lossless = frame_header->coded_lossless
4119 && (parser->state.frame_width == parser->state.upscaled_width);
4120
4121 retval = gst_av1_parse_loop_filter_params (parser, br, frame_header);
4122 if (retval != GST_AV1_PARSER_OK)
4123 goto error;
4124
4125 retval = gst_av1_parse_cdef_params (parser, br, frame_header);
4126 if (retval != GST_AV1_PARSER_OK)
4127 goto error;
4128
4129 retval = gst_av1_parse_loop_restoration_params (parser, br, frame_header);
4130 if (retval != GST_AV1_PARSER_OK)
4131 goto error;
4132
4133 retval = gst_av1_parse_tx_mode (parser, br, frame_header);
4134 if (retval != GST_AV1_PARSER_OK)
4135 goto error;
4136
4137 /* 5.9.23 inlined frame_reference_mode () */
4138 if (frame_header->frame_is_intra) {
4139 frame_header->reference_select = 0;
4140 } else {
4141 frame_header->reference_select = AV1_READ_BIT_CHECKED (br, &retval);
4142 if (retval != GST_AV1_PARSER_OK)
4143 goto error;
4144 }
4145
4146 retval = gst_av1_parse_skip_mode_params (parser, br, frame_header);
4147 if (retval != GST_AV1_PARSER_OK)
4148 goto error;
4149
4150 if (frame_header->frame_is_intra ||
4151 frame_header->error_resilient_mode || !seq_header->enable_warped_motion)
4152 frame_header->allow_warped_motion = 0;
4153 else {
4154 frame_header->allow_warped_motion = AV1_READ_BIT_CHECKED (br, &retval);
4155 if (retval != GST_AV1_PARSER_OK)
4156 goto error;
4157 }
4158
4159 frame_header->reduced_tx_set = AV1_READ_BIT_CHECKED (br, &retval);
4160 if (retval != GST_AV1_PARSER_OK)
4161 goto error;
4162
4163 retval = gst_av1_parse_global_motion_params (parser, br, frame_header);
4164 if (retval != GST_AV1_PARSER_OK)
4165 goto error;
4166
4167 retval = gst_av1_parse_film_grain_params (parser, br, frame_header);
4168 if (retval != GST_AV1_PARSER_OK)
4169 goto error;
4170
4171 success:
4172 return GST_AV1_PARSER_OK;
4173
4174 error:
4175 GST_WARNING ("parse uncompressed frame header error %d", retval);
4176 return retval;
4177 }
4178
4179 /* 7.21 */
4180 /**
4181 * gst_av1_parser_reference_frame_loading:
4182 * @parser: the #GstAV1Parser
4183 * @frame_header: a #GstAV1FrameHeaderOBU to load
4184 *
4185 * Load the context of @frame_header to parser's state. This function is
4186 * used when we want to show already parsed frames before.
4187 *
4188 * Returns: The #GstAV1ParserResult.
4189 *
4190 * Since: 1.18
4191 */
4192 GstAV1ParserResult
gst_av1_parser_reference_frame_loading(GstAV1Parser * parser,GstAV1FrameHeaderOBU * frame_header)4193 gst_av1_parser_reference_frame_loading (GstAV1Parser * parser,
4194 GstAV1FrameHeaderOBU * frame_header)
4195 {
4196 GstAV1ReferenceFrameInfo *ref_info;
4197 GstAV1TileInfo *ref_tile_info;
4198
4199 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4200 g_return_val_if_fail (frame_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4201
4202 if (!parser->seq_header) {
4203 GST_WARNING ("Missing OBU Reference: seq_header");
4204 return GST_AV1_PARSER_MISSING_OBU_REFERENCE;
4205 }
4206
4207 ref_info = &(parser->state.ref_info);
4208
4209 if (frame_header->frame_to_show_map_idx > GST_AV1_NUM_REF_FRAMES - 1)
4210 return GST_AV1_PARSER_BITSTREAM_ERROR;
4211
4212 g_assert (ref_info->entry[frame_header->frame_to_show_map_idx].ref_valid);
4213
4214 parser->state.current_frame_id =
4215 ref_info->entry[frame_header->frame_to_show_map_idx].ref_frame_id;
4216 parser->state.upscaled_width =
4217 ref_info->entry[frame_header->frame_to_show_map_idx].ref_upscaled_width;
4218 parser->state.frame_width =
4219 ref_info->entry[frame_header->frame_to_show_map_idx].ref_frame_width;
4220 parser->state.frame_height =
4221 ref_info->entry[frame_header->frame_to_show_map_idx].ref_frame_height;
4222 parser->state.render_width =
4223 ref_info->entry[frame_header->frame_to_show_map_idx].ref_render_width;
4224 parser->state.render_height =
4225 ref_info->entry[frame_header->frame_to_show_map_idx].ref_render_height;
4226 parser->state.mi_cols =
4227 ref_info->entry[frame_header->frame_to_show_map_idx].ref_mi_cols;
4228 parser->state.mi_rows =
4229 ref_info->entry[frame_header->frame_to_show_map_idx].ref_mi_rows;
4230
4231 ref_tile_info =
4232 &ref_info->entry[frame_header->frame_to_show_map_idx].ref_tile_info;
4233
4234 memcpy (parser->state.mi_col_starts, ref_tile_info->mi_col_starts,
4235 sizeof (guint32) * (GST_AV1_MAX_TILE_COLS + 1));
4236 memcpy (parser->state.mi_row_starts, ref_tile_info->mi_row_starts,
4237 sizeof (guint32) * (GST_AV1_MAX_TILE_ROWS + 1));
4238 parser->state.tile_cols_log2 = ref_tile_info->tile_cols_log2;
4239 parser->state.tile_cols = ref_tile_info->tile_cols;
4240 parser->state.tile_rows_log2 = ref_tile_info->tile_rows_log2;
4241 parser->state.tile_rows = ref_tile_info->tile_rows;
4242 parser->state.tile_size_bytes = ref_tile_info->tile_size_bytes;
4243
4244 return GST_AV1_PARSER_OK;
4245 }
4246
4247 /**
4248 * gst_av1_parser_reference_frame_update:
4249 * @parser: the #GstAV1Parser
4250 * @frame_header: a #GstAV1FrameHeaderOBU to load
4251 *
4252 * Update the context of @frame_header to parser's state. This function is
4253 * used when we finish one frame's decoding/showing, and need to update info
4254 * such as reference, global parameters.
4255 *
4256 * Returns: The #GstAV1ParserResult.
4257 *
4258 * Since: 1.18
4259 */
4260 GstAV1ParserResult
gst_av1_parser_reference_frame_update(GstAV1Parser * parser,GstAV1FrameHeaderOBU * frame_header)4261 gst_av1_parser_reference_frame_update (GstAV1Parser * parser,
4262 GstAV1FrameHeaderOBU * frame_header)
4263 {
4264 gint i;
4265 GstAV1SequenceHeaderOBU *seq_header;
4266 GstAV1ReferenceFrameInfo *ref_info;
4267
4268 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4269 g_return_val_if_fail (frame_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4270
4271 if (!parser->seq_header) {
4272 GST_WARNING ("Missing OBU Reference: seq_header");
4273 return GST_AV1_PARSER_MISSING_OBU_REFERENCE;
4274 }
4275
4276 seq_header = parser->seq_header;
4277 ref_info = &(parser->state.ref_info);
4278 if (frame_header->frame_type == GST_AV1_INTRA_ONLY_FRAME
4279 && frame_header->refresh_frame_flags == 0xff)
4280 return GST_AV1_PARSER_BITSTREAM_ERROR;
4281
4282 for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
4283 if ((frame_header->refresh_frame_flags >> i) & 1) {
4284 ref_info->entry[i].ref_valid = 1;
4285 ref_info->entry[i].ref_frame_id = frame_header->current_frame_id;
4286 ref_info->entry[i].ref_frame_type = frame_header->frame_type;
4287 ref_info->entry[i].ref_upscaled_width = frame_header->upscaled_width;
4288 ref_info->entry[i].ref_frame_width = frame_header->frame_width;
4289 ref_info->entry[i].ref_frame_height = frame_header->frame_height;
4290 ref_info->entry[i].ref_render_width = frame_header->render_width;
4291 ref_info->entry[i].ref_render_height = frame_header->render_height;
4292 ref_info->entry[i].ref_order_hint = frame_header->order_hint;
4293 ref_info->entry[i].ref_mi_cols = parser->state.mi_cols;
4294 ref_info->entry[i].ref_mi_rows = parser->state.mi_rows;
4295 ref_info->entry[i].ref_subsampling_x =
4296 seq_header->color_config.subsampling_x;
4297 ref_info->entry[i].ref_subsampling_y =
4298 seq_header->color_config.subsampling_y;
4299 ref_info->entry[i].ref_bit_depth = seq_header->bit_depth;
4300 ref_info->entry[i].ref_segmentation_params =
4301 frame_header->segmentation_params;
4302 ref_info->entry[i].ref_global_motion_params =
4303 frame_header->global_motion_params;
4304 ref_info->entry[i].ref_lf_params = frame_header->loop_filter_params;
4305 ref_info->entry[i].ref_tile_info = frame_header->tile_info;
4306 if (seq_header->film_grain_params_present)
4307 ref_info->entry[i].ref_film_grain_params =
4308 frame_header->film_grain_params;
4309 }
4310 }
4311
4312 return GST_AV1_PARSER_OK;
4313 }
4314
4315 /* 5.12.1 */
4316 /**
4317 * gst_av1_parser_parse_tile_list_obu:
4318 * @parser: the #GstAV1Parser
4319 * @obu: a #GstAV1OBU to be parsed
4320 * @tile_list: a #GstAV1TileListOBU to store the parsed result.
4321 *
4322 * Parse one tile list @obu based on the @parser context, store the result
4323 * in the @tile_list. It is for large scale tile coding mode.
4324 *
4325 * Returns: The #GstAV1ParserResult.
4326 *
4327 * Since: 1.18
4328 */
4329 GstAV1ParserResult
gst_av1_parser_parse_tile_list_obu(GstAV1Parser * parser,GstAV1OBU * obu,GstAV1TileListOBU * tile_list)4330 gst_av1_parser_parse_tile_list_obu (GstAV1Parser * parser,
4331 GstAV1OBU * obu, GstAV1TileListOBU * tile_list)
4332 {
4333 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
4334 GstBitReader *br;
4335 GstBitReader bitreader;
4336 gint tile;
4337
4338 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4339 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4340 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_TILE_LIST,
4341 GST_AV1_PARSER_INVALID_OPERATION);
4342 g_return_val_if_fail (tile_list != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4343
4344 br = &bitreader;
4345 memset (tile_list, 0, sizeof (*tile_list));
4346 gst_bit_reader_init (br, obu->data, obu->obu_size);
4347 if (AV1_REMAINING_BITS (br) < 8 + 8 + 16) {
4348 retval = GST_AV1_PARSER_NO_MORE_DATA;
4349 goto error;
4350 }
4351
4352 tile_list->output_frame_width_in_tiles_minus_1 = AV1_READ_BITS (br, 8);
4353 tile_list->output_frame_height_in_tiles_minus_1 = AV1_READ_BITS (br, 8);
4354 tile_list->tile_count_minus_1 = AV1_READ_BITS (br, 16);
4355 for (tile = 0; tile <= tile_list->tile_count_minus_1; tile++) {
4356 if (AV1_REMAINING_BITS (br) < 8 + 8 + 8 + 16) {
4357 retval = GST_AV1_PARSER_NO_MORE_DATA;
4358 goto error;
4359 }
4360 tile_list->entry[tile].anchor_frame_idx = AV1_READ_BITS (br, 8);
4361 tile_list->entry[tile].anchor_tile_row = AV1_READ_BITS (br, 8);
4362 tile_list->entry[tile].anchor_tile_col = AV1_READ_BITS (br, 8);
4363 tile_list->entry[tile].tile_data_size_minus_1 = AV1_READ_BITS (br, 16);
4364
4365 g_assert (gst_bit_reader_get_pos (br) % 8 == 0);
4366
4367 tile_list->entry[tile].coded_tile_data =
4368 obu->data + gst_bit_reader_get_pos (br) / 8;
4369 /* skip the coded_tile_data */
4370 if (!gst_bit_reader_skip (br,
4371 tile_list->entry[tile].tile_data_size_minus_1 + 1)) {
4372 retval = GST_AV1_PARSER_NO_MORE_DATA;
4373 goto error;
4374 }
4375 }
4376
4377 retval = av1_skip_trailing_bits (parser, br, obu);
4378 if (retval != GST_AV1_PARSER_OK)
4379 goto error;
4380
4381 return GST_AV1_PARSER_OK;
4382
4383 error:
4384 GST_WARNING ("parse tile list error %d", retval);
4385 return retval;
4386 }
4387
4388 /* 5.11.1 */
4389 static GstAV1ParserResult
gst_av1_parse_tile_group(GstAV1Parser * parser,GstBitReader * br,GstAV1TileGroupOBU * tile_group)4390 gst_av1_parse_tile_group (GstAV1Parser * parser, GstBitReader * br,
4391 GstAV1TileGroupOBU * tile_group)
4392 {
4393 GstAV1ParserResult retval = GST_AV1_PARSER_OK;
4394 gint tile_num /* TileNum */ , end_bit_pos /* endBitPos */ ;
4395 gint header_bytes /* headerBytes */ , start_bitpos /* startBitPos */ ;
4396 guint32 sz = AV1_REMAINING_BYTES (br);
4397 guint32 tile_row /* tileRow */ ;
4398 guint32 tile_col /* tileCol */ ;
4399 guint32 tile_size /* tileSize */ ;
4400
4401 memset (tile_group, 0, sizeof (*tile_group));
4402 tile_group->num_tiles = parser->state.tile_cols * parser->state.tile_rows;
4403 start_bitpos = gst_bit_reader_get_pos (br);
4404 tile_group->tile_start_and_end_present_flag = 0;
4405
4406 if (tile_group->num_tiles > 1) {
4407 tile_group->tile_start_and_end_present_flag =
4408 AV1_READ_BIT_CHECKED (br, &retval);
4409 if (retval != GST_AV1_PARSER_OK)
4410 goto error;
4411 }
4412 if (tile_group->num_tiles == 1
4413 || !tile_group->tile_start_and_end_present_flag) {
4414 tile_group->tg_start = 0;
4415 tile_group->tg_end = tile_group->num_tiles - 1;
4416 } else {
4417 gint tileBits = parser->state.tile_cols_log2 + parser->state.tile_rows_log2;
4418 tile_group->tg_start = AV1_READ_BITS_CHECKED (br, tileBits, &retval);
4419 if (retval != GST_AV1_PARSER_OK)
4420 goto error;
4421
4422 tile_group->tg_end = AV1_READ_BITS_CHECKED (br, tileBits, &retval);
4423 if (retval != GST_AV1_PARSER_OK)
4424 goto error;
4425 }
4426
4427 if (tile_group->tg_end < tile_group->tg_start) {
4428 retval = GST_AV1_PARSER_NO_MORE_DATA;
4429 goto error;
4430 }
4431
4432 if (!gst_bit_reader_skip_to_byte (br)) {
4433 retval = GST_AV1_PARSER_NO_MORE_DATA;
4434 goto error;
4435 }
4436
4437 end_bit_pos = gst_bit_reader_get_pos (br);
4438 header_bytes = (end_bit_pos - start_bitpos) / 8;
4439 sz -= header_bytes;
4440
4441 for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end;
4442 tile_num++) {
4443 tile_row = tile_num / parser->state.tile_cols;
4444 tile_col = tile_num % parser->state.tile_cols;
4445 /* if last tile */
4446 if (tile_num == tile_group->tg_end) {
4447 tile_size = sz;
4448 } else {
4449 gint tile_size_minus_1 = av1_bitstreamfn_le (br,
4450 parser->state.tile_size_bytes, &retval);
4451 if (retval != GST_AV1_PARSER_OK)
4452 goto error;
4453 tile_size = tile_size_minus_1 + 1;
4454 sz -= (tile_size + parser->state.tile_size_bytes);
4455 }
4456
4457 tile_group->entry[tile_num].tile_size = tile_size;
4458 tile_group->entry[tile_num].tile_offset = gst_bit_reader_get_pos (br) / 8;
4459 tile_group->entry[tile_num].tile_row = tile_row;
4460 tile_group->entry[tile_num].tile_col = tile_col;
4461
4462 tile_group->entry[tile_num].mi_row_start =
4463 parser->state.mi_row_starts[tile_row];
4464 tile_group->entry[tile_num].mi_row_end =
4465 parser->state.mi_row_starts[tile_row + 1];
4466 tile_group->entry[tile_num].mi_col_start =
4467 parser->state.mi_col_starts[tile_col];
4468 tile_group->entry[tile_num].mi_col_end =
4469 parser->state.mi_col_starts[tile_col + 1];
4470 /* Not implement here, the real decoder process
4471 init_symbol( tileSize )
4472 decode_tile( )
4473 exit_symbol( )
4474 */
4475
4476 /* Skip the real data to the next one */
4477 if (tile_num < tile_group->tg_end &&
4478 !gst_bit_reader_skip (br, tile_size * 8)) {
4479 retval = GST_AV1_PARSER_NO_MORE_DATA;
4480 goto error;
4481 }
4482 }
4483
4484 if (tile_group->tg_end == tile_group->num_tiles - 1) {
4485 /* Not implement here, the real decoder process
4486 if ( !disable_frame_end_update_cdf ) {
4487 frame_end_update_cdf( )
4488 }
4489 decode_frame_wrapup( )
4490 */
4491 parser->state.seen_frame_header = 0;
4492 }
4493
4494 return GST_AV1_PARSER_OK;
4495
4496 error:
4497 GST_WARNING ("parse tile group error %d", retval);
4498 return retval;
4499 }
4500
4501 /**
4502 * gst_av1_parser_parse_tile_group_obu:
4503 * @parser: the #GstAV1Parser
4504 * @obu: a #GstAV1OBU to be parsed
4505 * @tile_group: a #GstAV1TileGroupOBU to store the parsed result.
4506 *
4507 * Parse one tile group @obu based on the @parser context, store the result
4508 * in the @tile_group.
4509 *
4510 * Returns: The #GstAV1ParserResult.
4511 *
4512 * Since: 1.18
4513 */
4514 GstAV1ParserResult
gst_av1_parser_parse_tile_group_obu(GstAV1Parser * parser,GstAV1OBU * obu,GstAV1TileGroupOBU * tile_group)4515 gst_av1_parser_parse_tile_group_obu (GstAV1Parser * parser, GstAV1OBU * obu,
4516 GstAV1TileGroupOBU * tile_group)
4517 {
4518 GstAV1ParserResult ret;
4519 GstBitReader bit_reader;
4520
4521 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4522 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4523 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_TILE_GROUP,
4524 GST_AV1_PARSER_INVALID_OPERATION);
4525 g_return_val_if_fail (tile_group != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4526
4527 if (!parser->state.seen_frame_header) {
4528 GST_WARNING ("Missing OBU Reference: frame_header");
4529 return GST_AV1_PARSER_MISSING_OBU_REFERENCE;
4530 }
4531
4532 gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
4533 ret = gst_av1_parse_tile_group (parser, &bit_reader, tile_group);
4534 return ret;
4535 }
4536
4537 static GstAV1ParserResult
gst_av1_parse_frame_header(GstAV1Parser * parser,GstAV1OBU * obu,GstBitReader * bit_reader,GstAV1FrameHeaderOBU * frame_header)4538 gst_av1_parse_frame_header (GstAV1Parser * parser, GstAV1OBU * obu,
4539 GstBitReader * bit_reader, GstAV1FrameHeaderOBU * frame_header)
4540 {
4541 GstAV1ParserResult ret;
4542 guint i;
4543
4544 memset (frame_header, 0, sizeof (*frame_header));
4545 frame_header->frame_is_intra = 1;
4546 frame_header->last_frame_idx = -1;
4547 frame_header->gold_frame_idx = -1;
4548 for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
4549 frame_header->ref_frame_idx[i] = -1;
4550
4551 ret = gst_av1_parse_uncompressed_frame_header (parser, obu, bit_reader,
4552 frame_header);
4553 if (ret != GST_AV1_PARSER_OK)
4554 return ret;
4555
4556 if (frame_header->show_existing_frame) {
4557 parser->state.seen_frame_header = 0;
4558 } else {
4559 parser->state.seen_frame_header = 1;
4560 }
4561
4562 return GST_AV1_PARSER_OK;
4563 }
4564
4565 /**
4566 * gst_av1_parser_parse_frame_header_obu:
4567 * @parser: the #GstAV1Parser
4568 * @obu: a #GstAV1OBU to be parsed
4569 * @frame_header: a #GstAV1FrameHeaderOBU to store the parsed result.
4570 *
4571 * Parse one frame header @obu based on the @parser context, store the result
4572 * in the @frame.
4573 *
4574 * Returns: The #GstAV1ParserResult.
4575 *
4576 * Since: 1.18
4577 */
4578 GstAV1ParserResult
gst_av1_parser_parse_frame_header_obu(GstAV1Parser * parser,GstAV1OBU * obu,GstAV1FrameHeaderOBU * frame_header)4579 gst_av1_parser_parse_frame_header_obu (GstAV1Parser * parser,
4580 GstAV1OBU * obu, GstAV1FrameHeaderOBU * frame_header)
4581 {
4582 GstAV1ParserResult ret;
4583 GstBitReader bit_reader;
4584
4585 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4586 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4587 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_FRAME_HEADER ||
4588 obu->obu_type == GST_AV1_OBU_REDUNDANT_FRAME_HEADER,
4589 GST_AV1_PARSER_INVALID_OPERATION);
4590 g_return_val_if_fail (frame_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4591
4592 if (obu->obu_type == GST_AV1_OBU_REDUNDANT_FRAME_HEADER
4593 && !parser->state.seen_frame_header) {
4594 GST_WARNING ("no seen of frame header while get redundant frame header");
4595 return GST_AV1_PARSER_BITSTREAM_ERROR;
4596 }
4597
4598 if (obu->obu_type == GST_AV1_OBU_FRAME_HEADER
4599 && parser->state.seen_frame_header) {
4600 GST_WARNING ("already seen a frame header");
4601 return GST_AV1_PARSER_BITSTREAM_ERROR;
4602 }
4603
4604 gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
4605 ret = gst_av1_parse_frame_header (parser, obu, &bit_reader, frame_header);
4606 if (ret != GST_AV1_PARSER_OK)
4607 return ret;
4608
4609 ret = av1_skip_trailing_bits (parser, &bit_reader, obu);
4610 return ret;
4611 }
4612
4613 /**
4614 * gst_av1_parser_parse_frame_obu:
4615 * @parser: the #GstAV1Parser
4616 * @obu: a #GstAV1OBU to be parsed
4617 * @frame: a #GstAV1FrameOBU to store the parsed result.
4618 *
4619 * Parse one frame @obu based on the @parser context, store the result
4620 * in the @frame.
4621 *
4622 * Returns: The #GstAV1ParserResult.
4623 *
4624 * Since: 1.18
4625 */
4626 GstAV1ParserResult
gst_av1_parser_parse_frame_obu(GstAV1Parser * parser,GstAV1OBU * obu,GstAV1FrameOBU * frame)4627 gst_av1_parser_parse_frame_obu (GstAV1Parser * parser, GstAV1OBU * obu,
4628 GstAV1FrameOBU * frame)
4629 {
4630 GstAV1ParserResult retval;
4631 GstBitReader bit_reader;
4632
4633 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4634 g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4635 g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_FRAME,
4636 GST_AV1_PARSER_INVALID_OPERATION);
4637 g_return_val_if_fail (frame != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4638
4639 if (parser->state.seen_frame_header) {
4640 GST_WARNING ("already seen a frame header");
4641 return GST_AV1_PARSER_BITSTREAM_ERROR;
4642 }
4643
4644 gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
4645 retval = gst_av1_parse_frame_header (parser, obu, &bit_reader,
4646 &(frame->frame_header));
4647 if (retval != GST_AV1_PARSER_OK)
4648 return retval;
4649
4650 if (!gst_bit_reader_skip_to_byte (&bit_reader))
4651 return GST_AV1_PARSER_NO_MORE_DATA;
4652
4653 retval = gst_av1_parse_tile_group (parser, &bit_reader, &(frame->tile_group));
4654 return retval;
4655 }
4656
4657 /**
4658 * gst_av1_parser_set_operating_point:
4659 * @parser: the #GstAV1Parser
4660 * @operating_point: the operating point to set
4661 *
4662 * Set the operating point to filter OBUs.
4663 *
4664 * Returns: The #GstAV1ParserResult.
4665 *
4666 * Since: 1.20
4667 */
4668 GstAV1ParserResult
gst_av1_parser_set_operating_point(GstAV1Parser * parser,gint32 operating_point)4669 gst_av1_parser_set_operating_point (GstAV1Parser * parser,
4670 gint32 operating_point)
4671 {
4672 g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
4673 g_return_val_if_fail (operating_point >= 0, GST_AV1_PARSER_INVALID_OPERATION);
4674
4675 if (parser->seq_header &&
4676 operating_point > parser->seq_header->operating_points_cnt_minus_1)
4677 return GST_AV1_PARSER_INVALID_OPERATION;
4678
4679 /* Decide whether it is valid when sequence comes. */
4680 parser->state.operating_point = operating_point;
4681 return GST_AV1_PARSER_OK;
4682 }
4683
4684 /**
4685 * gst_av1_parser_new:
4686 *
4687 * Allocates a new #GstAV1Parser,
4688 *
4689 * Returns: (transfer full): a newly-allocated #GstAV1Parser
4690 *
4691 * Since: 1.18
4692 */
4693 GstAV1Parser *
gst_av1_parser_new(void)4694 gst_av1_parser_new (void)
4695 {
4696 return g_slice_new0 (GstAV1Parser);
4697 }
4698
4699 /**
4700 * gst_av1_parser_free:
4701 * @parser: the #GstAV1Parser to free
4702 *
4703 * If parser is not %NULL, frees its allocated memory.
4704 *
4705 * It cannot be used afterwards.
4706 *
4707 * Since: 1.18
4708 */
4709 void
gst_av1_parser_free(GstAV1Parser * parser)4710 gst_av1_parser_free (GstAV1Parser * parser)
4711 {
4712 g_return_if_fail (parser != NULL);
4713
4714 if (parser->seq_header)
4715 g_slice_free (GstAV1SequenceHeaderOBU, parser->seq_header);
4716 g_slice_free (GstAV1Parser, parser);
4717 }
4718