mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-01 22:21:13 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/codecparsers/gstav1parser.c
He Junyan aa5092dabf av1parse: Do not return error when expectedFrameId mismatch 
According to the SPEC:
  The frame id numbers (represented in display_frame_id, current_frame_id,
  and RefFrameId[ i ]) are not needed by the decoding process, but allow
  decoders to spot when frames have been missed and take an appropriate action.

So we should just print out warning and should not return error in parser when
mismatching. The decoder itself is already robust to handle the reference missing.

Fixes #3622

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/7052>
2024-06-18 11:04:43 +01:00

4714 lines
151 KiB
C
Raw Blame History

/* gstav1parser.c
*
* Copyright (C) 2018 Georg Ottinger
* Copyright (C) 2019-2020 Intel Corporation
* Author: Georg Ottinger <g.ottinger@gmx.at>
* Author: Junyan He <junyan.he@hotmail.com>
* Author: Victor Jaquez <vjaquez@igalia.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:gstav1parser
* @title: GstAV1Parser
* @short_description: Convenience library for parsing AV1 video bitstream.
*
* For more details about the structures, you can refer to the AV1 Bitstream &
* Decoding Process Specification V1.0.0
* [specification](https://aomediacodec.github.io/av1-spec/av1-spec.pdf)
*
* It offers you bitstream parsing of low overhead bistream format (Section 5)
* or Annex B according to the setting of the parser. By calling the function of
* gst_av1_parser_reset(), user can switch between bistream mode and Annex B mode.
*
* To retrieve OBUs and parse its headers, you should firstly call the function of
* gst_av1_parser_identify_one_obu() to get the OBU type if succeeds or just discard
* the data if fails.
*
* Then, depending on the #GstAV1OBUType of the newly parsed #GstAV1OBU,
* you should call the differents functions to parse the structure details:
*
* * #GST_AV1_OBU_SEQUENCE_HEADER: gst_av1_parser_parse_sequence_header_obu()
*
* * #GST_AV1_OBU_TEMPORAL_DELIMITER: gst_av1_parser_parse_temporal_delimiter_obu()
*
* * #GST_AV1_OBU_FRAME: gst_av1_parser_parse_frame_obu()
*
* * #GST_AV1_OBU_FRAME_HEADER: gst_av1_parser_parse_frame_header_obu()
*
* * #GST_AV1_OBU_TILE_GROUP: gst_av1_parser_parse_tile_group_obu()
*
* * #GST_AV1_OBU_METADATA: gst_av1_parser_parse_metadata_obu()
*
* * #GST_AV1_OBU_REDUNDANT_FRAME_HEADER: gst_av1_parser_parse_frame_header_obu()
*
* * #GST_AV1_OBU_TILE_LIST: gst_av1_parser_parse_tile_list_obu()
*
* Note: Some parser functions are dependent on information provided in the sequence
* header and reference frame's information. It maintains a state inside itself, which
* contains all global vars and reference information during the whole parsing process.
* Calling gst_av1_parser_reset() or a new sequence's arriving can clear and reset this
* inside state.
*
* After successfully handled a frame(for example, decode a frame successfully), you
* should call gst_av1_parser_reference_frame_update() to update the parser's inside
* state(such as reference information, global segmentation information, etc).
*
* @since: 1.18.00
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstav1parser.h"
#include <gst/base/gstbitreader.h>
#include <string.h>
#include <stdlib.h>
#ifndef GST_DISABLE_GST_DEBUG
#define GST_CAT_DEFAULT gst_av1_debug_category_get ()
static GstDebugCategory *
gst_av1_debug_category_get (void)
{
static gsize cat_gonce = 0;
if (g_once_init_enter (&cat_gonce)) {
GstDebugCategory *cat = NULL;
GST_DEBUG_CATEGORY_INIT (cat, "codecparsers_av1", 0, "av1 parse library");
g_once_init_leave (&cat_gonce, (gsize) cat);
}
return (GstDebugCategory *) cat_gonce;
}
#endif /* GST_DISABLE_GST_DEBUG */
#define AV1_READ_BIT(br) ((guint8) gst_bit_reader_get_bits_uint32_unchecked (br, 1))
#define AV1_READ_UINT8(br) ((guint8) gst_bit_reader_get_bits_uint32_unchecked (br, 8))
#define AV1_READ_UINT16(br) ((guint16) gst_bit_reader_get_bits_uint32_unchecked (br, 16))
#define AV1_READ_UINT32(br) gst_bit_reader_get_bits_uint32_unchecked (br, 32)
#define AV1_READ_UINT64(br) gst_bit_reader_get_bits_uint64_unchecked (br, 64)
#define AV1_READ_BITS(br, nbits) \
((nbits <= 32) ? (gst_bit_reader_get_bits_uint32_unchecked (br, nbits)) : \
(gst_bit_reader_get_bits_uint64_unchecked (br, nbits)))
static guint64
av1_read_bits_checked (GstBitReader * br, guint nbits,
GstAV1ParserResult * retval, const char *func_name, gint line)
{
guint64 read_bits = 0;
gboolean result;
if (nbits <= 64)
result = gst_bit_reader_get_bits_uint64 (br, &read_bits, nbits);
else
result = FALSE;
if (result == TRUE) {
*retval = GST_AV1_PARSER_OK;
return read_bits;
} else {
*retval = GST_AV1_PARSER_NO_MORE_DATA;
GST_WARNING ("Read %d bits failed in func: %s, line %d", nbits, func_name,
line);
return 0;
}
}
#define AV1_READ_BIT_CHECKED(br, ret) \
((guint8) av1_read_bits_checked (br, 1, ret, __func__, __LINE__))
#define AV1_READ_UINT8_CHECKED(br, ret) \
((guint8) av1_read_bits_checked (br, 8, ret, __func__, __LINE__))
#define AV1_READ_UINT16_CHECKED(br, ret) \
((guint16) av1_read_bits_checked (br, 16, ret, __func__, __LINE__))
#define AV1_READ_UINT32_CHECKED(br, ret) \
((guint32) av1_read_bits_checked (br, 32, ret, __func__, __LINE__))
#define AV1_READ_BITS_CHECKED(br, nbits, ret) \
av1_read_bits_checked (br, nbits, ret, __func__, __LINE__)
#define AV1_REMAINING_BYTES(br) (gst_bit_reader_get_remaining (br) / 8)
#define AV1_REMAINING_BITS(br) (gst_bit_reader_get_remaining (br))
/*************************************
* *
* Helperfunctions *
* *
*************************************/
/* 4.7
*
* floor of the base 2 logarithm of the input x */
static gint
av1_helpers_floor_log2 (guint32 x)
{
gint s = 0;
while (x != 0) {
x = x >> 1;
s++;
}
return s - 1;
}
/* 5.9.16 Tile size calculation
*
* returns the smallest value for k such that blkSize << k is greater
* than or equal to target */
static gint
av1_helper_tile_log2 (gint blkSize, gint target)
{
gint k;
for (k = 0; (blkSize << k) < target; k++);
return k;
}
/* 5.9.29 */
static gint
av1_helper_inverse_recenter (gint r, gint v)
{
if (v > 2 * r)
return v;
else if (v & 1)
return r - ((v + 1) >> 1);
else
return r + (v >> 1);
}
/* Shift down with rounding for use when n >= 0, value >= 0 */
static guint64
av1_helper_round_power_of_two (guint64 value, guint16 n)
{
return (value + (((guint64) (1) << n) >> 1)) >> n;
}
/* Shift down with rounding for signed integers, for use when n >= 0 */
static gint64
av1_helper_round_power_of_two_signed (gint64 value, guint16 n)
{
return (value < 0) ? -((gint64) (av1_helper_round_power_of_two (-value, n)))
: (gint64) av1_helper_round_power_of_two (value, n);
}
static gint
av1_helper_msb (guint n)
{
int log = 0;
guint value = n;
int i;
g_assert (n != 0);
for (i = 4; i >= 0; --i) {
const gint shift = (1 << i);
const guint x = value >> shift;
if (x != 0) {
value = x;
log += shift;
}
}
return log;
}
static const guint16 div_lut[GST_AV1_DIV_LUT_NUM + 1] = {
16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,
15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,
15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,
14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,
13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,
13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,
13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,
12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,
12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,
11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,
11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,
11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,
10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,
10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986,
9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732,
9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489,
9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259,
9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039,
9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830,
8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630,
8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439,
8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257,
8240, 8224, 8208, 8192,
};
static gint16
av1_helper_resolve_divisor_32 (guint32 D, gint16 * shift)
{
gint32 f;
gint32 e;
*shift = av1_helper_msb (D);
// e is obtained from D after resetting the most significant 1 bit.
e = D - ((guint32) 1 << *shift);
// Get the most significant DIV_LUT_BITS (8) bits of e into f
if (*shift > GST_AV1_DIV_LUT_BITS)
f = av1_helper_round_power_of_two (e, *shift - GST_AV1_DIV_LUT_BITS);
else
f = e << (GST_AV1_DIV_LUT_BITS - *shift);
g_assert (f <= GST_AV1_DIV_LUT_NUM);
*shift += GST_AV1_DIV_LUT_PREC_BITS;
// Use f as lookup into the precomputed table of multipliers
return div_lut[f];
}
/*************************************
* *
* Bitstream Functions *
* *
*************************************/
/* 4.10.5
*
* Unsigned integer represented by a variable number of little-endian
* bytes. */
static guint32
av1_bitstreamfn_leb128 (GstBitReader * br, GstAV1ParserResult * retval)
{
guint8 leb128_byte = 0;
guint64 value = 0;
gint i;
for (i = 0; i < 8; i++) {
leb128_byte = AV1_READ_UINT8_CHECKED (br, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
value |= (((gint) leb128_byte & 0x7f) << (i * 7));
if (!(leb128_byte & 0x80))
break;
}
/* check for bitstream conformance see chapter4.10.5 */
if (value < G_MAXUINT32) {
return (guint32) value;
} else {
GST_WARNING ("invalid leb128");
*retval = GST_AV1_PARSER_BITSTREAM_ERROR;
return 0;
}
}
/* 4.10.3
*
* Variable length unsigned n-bit number appearing directly in the
* bitstream */
static guint32
av1_bitstreamfn_uvlc (GstBitReader * br, GstAV1ParserResult * retval)
{
guint8 leadingZero = 0;
guint32 readv;
guint32 value;
gboolean done;
while (1) {
done = AV1_READ_BIT_CHECKED (br, retval);
if (*retval != GST_AV1_PARSER_OK) {
GST_WARNING ("invalid uvlc");
return 0;
}
if (done)
break;
leadingZero++;
}
if (leadingZero >= 32) {
value = G_MAXUINT32;
return value;
}
readv = AV1_READ_BITS_CHECKED (br, leadingZero, retval);
if (*retval != GST_AV1_PARSER_OK) {
GST_WARNING ("invalid uvlc");
return 0;
}
value = readv + (1 << leadingZero) - 1;
return value;
}
/* 4.10.6
*
* Signed integer converted from an n bits unsigned integer in the
* bitstream */
static guint32
av1_bitstreamfn_su (GstBitReader * br, guint8 n, GstAV1ParserResult * retval)
{
guint32 v, signMask;
v = AV1_READ_BITS_CHECKED (br, n, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
signMask = 1 << (n - 1);
if (v & signMask)
return v - 2 * signMask;
else
return v;
}
/* 4.10.7
*
* Unsigned encoded integer with maximum number of values n */
static guint32
av1_bitstreamfn_ns (GstBitReader * br, guint32 n, GstAV1ParserResult * retval)
{
gint w, m, v;
gint extra_bit;
w = av1_helpers_floor_log2 (n) + 1;
m = (1 << w) - n;
v = AV1_READ_BITS_CHECKED (br, w - 1, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
if (v < m)
return v;
extra_bit = AV1_READ_BITS_CHECKED (br, 1, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
return (v << 1) - m + extra_bit;
}
/* 4.10.4
*
* Unsigned little-endian n-byte number appearing directly in the
* bitstream */
static guint
av1_bitstreamfn_le (GstBitReader * br, guint8 n, GstAV1ParserResult * retval)
{
guint t = 0;
guint8 byte;
gint i;
for (i = 0; i < n; i++) {
byte = AV1_READ_BITS_CHECKED (br, 8, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
t += (byte << (i * 8));
}
return t;
}
/* 5.9.13
*
* Delta quantizer */
static gint8
av1_bitstreamfn_delta_q (GstBitReader * br, GstAV1ParserResult * retval)
{
guint8 delta_coded;
delta_coded = AV1_READ_BIT_CHECKED (br, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
if (delta_coded) {
gint delta_q = av1_bitstreamfn_su (br, 7, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
return delta_q;
} else {
return 0;
}
return 0;
}
/* 5.3.4 */
static GstAV1ParserResult
av1_bitstreamfn_trailing_bits (GstBitReader * br, guint32 nbBits)
{
guint8 trailing_one_bit, trailing_zero_bit;
g_assert (nbBits);
trailing_one_bit = AV1_READ_BIT (br);
if (trailing_one_bit != 1) {
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
nbBits--;
while (nbBits > 0) {
trailing_zero_bit = AV1_READ_BIT (br);
if (trailing_zero_bit != 0)
return GST_AV1_PARSER_BITSTREAM_ERROR;
nbBits--;
}
return GST_AV1_PARSER_OK;
}
static GstAV1ParserResult
av1_skip_trailing_bits (GstAV1Parser * parser, GstBitReader * br,
GstAV1OBU * obu)
{
guint32 payloadBits = gst_bit_reader_get_pos (br);
GstAV1ParserResult ret;
if (obu->obu_size > 0
&& obu->obu_type != GST_AV1_OBU_TILE_GROUP
&& obu->obu_type != GST_AV1_OBU_TILE_LIST
&& obu->obu_type != GST_AV1_OBU_FRAME) {
if (payloadBits >= obu->obu_size * 8)
return GST_AV1_PARSER_NO_MORE_DATA;
ret = av1_bitstreamfn_trailing_bits (br, obu->obu_size * 8 - payloadBits);
if (ret != GST_AV1_PARSER_OK)
return ret;
}
return GST_AV1_PARSER_OK;
}
static gboolean
av1_seq_level_idx_is_valid (GstAV1SeqLevels seq_level_idx)
{
return seq_level_idx == GST_AV1_SEQ_LEVEL_MAX
|| (seq_level_idx < GST_AV1_SEQ_LEVELS
/* The following levels are currently undefined. */
&& seq_level_idx != GST_AV1_SEQ_LEVEL_2_2
&& seq_level_idx != GST_AV1_SEQ_LEVEL_2_3
&& seq_level_idx != GST_AV1_SEQ_LEVEL_3_2
&& seq_level_idx != GST_AV1_SEQ_LEVEL_3_3
&& seq_level_idx != GST_AV1_SEQ_LEVEL_4_2
&& seq_level_idx != GST_AV1_SEQ_LEVEL_4_3
&& seq_level_idx != GST_AV1_SEQ_LEVEL_7_0
&& seq_level_idx != GST_AV1_SEQ_LEVEL_7_1
&& seq_level_idx != GST_AV1_SEQ_LEVEL_7_2
&& seq_level_idx != GST_AV1_SEQ_LEVEL_7_3);
}
static void
av1_parser_init_sequence_header (GstAV1SequenceHeaderOBU * seq_header)
{
memset (seq_header, 0, sizeof (*seq_header));
seq_header->bit_depth = 8;
seq_header->num_planes = 1;
}
/*************************************
* *
* Parser Functions *
* *
*************************************/
static void
gst_av1_parse_reset_state (GstAV1Parser * parser, gboolean free_sps)
{
parser->state.begin_first_frame = FALSE;
parser->state.prev_frame_id = 0;
parser->state.current_frame_id = 0;
memset (&parser->state.ref_info, 0, sizeof (parser->state.ref_info));
parser->state.frame_width = 0;
parser->state.frame_height = 0;
parser->state.upscaled_width = 0;
parser->state.mi_cols = 0;
parser->state.mi_rows = 0;
parser->state.render_width = 0;
parser->state.render_height = 0;
memset (parser->state.mi_col_starts, 0, sizeof (parser->state.mi_col_starts));
memset (parser->state.mi_row_starts, 0, sizeof (parser->state.mi_row_starts));
parser->state.tile_cols_log2 = 0;
parser->state.tile_cols = 0;
parser->state.tile_rows_log2 = 0;
parser->state.tile_rows = 0;
parser->state.tile_size_bytes = 0;
parser->state.seen_frame_header = 0;
if (free_sps) {
parser->state.sequence_changed = FALSE;
if (parser->seq_header) {
g_free (parser->seq_header);
parser->seq_header = NULL;
}
}
}
/**
* gst_av1_parser_reset:
* @parser: the #GstAV1Parser
* @annex_b: indicate whether conforms to annex b
*
* Reset the current #GstAV1Parser's state totally.
*
* Since: 1.18
*/
void
gst_av1_parser_reset (GstAV1Parser * parser, gboolean annex_b)
{
g_return_if_fail (parser != NULL);
parser->annex_b = annex_b;
if (parser->annex_b)
gst_av1_parser_reset_annex_b (parser);
gst_av1_parse_reset_state (parser, TRUE);
}
/**
* gst_av1_parser_reset_annex_b:
* @parser: the #GstAV1Parser
*
* Only reset the current #GstAV1Parser's annex b context.
* The other part of the state is kept.
*
* Since: 1.20
*/
void
gst_av1_parser_reset_annex_b (GstAV1Parser * parser)
{
g_return_if_fail (parser != NULL);
g_return_if_fail (parser->annex_b);
if (parser->temporal_unit_consumed < parser->temporal_unit_size)
GST_DEBUG ("temporal_unit_consumed: %d, temporal_unit_size:%d, "
"discard the left %d bytes for a temporal_unit.",
parser->temporal_unit_consumed, parser->temporal_unit_size,
parser->temporal_unit_size - parser->temporal_unit_consumed);
if (parser->frame_unit_consumed < parser->frame_unit_size)
GST_DEBUG (" frame_unit_consumed %d, frame_unit_size: %d "
"discard the left %d bytes for a frame_unit.",
parser->frame_unit_consumed, parser->frame_unit_size,
parser->frame_unit_size - parser->frame_unit_consumed);
parser->temporal_unit_consumed = 0;
parser->temporal_unit_size = 0;
parser->frame_unit_consumed = 0;
parser->frame_unit_size = 0;
}
/* 5.3.2 */
static GstAV1ParserResult
gst_av1_parse_obu_header (GstAV1Parser * parser, GstBitReader * br,
GstAV1OBUHeader * obu_header)
{
guint8 obu_forbidden_bit;
guint8 obu_reserved_1bit;
guint8 obu_extension_header_reserved_3bits;
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
if (AV1_REMAINING_BYTES (br) < 1) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
obu_forbidden_bit = AV1_READ_BIT (br);
if (obu_forbidden_bit != 0) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
obu_header->obu_type = AV1_READ_BITS (br, 4);
obu_header->obu_extention_flag = AV1_READ_BIT (br);
obu_header->obu_has_size_field = AV1_READ_BIT (br);
obu_reserved_1bit = AV1_READ_BIT (br);
if (obu_reserved_1bit != 0) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (obu_header->obu_extention_flag) {
if (AV1_REMAINING_BYTES (br) < 1) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
/* 5.3.3 OBU extension header */
obu_header->obu_temporal_id = AV1_READ_BITS (br, 3);
obu_header->obu_spatial_id = AV1_READ_BITS (br, 2);
obu_extension_header_reserved_3bits = AV1_READ_BITS (br, 3);
if (obu_extension_header_reserved_3bits != 0) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse OBU header error %d", ret);
return ret;
}
/**
* gst_av1_parser_identify_one_obu:
* @parser: the #GstAV1Parser
* @data: the data to parse
* @size: the size of @data
* @obu: a #GstAV1OBU to store the identified result
* @consumed: (out): the consumed data size
*
* Identify one @obu's type from the incoming data stream. This function
* should be called first to know the type of @obu before other parse APIs.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_identify_one_obu (GstAV1Parser * parser, const guint8 * data,
guint32 size, GstAV1OBU * obu, guint32 * consumed)
{
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
GstBitReader br;
guint obu_length = 0;
guint32 used;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (data != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (consumed != NULL, GST_AV1_PARSER_INVALID_OPERATION);
*consumed = 0;
memset (obu, 0, sizeof (*obu));
if (parser->annex_b) {
GST_LOG ("temporal_unit_consumed: %d, temporal_unit_size:%d,"
" frame_unit_consumed %d, frame_unit_size: %d",
parser->temporal_unit_consumed, parser->temporal_unit_size,
parser->frame_unit_consumed, parser->frame_unit_size);
}
if (!size) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
/* parse the data size if annex_b */
if (parser->annex_b) {
guint last_pos;
annex_b_again:
last_pos = 0;
if (*consumed > size)
goto error;
if (*consumed == size) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
gst_bit_reader_init (&br, data + *consumed, size - *consumed);
if (parser->temporal_unit_consumed > parser->temporal_unit_size)
goto error;
if (parser->temporal_unit_consumed &&
parser->temporal_unit_consumed == parser->temporal_unit_size) {
GST_LOG ("Complete a temporal unit of size %d",
parser->temporal_unit_size);
parser->temporal_unit_consumed = parser->temporal_unit_size = 0;
}
if (parser->temporal_unit_size == 0) {
parser->temporal_unit_size = av1_bitstreamfn_leb128 (&br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
g_assert (gst_bit_reader_get_pos (&br) % 8 == 0);
used = (gst_bit_reader_get_pos (&br) / 8 - last_pos);
last_pos = gst_bit_reader_get_pos (&br) / 8;
*consumed += used;
if (parser->temporal_unit_consumed == parser->temporal_unit_size) {
/* Some extreme case like a temporal unit just
hold a temporal_unit_size = 0 */
goto annex_b_again;
}
}
if (parser->frame_unit_consumed > parser->frame_unit_size)
goto error;
if (parser->frame_unit_consumed &&
parser->frame_unit_consumed == parser->frame_unit_size) {
GST_LOG ("Complete a frame unit of size %d", parser->frame_unit_size);
parser->frame_unit_size = parser->frame_unit_consumed = 0;
}
if (parser->frame_unit_size == 0) {
parser->frame_unit_size = av1_bitstreamfn_leb128 (&br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
g_assert (gst_bit_reader_get_pos (&br) % 8 == 0);
used = gst_bit_reader_get_pos (&br) / 8 - last_pos;
last_pos = gst_bit_reader_get_pos (&br) / 8;
*consumed += used;
parser->temporal_unit_consumed += used;
if (parser->frame_unit_size >
parser->temporal_unit_size - parser->temporal_unit_consumed) {
GST_INFO ("Error stream, frame unit size %d, bigger than the left"
"temporal unit size %d", parser->frame_unit_size,
parser->temporal_unit_size - parser->temporal_unit_consumed);
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (parser->temporal_unit_consumed == parser->temporal_unit_size ||
parser->frame_unit_consumed == parser->frame_unit_size) {
/* Some extreme case like a temporal unit just hold a frame_unit_size,
or a frame unit just hold frame_unit_size = 0 */
goto annex_b_again;
}
}
obu_length = av1_bitstreamfn_leb128 (&br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (obu_length > parser->frame_unit_size - parser->frame_unit_consumed) {
GST_INFO ("Error stream, obu_length is %d, bigger than the left"
"frame unit size %d", obu_length,
parser->frame_unit_size - parser->frame_unit_consumed);
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
/* update the consumed */
used = gst_bit_reader_get_pos (&br) / 8 - last_pos;
last_pos = gst_bit_reader_get_pos (&br) / 8;
*consumed += used;
parser->temporal_unit_consumed += used;
parser->frame_unit_consumed += used;
if (obu_length == 0) {
/* An empty obu? let continue to the next */
return GST_AV1_PARSER_DROP;
}
}
if (*consumed > size)
goto error;
if (*consumed == size) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
gst_bit_reader_init (&br, data + *consumed, size - *consumed);
ret = gst_av1_parse_obu_header (parser, &br, &obu->header);
if (ret != GST_AV1_PARSER_OK)
goto error;
obu->obu_type = obu->header.obu_type;
GST_LOG ("identify obu type is %d", obu->obu_type);
if (obu->header.obu_has_size_field) {
guint size_sz = gst_bit_reader_get_pos (&br) / 8;
obu->obu_size = av1_bitstreamfn_leb128 (&br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
size_sz = gst_bit_reader_get_pos (&br) / 8 - size_sz;
if (obu_length
&& obu_length - 1 - obu->header.obu_extention_flag - size_sz !=
obu->obu_size) {
/* If obu_size and obu_length are both present, but inconsistent,
then the packed bitstream is deemed invalid. */
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (AV1_REMAINING_BYTES (&br) < obu->obu_size) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
} else {
if (obu_length == 0) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
obu->obu_size = obu_length - 1 - obu->header.obu_extention_flag;
}
g_assert (gst_bit_reader_get_pos (&br) % 8 == 0);
used = gst_bit_reader_get_pos (&br) / 8;
/* fail if not a complete obu */
if (size - *consumed - used < obu->obu_size) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
/* update the consumed */
*consumed += used;
if (parser->annex_b) {
parser->temporal_unit_consumed += used;
parser->frame_unit_consumed += used;
}
obu->data = (guint8 *) (data + *consumed);
*consumed += obu->obu_size;
if (parser->annex_b) {
parser->temporal_unit_consumed += obu->obu_size;
parser->frame_unit_consumed += obu->obu_size;
}
if (obu->obu_type != GST_AV1_OBU_SEQUENCE_HEADER
&& obu->obu_type != GST_AV1_OBU_TEMPORAL_DELIMITER
&& parser->state.operating_point_idc && obu->header.obu_extention_flag) {
guint32 inTemporalLayer =
(parser->state.operating_point_idc >> obu->header.obu_temporal_id) & 1;
guint32 inSpatialLayer =
(parser->state.operating_point_idc >> (obu->header.obu_spatial_id +
8)) & 1;
if (!inTemporalLayer || !inSpatialLayer) {
return GST_AV1_PARSER_DROP;
}
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("can not identify obu, error %d", ret);
return ret;
}
/* 5.5.2 */
static GstAV1ParserResult
gst_av1_parse_color_config (GstAV1Parser * parser, GstBitReader * br,
GstAV1SequenceHeaderOBU * seq_header, GstAV1ColorConfig * color_config)
{
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
color_config->high_bitdepth = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (seq_header->seq_profile == GST_AV1_PROFILE_2
&& color_config->high_bitdepth) {
color_config->twelve_bit = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
seq_header->bit_depth = color_config->twelve_bit ? 12 : 10;
} else if (seq_header->seq_profile <= GST_AV1_PROFILE_2) {
seq_header->bit_depth = color_config->high_bitdepth ? 10 : 8;
} else {
GST_INFO ("Unsupported profile/bit-depth combination");
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (seq_header->seq_profile == GST_AV1_PROFILE_1)
color_config->mono_chrome = 0;
else {
color_config->mono_chrome = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
seq_header->num_planes = color_config->mono_chrome ? 1 : 3;
color_config->color_description_present_flag =
AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (color_config->color_description_present_flag) {
if (AV1_REMAINING_BITS (br) < 8 + 8 + 8) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
color_config->color_primaries = AV1_READ_BITS (br, 8);
color_config->transfer_characteristics = AV1_READ_BITS (br, 8);
color_config->matrix_coefficients = AV1_READ_BITS (br, 8);
} else {
color_config->color_primaries = GST_AV1_CP_UNSPECIFIED;
color_config->transfer_characteristics = GST_AV1_TC_UNSPECIFIED;
color_config->matrix_coefficients = GST_AV1_MC_UNSPECIFIED;
}
if (color_config->mono_chrome) {
color_config->color_range = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
color_config->subsampling_x = 1;
color_config->subsampling_y = 1;
color_config->chroma_sample_position = GST_AV1_CSP_UNKNOWN;
color_config->separate_uv_delta_q = 0;
goto success;
} else if (color_config->color_primaries == GST_AV1_CP_BT_709 &&
color_config->transfer_characteristics == GST_AV1_TC_SRGB &&
color_config->matrix_coefficients == GST_AV1_MC_IDENTITY) {
color_config->color_range = 1;
color_config->subsampling_x = 0;
color_config->subsampling_y = 0;
if (!(seq_header->seq_profile == GST_AV1_PROFILE_1 ||
(seq_header->seq_profile == GST_AV1_PROFILE_2
&& seq_header->bit_depth == 12))) {
GST_INFO ("sRGB colorspace not compatible with specified profile");
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
} else {
color_config->color_range = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (seq_header->seq_profile == GST_AV1_PROFILE_0) {
/* 420 only */
color_config->subsampling_x = 1;
color_config->subsampling_y = 1;
} else if (seq_header->seq_profile == GST_AV1_PROFILE_1) {
/* 444 only */
color_config->subsampling_x = 0;
color_config->subsampling_y = 0;
} else {
g_assert (seq_header->seq_profile == GST_AV1_PROFILE_2);
if (seq_header->bit_depth == 12) {
color_config->subsampling_x = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (color_config->subsampling_x) {
/* 422 or 420 */
color_config->subsampling_y = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
} else
/* 444 */
color_config->subsampling_y = 0;
} else {
/* 422 */
color_config->subsampling_x = 1;
color_config->subsampling_y = 0;
}
}
if (color_config->matrix_coefficients == GST_AV1_MC_IDENTITY &&
(color_config->subsampling_x || color_config->subsampling_y)) {
GST_INFO ("Identity CICP Matrix incompatible with"
" non 4:4:4 color sampling");
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (color_config->subsampling_x && color_config->subsampling_y) {
color_config->chroma_sample_position =
AV1_READ_BITS_CHECKED (br, 2, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
}
color_config->separate_uv_delta_q = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (!(color_config->subsampling_x == 0 && color_config->subsampling_y == 0) &&
!(color_config->subsampling_x == 1 && color_config->subsampling_y == 1) &&
!(color_config->subsampling_x == 1 && color_config->subsampling_y == 0)) {
GST_INFO ("Only 4:4:4, 4:2:2 and 4:2:0 are currently supported, "
"%d %d subsampling is not supported.\n",
color_config->subsampling_x, color_config->subsampling_y);
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse color config error %d", ret);
return ret;
}
/* 5.5.3 */
static GstAV1ParserResult
gst_av1_parse_timing_info (GstAV1Parser * parser, GstBitReader * br,
GstAV1TimingInfo * timing_info)
{
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
if (AV1_REMAINING_BITS (br) < 32 + 32 + 1) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
timing_info->num_units_in_display_tick = AV1_READ_UINT32 (br);
timing_info->time_scale = AV1_READ_UINT32 (br);
if (timing_info->num_units_in_display_tick == 0 ||
timing_info->time_scale == 0) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
timing_info->equal_picture_interval = AV1_READ_BIT (br);
if (timing_info->equal_picture_interval) {
timing_info->num_ticks_per_picture_minus_1 =
av1_bitstreamfn_uvlc (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (timing_info->num_ticks_per_picture_minus_1 == G_MAXUINT) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse timing info error %d", ret);
return ret;
}
/* 5.5.4 */
static GstAV1ParserResult
gst_av1_parse_decoder_model_info (GstAV1Parser * parser, GstBitReader * br,
GstAV1DecoderModelInfo * decoder_model_info)
{
if (AV1_REMAINING_BITS (br) < 5 + 32 + 5 + 5)
return GST_AV1_PARSER_NO_MORE_DATA;
decoder_model_info->buffer_delay_length_minus_1 = AV1_READ_BITS (br, 5);
decoder_model_info->num_units_in_decoding_tick = AV1_READ_BITS (br, 32);
decoder_model_info->buffer_removal_time_length_minus_1 =
AV1_READ_BITS (br, 5);
decoder_model_info->frame_presentation_time_length_minus_1 =
AV1_READ_BITS (br, 5);
return GST_AV1_PARSER_OK;
}
/* 5.5.5 */
static GstAV1ParserResult
gst_av1_parse_operating_parameters_info (GstAV1Parser * parser,
GstBitReader * br, GstAV1SequenceHeaderOBU * seq_header,
GstAV1OperatingPoint * op_point)
{
guint32 n = seq_header->decoder_model_info.buffer_delay_length_minus_1 + 1;
if (AV1_REMAINING_BITS (br) < n + n + 1)
return GST_AV1_PARSER_NO_MORE_DATA;
op_point->decoder_buffer_delay = AV1_READ_BITS (br, n);
op_point->encoder_buffer_delay = AV1_READ_BITS (br, n);
op_point->low_delay_mode_flag = AV1_READ_BIT (br);
return GST_AV1_PARSER_OK;
}
/* 5.5.1 General sequence header OBU */
/**
* gst_av1_parser_parse_sequence_header_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
* @seq_header: a #GstAV1SequenceHeaderOBU to store the parsed result.
*
* Parse one sequence header @obu based on the @parser context, store the
* result in the @seq_header.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_sequence_header_obu (GstAV1Parser * parser,
GstAV1OBU * obu, GstAV1SequenceHeaderOBU * seq_header)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
gint i;
GstBitReader bit_reader;
GstBitReader *br = &bit_reader;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_SEQUENCE_HEADER,
GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (seq_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
av1_parser_init_sequence_header (seq_header);
gst_bit_reader_init (br, obu->data, obu->obu_size);
if (AV1_REMAINING_BITS (br) < 8) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->seq_profile = AV1_READ_BITS (br, 3);
if (seq_header->seq_profile > GST_AV1_PROFILE_2) {
GST_INFO ("Unsupported profile %d", seq_header->seq_profile);
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
seq_header->still_picture = AV1_READ_BIT (br);
seq_header->reduced_still_picture_header = AV1_READ_BIT (br);
if (!seq_header->still_picture && seq_header->reduced_still_picture_header) {
GST_INFO (" If reduced_still_picture_header is equal to 1, it is a"
" requirement of bitstream conformance that still_picture is equal"
" to 1. ");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (seq_header->reduced_still_picture_header) {
seq_header->timing_info_present_flag = 0;
seq_header->decoder_model_info_present_flag = 0;
seq_header->initial_display_delay_present_flag = 0;
seq_header->operating_points_cnt_minus_1 = 0;
seq_header->operating_points[0].idc = 0;
seq_header->operating_points[0].seq_level_idx = AV1_READ_BITS (br, 5);
if (!av1_seq_level_idx_is_valid
(seq_header->operating_points[0].seq_level_idx)) {
GST_INFO ("The seq_level_idx is unsupported");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
seq_header->operating_points[0].seq_tier = 0;
seq_header->operating_points[0].decoder_model_present_for_this_op = 0;
seq_header->operating_points[0].initial_display_delay_present_for_this_op =
0;
} else {
seq_header->timing_info_present_flag = AV1_READ_BIT (br);
if (seq_header->timing_info_present_flag) {
retval =
gst_av1_parse_timing_info (parser, br, &(seq_header->timing_info));
if (retval != GST_AV1_PARSER_OK)
goto error;
seq_header->decoder_model_info_present_flag =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->decoder_model_info_present_flag) {
retval = gst_av1_parse_decoder_model_info (parser, br,
&(seq_header->decoder_model_info));
if (retval != GST_AV1_PARSER_OK)
goto error;
}
} else {
seq_header->decoder_model_info_present_flag = 0;
}
if (AV1_REMAINING_BITS (br) < 6) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->initial_display_delay_present_flag = AV1_READ_BIT (br);
seq_header->operating_points_cnt_minus_1 = AV1_READ_BITS (br, 5);
if (seq_header->operating_points_cnt_minus_1 + 1 >
GST_AV1_MAX_OPERATING_POINTS) {
GST_INFO ("The operating points number %d is too big",
seq_header->operating_points_cnt_minus_1 + 1);
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
for (i = 0; i < seq_header->operating_points_cnt_minus_1 + 1; i++) {
if (AV1_REMAINING_BITS (br) < 17) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->operating_points[i].idc = AV1_READ_BITS (br, 12);
seq_header->operating_points[i].seq_level_idx = AV1_READ_BITS (br, 5);
if (!av1_seq_level_idx_is_valid
(seq_header->operating_points[i].seq_level_idx)) {
GST_INFO ("The seq_level_idx is unsupported");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (seq_header->operating_points[i].seq_level_idx > GST_AV1_SEQ_LEVEL_3_3) {
seq_header->operating_points[i].seq_tier = AV1_READ_BIT (br);
} else {
seq_header->operating_points[i].seq_tier = 0;
}
if (seq_header->decoder_model_info_present_flag) {
seq_header->operating_points[i].decoder_model_present_for_this_op =
AV1_READ_BIT (br);
if (seq_header->operating_points[i].decoder_model_present_for_this_op)
retval =
gst_av1_parse_operating_parameters_info (parser, br, seq_header,
&(seq_header->operating_points[i]));
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
seq_header->operating_points[i].decoder_model_present_for_this_op = 0;
}
if (seq_header->initial_display_delay_present_flag) {
seq_header->
operating_points[i].initial_display_delay_present_for_this_op =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->
operating_points[i].initial_display_delay_present_for_this_op) {
seq_header->operating_points[i].initial_display_delay_minus_1 =
AV1_READ_BITS_CHECKED (br, 4, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->operating_points[i].initial_display_delay_minus_1 +
1 > 10) {
GST_INFO ("AV1 does not support more than 10 decoded frames delay");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
} else {
seq_header->operating_points[i].initial_display_delay_minus_1 = 9;
}
} else {
seq_header->
operating_points[i].initial_display_delay_present_for_this_op = 0;
seq_header->operating_points[i].initial_display_delay_minus_1 = 9;
}
}
}
/* Let user decide the operatingPoint,
implemented by calling gst_av1_parser_set_operating_point()
operatingPoint = choose_operating_point( )
operating_point_idc = operating_point_idc[ operatingPoint ] */
if (AV1_REMAINING_BITS (br) < 4 + 4 +
(seq_header->frame_width_bits_minus_1 + 1) +
(seq_header->frame_height_bits_minus_1 + 1)) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->frame_width_bits_minus_1 = AV1_READ_BITS (br, 4);
seq_header->frame_height_bits_minus_1 = AV1_READ_BITS (br, 4);
seq_header->max_frame_width_minus_1 =
AV1_READ_BITS (br, seq_header->frame_width_bits_minus_1 + 1);
seq_header->max_frame_height_minus_1 =
AV1_READ_BITS (br, seq_header->frame_height_bits_minus_1 + 1);
if (seq_header->reduced_still_picture_header)
seq_header->frame_id_numbers_present_flag = 0;
else {
seq_header->frame_id_numbers_present_flag =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (seq_header->frame_id_numbers_present_flag) {
if (AV1_REMAINING_BITS (br) < 4 + 3) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->delta_frame_id_length_minus_2 = AV1_READ_BITS (br, 4);
seq_header->additional_frame_id_length_minus_1 = AV1_READ_BITS (br, 3);
if (seq_header->additional_frame_id_length_minus_1 + 1 +
seq_header->delta_frame_id_length_minus_2 + 2 > 16) {
GST_INFO ("Invalid frame_id_length");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
if (AV1_REMAINING_BITS (br) < 3) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->use_128x128_superblock = AV1_READ_BIT (br);
seq_header->enable_filter_intra = AV1_READ_BIT (br);
seq_header->enable_intra_edge_filter = AV1_READ_BIT (br);
if (seq_header->reduced_still_picture_header) {
seq_header->enable_interintra_compound = 0;
seq_header->enable_masked_compound = 0;
seq_header->enable_warped_motion = 0;
seq_header->enable_dual_filter = 0;
seq_header->enable_order_hint = 0;
seq_header->enable_jnt_comp = 0;
seq_header->enable_ref_frame_mvs = 0;
seq_header->seq_force_screen_content_tools =
GST_AV1_SELECT_SCREEN_CONTENT_TOOLS;
seq_header->seq_force_integer_mv = GST_AV1_SELECT_INTEGER_MV;
seq_header->order_hint_bits_minus_1 = -1;
seq_header->order_hint_bits = 0;
} else {
if (AV1_REMAINING_BITS (br) < 5) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->enable_interintra_compound = AV1_READ_BIT (br);
seq_header->enable_masked_compound = AV1_READ_BIT (br);
seq_header->enable_warped_motion = AV1_READ_BIT (br);
seq_header->enable_dual_filter = AV1_READ_BIT (br);
seq_header->enable_order_hint = AV1_READ_BIT (br);
if (seq_header->enable_order_hint) {
if (AV1_REMAINING_BITS (br) < 2) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->enable_jnt_comp = AV1_READ_BIT (br);
seq_header->enable_ref_frame_mvs = AV1_READ_BIT (br);
} else {
seq_header->enable_jnt_comp = 0;
seq_header->enable_ref_frame_mvs = 0;
}
seq_header->seq_choose_screen_content_tools =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->seq_choose_screen_content_tools)
seq_header->seq_force_screen_content_tools =
GST_AV1_SELECT_SCREEN_CONTENT_TOOLS;
else {
seq_header->seq_force_screen_content_tools =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (seq_header->seq_force_screen_content_tools > 0) {
seq_header->seq_choose_integer_mv = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->seq_choose_integer_mv)
seq_header->seq_force_integer_mv = GST_AV1_SELECT_INTEGER_MV;
else {
seq_header->seq_force_integer_mv = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
} else {
seq_header->seq_force_integer_mv = GST_AV1_SELECT_INTEGER_MV;
}
if (seq_header->enable_order_hint) {
seq_header->order_hint_bits_minus_1 =
AV1_READ_BITS_CHECKED (br, 3, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
seq_header->order_hint_bits = seq_header->order_hint_bits_minus_1 + 1;
} else {
seq_header->order_hint_bits_minus_1 = -1;
seq_header->order_hint_bits = 0;
}
}
if (AV1_REMAINING_BITS (br) < 3) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
seq_header->enable_superres = AV1_READ_BIT (br);
seq_header->enable_cdef = AV1_READ_BIT (br);
seq_header->enable_restoration = AV1_READ_BIT (br);
retval = gst_av1_parse_color_config (parser, br, seq_header,
&seq_header->color_config);
if (retval != GST_AV1_PARSER_OK)
goto error;
seq_header->film_grain_params_present = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = av1_skip_trailing_bits (parser, br, obu);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (parser->seq_header) {
if (!memcmp (parser->seq_header, seq_header,
sizeof (GstAV1SequenceHeaderOBU)))
goto success;
g_free (parser->seq_header);
}
parser->seq_header = g_memdup2 (seq_header, sizeof (GstAV1SequenceHeaderOBU));
gst_av1_parse_reset_state (parser, FALSE);
/* choose_operating_point() set the operating_point */
if (parser->state.operating_point > seq_header->operating_points_cnt_minus_1) {
GST_WARNING ("Invalid operating_point %d set by user, just use 0",
parser->state.operating_point);
parser->state.operating_point_idc = seq_header->operating_points[0].idc;
} else {
parser->state.operating_point_idc =
seq_header->operating_points[parser->state.operating_point].idc;
}
parser->state.sequence_changed = TRUE;
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse sequence header error %d", retval);
return retval;
}
/* 5.6 */
/**
* gst_av1_parser_parse_temporal_delimiter_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
*
* Parse one temporal delimiter @obu based on the @parser context.
* The temporal delimiter is just delimiter and contains no content.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_temporal_delimiter_obu (GstAV1Parser * parser,
GstAV1OBU * obu)
{
GstBitReader bit_reader;
GstAV1ParserResult ret;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_TEMPORAL_DELIMITER,
GST_AV1_PARSER_INVALID_OPERATION);
gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
parser->state.seen_frame_header = 0;
ret = av1_skip_trailing_bits (parser, &bit_reader, obu);
if (ret != GST_AV1_PARSER_OK)
GST_WARNING ("parse temporal delimiter error %d", ret);
return ret;
}
/* 5.8.2 */
static GstAV1ParserResult
gst_av1_parse_metadata_itut_t35 (GstAV1Parser * parser, GstBitReader * br,
GstAV1MetadataITUT_T35 * itut_t35)
{
GstAV1ParserResult ret;
itut_t35->itu_t_t35_country_code = AV1_READ_BITS_CHECKED (br, 8, &ret);
if (ret != GST_AV1_PARSER_OK)
return ret;
if (itut_t35->itu_t_t35_country_code == 0xFF) {
itut_t35->itu_t_t35_country_code_extention_byte =
AV1_READ_BITS_CHECKED (br, 8, &ret);
if (ret != GST_AV1_PARSER_OK)
return ret;
}
/* itu_t_t35_payload_bytes is not defined in specification.
Just skip this part. */
return GST_AV1_PARSER_OK;
}
/* 5.8.3 */
static GstAV1ParserResult
gst_av1_parse_metadata_hdr_cll (GstAV1Parser * parser, GstBitReader * br,
GstAV1MetadataHdrCll * hdr_cll)
{
if (AV1_REMAINING_BITS (br) < 32)
return GST_AV1_PARSER_NO_MORE_DATA;
hdr_cll->max_cll = AV1_READ_UINT16 (br);
hdr_cll->max_fall = AV1_READ_UINT16 (br);
return GST_AV1_PARSER_OK;
}
/* 5.8.4 */
static GstAV1ParserResult
gst_av1_parse_metadata_hdr_mdcv (GstAV1Parser * parser, GstBitReader * br,
GstAV1MetadataHdrMdcv * hdr_mdcv)
{
gint i;
if (AV1_REMAINING_BITS (br) < 3 * (16 + 16) + 16 + 16 + 32 + 32)
return GST_AV1_PARSER_NO_MORE_DATA;
for (i = 0; i < 3; i++) {
hdr_mdcv->primary_chromaticity_x[i] = AV1_READ_UINT16 (br);
hdr_mdcv->primary_chromaticity_y[i] = AV1_READ_UINT16 (br);
}
hdr_mdcv->white_point_chromaticity_x = AV1_READ_UINT16 (br);
hdr_mdcv->white_point_chromaticity_y = AV1_READ_UINT16 (br);
hdr_mdcv->luminance_max = AV1_READ_UINT32 (br);
hdr_mdcv->luminance_min = AV1_READ_UINT32 (br);
return GST_AV1_PARSER_OK;
}
/* 5.8.5 */
static GstAV1ParserResult
gst_av1_parse_metadata_scalability (GstAV1Parser * parser,
GstBitReader * br, GstAV1MetadataScalability * scalability)
{
gint i, j;
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
guint8 scalability_structure_reserved_3bits;
scalability->scalability_mode_idc = AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (scalability->scalability_mode_idc != GST_AV1_SCALABILITY_SS)
goto success;
if (AV1_REMAINING_BITS (br) < 8) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
/* 5.8.6 */
scalability->spatial_layers_cnt_minus_1 = AV1_READ_BITS (br, 2);
scalability->spatial_layer_dimensions_present_flag = AV1_READ_BIT (br);
scalability->spatial_layer_description_present_flag = AV1_READ_BIT (br);
scalability->temporal_group_description_present_flag = AV1_READ_BIT (br);
scalability_structure_reserved_3bits = AV1_READ_BITS (br, 3);
/* scalability_structure_reserved_3bits: must be set to zero and
be ignored by decoders. */
if (scalability_structure_reserved_3bits) {
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (scalability->spatial_layer_dimensions_present_flag) {
for (i = 0; i <= scalability->spatial_layers_cnt_minus_1; i++) {
if (AV1_REMAINING_BITS (br) < 16 * 2) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
scalability->spatial_layer_max_width[i] = AV1_READ_UINT16 (br);
scalability->spatial_layer_max_height[i] = AV1_READ_UINT16 (br);
}
}
if (scalability->spatial_layer_description_present_flag) {
for (i = 0; i <= scalability->spatial_layers_cnt_minus_1; i++) {
scalability->spatial_layer_ref_id[i] = AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
}
if (scalability->temporal_group_description_present_flag) {
scalability->temporal_group_size = AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
for (i = 0; i < scalability->temporal_group_size; i++) {
if (AV1_REMAINING_BITS (br) < 8) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
scalability->temporal_group_temporal_id[i] = AV1_READ_BITS (br, 3);
scalability->temporal_group_temporal_switching_up_point_flag[i] =
AV1_READ_BIT (br);
scalability->temporal_group_spatial_switching_up_point_flag[i] =
AV1_READ_BIT (br);
scalability->temporal_group_ref_cnt[i] = AV1_READ_BITS (br, 3);
for (j = 0; j < scalability->temporal_group_ref_cnt[i]; j++) {
scalability->temporal_group_ref_pic_diff[i][j] =
AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
}
}
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse metadata scalability error %d", ret);
return ret;
}
/* 5.8.7 */
static GstAV1ParserResult
gst_av1_parse_metadata_timecode (GstAV1Parser * parser, GstBitReader * br,
GstAV1MetadataTimecode * timecode)
{
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
if (AV1_REMAINING_BITS (br) < 17) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
timecode->counting_type = AV1_READ_BITS (br, 5);
timecode->full_timestamp_flag = AV1_READ_BIT (br);
timecode->discontinuity_flag = AV1_READ_BIT (br);
timecode->cnt_dropped_flag = AV1_READ_BIT (br);
timecode->n_frames = AV1_READ_BITS (br, 9);
if (timecode->full_timestamp_flag) {
if (AV1_REMAINING_BITS (br) < 17) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
timecode->seconds_value = AV1_READ_BITS (br, 6);
timecode->minutes_value = AV1_READ_BITS (br, 6);
timecode->hours_value = AV1_READ_BITS (br, 5);
} else {
timecode->seconds_flag = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (timecode->seconds_flag) {
if (AV1_REMAINING_BITS (br) < 7) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
timecode->seconds_value = AV1_READ_BITS (br, 6);
timecode->minutes_flag = AV1_READ_BIT (br);
if (timecode->minutes_flag) {
if (AV1_REMAINING_BITS (br) < 7) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
timecode->minutes_value = AV1_READ_BITS (br, 6);
timecode->hours_flag = AV1_READ_BIT (br);
if (timecode->hours_flag) {
timecode->hours_value = AV1_READ_BITS_CHECKED (br, 6, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
}
}
}
timecode->time_offset_length = AV1_READ_BITS_CHECKED (br, 5, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (timecode->time_offset_length > 0) {
timecode->time_offset_value =
AV1_READ_BITS_CHECKED (br, timecode->time_offset_length, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse metadata timecode error %d", ret);
return ret;
}
/* 5.8.1 */
/**
* gst_av1_parser_parse_metadata_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
* @metadata: a #GstAV1MetadataOBU to store the parsed result.
*
* Parse one meta data @obu based on the @parser context.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_metadata_obu (GstAV1Parser * parser, GstAV1OBU * obu,
GstAV1MetadataOBU * metadata)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
GstBitReader bit_reader;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_METADATA,
GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (metadata != NULL, GST_AV1_PARSER_INVALID_OPERATION);
gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
memset (metadata, 0, sizeof (*metadata));
metadata->metadata_type = av1_bitstreamfn_leb128 (&bit_reader, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
switch (metadata->metadata_type) {
case GST_AV1_METADATA_TYPE_ITUT_T35:
retval = gst_av1_parse_metadata_itut_t35 (parser,
&bit_reader, &(metadata->itut_t35));
break;
case GST_AV1_METADATA_TYPE_HDR_CLL:
retval = gst_av1_parse_metadata_hdr_cll (parser,
&bit_reader, &(metadata->hdr_cll));
break;
case GST_AV1_METADATA_TYPE_HDR_MDCV:
retval = gst_av1_parse_metadata_hdr_mdcv (parser,
&bit_reader, &(metadata->hdr_mdcv));
break;
case GST_AV1_METADATA_TYPE_SCALABILITY:
retval = gst_av1_parse_metadata_scalability (parser,
&bit_reader, &(metadata->scalability));
break;
case GST_AV1_METADATA_TYPE_TIMECODE:
retval = gst_av1_parse_metadata_timecode (parser,
&bit_reader, &(metadata->timecode));
break;
default:
GST_WARNING ("Unknown metadata type %u", metadata->metadata_type);
return GST_AV1_PARSER_OK;
}
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = av1_skip_trailing_bits (parser, &bit_reader, obu);
if (retval != GST_AV1_PARSER_OK) {
GST_WARNING ("Metadata type %d may have wrong trailings.",
metadata->metadata_type);
retval = GST_AV1_PARSER_OK;
}
return retval;
error:
GST_WARNING ("parse metadata error %d", retval);
return retval;
}
/* 5.9.8 */
static GstAV1ParserResult
gst_av1_parse_superres_params_compute_image_size (GstAV1Parser * parser,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult ret;
GstAV1SequenceHeaderOBU *seq_header;
g_assert (parser->seq_header);
seq_header = parser->seq_header;
if (seq_header->enable_superres) {
frame_header->use_superres = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
return ret;
} else {
frame_header->use_superres = 0;
}
if (frame_header->use_superres) {
guint8 coded_denom;
coded_denom = AV1_READ_BITS_CHECKED (br, GST_AV1_SUPERRES_DENOM_BITS, &ret);
if (ret != GST_AV1_PARSER_OK)
return ret;
frame_header->superres_denom = coded_denom + GST_AV1_SUPERRES_DENOM_MIN;
} else {
frame_header->superres_denom = GST_AV1_SUPERRES_NUM;
}
parser->state.upscaled_width = parser->state.frame_width;
parser->state.frame_width =
(parser->state.upscaled_width * GST_AV1_SUPERRES_NUM +
(frame_header->superres_denom / 2)) / frame_header->superres_denom;
/* 5.9.9 compute_image_size */
parser->state.mi_cols = 2 * ((parser->state.frame_width + 7) >> 3);
parser->state.mi_rows = 2 * ((parser->state.frame_height + 7) >> 3);
return GST_AV1_PARSER_OK;
}
/* 5.9.5 */
static GstAV1ParserResult
gst_av1_parse_frame_size (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval;
GstAV1SequenceHeaderOBU *seq_header;
g_assert (parser->seq_header);
seq_header = parser->seq_header;
if (frame_header->frame_size_override_flag) {
guint16 frame_width_minus_1;
guint16 frame_height_minus_1;
if (AV1_REMAINING_BITS (br) <
seq_header->frame_width_bits_minus_1 + 1 +
seq_header->frame_height_bits_minus_1 + 1)
return GST_AV1_PARSER_NO_MORE_DATA;
frame_width_minus_1 =
AV1_READ_BITS (br, seq_header->frame_width_bits_minus_1 + 1);
frame_height_minus_1 =
AV1_READ_BITS (br, seq_header->frame_height_bits_minus_1 + 1);
parser->state.frame_width = frame_width_minus_1 + 1;
parser->state.frame_height = frame_height_minus_1 + 1;
} else {
parser->state.frame_width = seq_header->max_frame_width_minus_1 + 1;
parser->state.frame_height = seq_header->max_frame_height_minus_1 + 1;
}
retval = gst_av1_parse_superres_params_compute_image_size (parser, br,
frame_header);
return retval;
}
/* 5.9.6 */
static GstAV1ParserResult
gst_av1_parse_render_size (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval;
frame_header->render_and_frame_size_different =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
if (frame_header->render_and_frame_size_different) {
guint16 render_width_minus_1;
guint16 render_height_minus_1;
if (AV1_REMAINING_BITS (br) < 16 + 16)
return GST_AV1_PARSER_NO_MORE_DATA;
render_width_minus_1 = AV1_READ_UINT16 (br);
render_height_minus_1 = AV1_READ_UINT16 (br);
parser->state.render_width = render_width_minus_1 + 1;
parser->state.render_height = render_height_minus_1 + 1;
} else {
parser->state.render_width = parser->state.upscaled_width;
parser->state.render_height = parser->state.frame_height;
}
return GST_AV1_PARSER_OK;
}
/* 5.9.7 */
static GstAV1ParserResult
gst_av1_parse_frame_size_with_refs (GstAV1Parser * parser,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval;
GstAV1ReferenceFrameInfo *ref_info;
gboolean found_ref = FALSE;
gint i;
ref_info = &(parser->state.ref_info);
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
found_ref = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
if (found_ref == 1) {
gint ref_idx = frame_header->ref_frame_idx[i];
parser->state.upscaled_width =
ref_info->entry[ref_idx].ref_upscaled_width;
parser->state.frame_width = parser->state.upscaled_width;
parser->state.frame_height = ref_info->entry[ref_idx].ref_frame_height;
parser->state.render_width = ref_info->entry[ref_idx].ref_render_width;
parser->state.render_height = ref_info->entry[ref_idx].ref_render_height;
break;
}
}
if (found_ref == 0) {
retval = gst_av1_parse_frame_size (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
return retval;
retval = gst_av1_parse_render_size (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
return retval;
} else {
retval = gst_av1_parse_superres_params_compute_image_size (parser, br,
frame_header);
if (retval != GST_AV1_PARSER_OK)
return retval;
}
return GST_AV1_PARSER_OK;
}
/* 5.9.12 */
static GstAV1ParserResult
gst_av1_parse_quantization_params (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
GstAV1ColorConfig *color_config;
GstAV1QuantizationParams *quant_params = &(frame_header->quantization_params);
g_assert (parser->seq_header);
color_config = &(parser->seq_header->color_config);
quant_params->base_q_idx = AV1_READ_UINT8_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
frame_header->quantization_params.delta_q_y_dc =
av1_bitstreamfn_delta_q (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (parser->seq_header->num_planes > 1) {
if (color_config->separate_uv_delta_q) {
quant_params->diff_uv_delta = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
quant_params->diff_uv_delta = 0;
}
frame_header->quantization_params.delta_q_u_dc =
av1_bitstreamfn_delta_q (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
frame_header->quantization_params.delta_q_u_ac =
av1_bitstreamfn_delta_q (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (quant_params->diff_uv_delta) {
frame_header->quantization_params.delta_q_v_dc =
av1_bitstreamfn_delta_q (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
frame_header->quantization_params.delta_q_v_ac =
av1_bitstreamfn_delta_q (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
frame_header->quantization_params.delta_q_v_dc =
frame_header->quantization_params.delta_q_u_dc;
frame_header->quantization_params.delta_q_v_ac =
frame_header->quantization_params.delta_q_u_ac;
}
} else {
frame_header->quantization_params.delta_q_u_dc = 0;
frame_header->quantization_params.delta_q_u_ac = 0;
frame_header->quantization_params.delta_q_v_dc = 0;
frame_header->quantization_params.delta_q_v_ac = 0;
}
quant_params->using_qmatrix = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (quant_params->using_qmatrix) {
if (AV1_REMAINING_BITS (br) < 4 + 4) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
quant_params->qm_y = AV1_READ_BITS (br, 4);
quant_params->qm_u = AV1_READ_BITS (br, 4);
if (!color_config->separate_uv_delta_q) {
quant_params->qm_v = quant_params->qm_u;
} else {
quant_params->qm_v = AV1_READ_BITS_CHECKED (br, 4, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse quantization params error %d", retval);
return retval;
}
/* 5.9.14 */
static GstAV1ParserResult
gst_av1_parse_segmentation_params (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
gint i, j;
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
gint clipped_value /* clippedValue */ ;
GstAV1SegmenationParams *seg_params;
gint feature_value = 0;
const guint8 segmentation_feature_bits[GST_AV1_SEG_LVL_MAX] = {
8, 6, 6, 6, 6, 3, 0, 0
};
const guint8 segmentation_feature_signed[GST_AV1_SEG_LVL_MAX] = {
1, 1, 1, 1, 1, 0, 0, 0
};
const guint8 segmentation_feature_max[GST_AV1_SEG_LVL_MAX] = {
255, GST_AV1_MAX_LOOP_FILTER, GST_AV1_MAX_LOOP_FILTER,
GST_AV1_MAX_LOOP_FILTER, GST_AV1_MAX_LOOP_FILTER, 7, 0, 0
};
seg_params = &frame_header->segmentation_params;
seg_params->segmentation_enabled = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seg_params->segmentation_enabled) {
if (frame_header->primary_ref_frame == GST_AV1_PRIMARY_REF_NONE) {
seg_params->segmentation_update_map = 1;
seg_params->segmentation_temporal_update = 0;
seg_params->segmentation_update_data = 1;
} else {
seg_params->segmentation_update_map = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seg_params->segmentation_update_map) {
seg_params->segmentation_temporal_update =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
seg_params->segmentation_update_data = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (seg_params->segmentation_update_data) {
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
seg_params->feature_enabled[i][j] =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
clipped_value = 0;
feature_value = 0;
if (seg_params->feature_enabled[i][j]) {
gint bits_to_read = segmentation_feature_bits[j];
gint limit = segmentation_feature_max[j];
if (segmentation_feature_signed[j]) {
feature_value =
av1_bitstreamfn_su (br, 1 + bits_to_read, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
clipped_value = CLAMP (feature_value, limit * (-1), limit);
} else {
feature_value = AV1_READ_BITS_CHECKED (br, bits_to_read, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
clipped_value = CLAMP (feature_value, 0, limit);
}
}
seg_params->feature_data[i][j] = clipped_value;
}
}
} else {
gint8 ref_idx;
GstAV1SegmenationParams *ref_seg_params;
/* Copy it from prime_ref */
if (frame_header->primary_ref_frame >= GST_AV1_PRIMARY_REF_NONE) {
GST_WARNING ("Invalid primary_ref_frame %d",
frame_header->primary_ref_frame);
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
ref_idx = frame_header->ref_frame_idx[frame_header->primary_ref_frame];
if (ref_idx >= GST_AV1_NUM_REF_FRAMES || ref_idx < 0) {
GST_WARNING ("Invalid ref_frame_idx %d", ref_idx);
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
if (!parser->state.ref_info.entry[ref_idx].ref_valid) {
GST_WARNING ("Reference frame at index %d is unavailable", ref_idx);
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
ref_seg_params =
&parser->state.ref_info.entry[ref_idx].ref_segmentation_params;
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
seg_params->feature_enabled[i][j] =
ref_seg_params->feature_enabled[i][j];
seg_params->feature_data[i][j] = ref_seg_params->feature_data[i][j];
}
}
}
} else {
seg_params->segmentation_update_map = 0;
seg_params->segmentation_temporal_update = 0;
seg_params->segmentation_update_data = 0;
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
seg_params->feature_enabled[i][j] = 0;
seg_params->feature_data[i][j] = 0;
}
}
}
seg_params->seg_id_pre_skip = 0;
seg_params->last_active_seg_id = 0;
for (i = 0; i < GST_AV1_MAX_SEGMENTS; i++) {
for (j = 0; j < GST_AV1_SEG_LVL_MAX; j++) {
if (seg_params->feature_enabled[i][j]) {
seg_params->last_active_seg_id = i;
if (j >= GST_AV1_SEG_LVL_REF_FRAME) {
seg_params->seg_id_pre_skip = 1;
}
}
}
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse segmentation params error %d", retval);
return retval;
}
/* 5.9.15 */
static GstAV1ParserResult
gst_av1_parse_tile_info (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
GstAV1SequenceHeaderOBU *seq_header;
GstAV1TileInfo *tile_info;
gint i;
gint start_sb /* startSb */ ;
gint sb_cols /* sbCols */ ;
gint sb_rows /* sbRows */ ;
gint sb_shift /*sbShift */ ;
gint sb_size /* sbSize */ ;
gint max_tile_width_sb /* maxTileWidthSb */ ;
gint max_tile_height_sb /* maxTileHeightSb */ ;
gint max_tile_area_sb /* maxTileAreaSb */ ;
gint min_log2_tile_cols /* minLog2TileCols */ ;
gint max_log2_tile_cols /* maxLog2TileCols */ ;
gint min_log2_tile_rows /* minLog2TileRows */ ;
gint max_log2_tile_rows /* maxLog2TileRows */ ;
gint min_log2_tiles /* minLog2Tiles */ ;
gint tile_width_sb /* tileWidthSb */ ;
gint tile_height_sb /* tileHeightSb */ ;
gint max_width /* maxWidth */ , max_height /* maxHeight */ ;
gint size_sb /* sizeSb */ ;
gint widest_tile_sb /* widestTileSb */ ;
g_assert (parser->seq_header);
seq_header = parser->seq_header;
tile_info = &frame_header->tile_info;
sb_cols = seq_header->use_128x128_superblock ?
((parser->state.mi_cols + 31) >> 5) : ((parser->state.mi_cols + 15) >> 4);
sb_rows = seq_header->use_128x128_superblock ? ((parser->state.mi_rows +
31) >> 5) : ((parser->state.mi_rows + 15) >> 4);
sb_shift = seq_header->use_128x128_superblock ? 5 : 4;
sb_size = sb_shift + 2;
max_tile_width_sb = GST_AV1_MAX_TILE_WIDTH >> sb_size;
max_tile_area_sb = GST_AV1_MAX_TILE_AREA >> (2 * sb_size);
min_log2_tile_cols = av1_helper_tile_log2 (max_tile_width_sb, sb_cols);
max_log2_tile_cols = av1_helper_tile_log2 (1, MIN (sb_cols,
GST_AV1_MAX_TILE_COLS));
max_log2_tile_rows = av1_helper_tile_log2 (1, MIN (sb_rows,
GST_AV1_MAX_TILE_ROWS));
min_log2_tiles = MAX (min_log2_tile_cols,
av1_helper_tile_log2 (max_tile_area_sb, sb_rows * sb_cols));
tile_info->uniform_tile_spacing_flag = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (tile_info->uniform_tile_spacing_flag) {
parser->state.tile_cols_log2 = min_log2_tile_cols;
while (parser->state.tile_cols_log2 < max_log2_tile_cols) {
gint increment_tile_cols_log2 = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (increment_tile_cols_log2 == 1)
parser->state.tile_cols_log2++;
else
break;
}
tile_width_sb = (sb_cols + (1 << parser->state.tile_cols_log2) -
1) >> parser->state.tile_cols_log2;
i = 0;
/* Fill mi_col_starts[] and make sure to not exceed array range */
for (start_sb = 0; start_sb < sb_cols && i < GST_AV1_MAX_TILE_COLS;
start_sb += tile_width_sb) {
parser->state.mi_col_starts[i] = start_sb << sb_shift;
i += 1;
}
parser->state.mi_col_starts[i] = parser->state.mi_cols;
parser->state.tile_cols = i;
while (i >= 1) {
tile_info->width_in_sbs_minus_1[i - 1] =
((parser->state.mi_col_starts[i] - parser->state.mi_col_starts[i - 1]
+ ((1 << sb_shift) - 1)) >> sb_shift) - 1;
i--;
}
min_log2_tile_rows = MAX (min_log2_tiles - parser->state.tile_cols_log2, 0);
parser->state.tile_rows_log2 = min_log2_tile_rows;
while (parser->state.tile_rows_log2 < max_log2_tile_rows) {
tile_info->increment_tile_rows_log2 = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (tile_info->increment_tile_rows_log2 == 1)
parser->state.tile_rows_log2++;
else
break;
}
tile_height_sb = (sb_rows + (1 << parser->state.tile_rows_log2) -
1) >> parser->state.tile_rows_log2;
i = 0;
/* Fill mi_row_starts[] and make sure to not exceed array range */
for (start_sb = 0; start_sb < sb_rows && i < GST_AV1_MAX_TILE_ROWS;
start_sb += tile_height_sb) {
parser->state.mi_row_starts[i] = start_sb << sb_shift;
i += 1;
}
parser->state.mi_row_starts[i] = parser->state.mi_rows;
parser->state.tile_rows = i;
while (i >= 1) {
tile_info->height_in_sbs_minus_1[i - 1] =
((parser->state.mi_row_starts[i] - parser->state.mi_row_starts[i - 1]
+ ((1 << sb_shift) - 1)) >> sb_shift) - 1;
i--;
}
} else {
widest_tile_sb = 0;
start_sb = 0;
/* Fill mi_col_starts[] and make sure to not exceed array range */
for (i = 0; start_sb < sb_cols && i < GST_AV1_MAX_TILE_COLS; i++) {
parser->state.mi_col_starts[i] = start_sb << sb_shift;
max_width = MIN (sb_cols - start_sb, max_tile_width_sb);
tile_info->width_in_sbs_minus_1[i] =
av1_bitstreamfn_ns (br, max_width, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
size_sb = tile_info->width_in_sbs_minus_1[i] + 1;
widest_tile_sb = MAX (size_sb, widest_tile_sb);
start_sb += size_sb;
}
parser->state.mi_col_starts[i] = parser->state.mi_cols;
parser->state.tile_cols = i;
parser->state.tile_cols_log2 =
av1_helper_tile_log2 (1, parser->state.tile_cols);
if (min_log2_tiles > 0)
max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
else
max_tile_area_sb = sb_rows * sb_cols;
max_tile_height_sb = MAX (max_tile_area_sb / widest_tile_sb, 1);
start_sb = 0;
/* Fill mi_row_starts[] and make sure to not exceed array range */
for (i = 0; start_sb < sb_rows && i < GST_AV1_MAX_TILE_ROWS; i++) {
parser->state.mi_row_starts[i] = start_sb << sb_shift;
max_height = MIN (sb_rows - start_sb, max_tile_height_sb);
tile_info->height_in_sbs_minus_1[i] =
av1_bitstreamfn_ns (br, max_height, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
size_sb = tile_info->height_in_sbs_minus_1[i] + 1;
start_sb += size_sb;
}
parser->state.mi_row_starts[i] = parser->state.mi_rows;
parser->state.tile_rows = i;
parser->state.tile_rows_log2 =
av1_helper_tile_log2 (1, parser->state.tile_rows);
}
if (parser->state.tile_cols_log2 > 0 || parser->state.tile_rows_log2 > 0) {
tile_info->context_update_tile_id =
AV1_READ_BITS_CHECKED (br,
parser->state.tile_cols_log2 + parser->state.tile_rows_log2, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
tile_info->tile_size_bytes_minus_1 = AV1_READ_BITS_CHECKED (br, 2, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
parser->state.tile_size_bytes = tile_info->tile_size_bytes_minus_1 + 1;
} else {
tile_info->context_update_tile_id = 0;
}
memcpy (tile_info->mi_col_starts, parser->state.mi_col_starts,
sizeof (guint32) * (GST_AV1_MAX_TILE_COLS + 1));
memcpy (tile_info->mi_row_starts, parser->state.mi_row_starts,
sizeof (guint32) * (GST_AV1_MAX_TILE_ROWS + 1));
tile_info->tile_cols_log2 = parser->state.tile_cols_log2;
tile_info->tile_cols = parser->state.tile_cols;
tile_info->tile_rows_log2 = parser->state.tile_rows_log2;
tile_info->tile_rows = parser->state.tile_rows;
tile_info->tile_size_bytes = parser->state.tile_size_bytes;
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse tile info error %d", retval);
return retval;
}
static GstAV1ParserResult
gst_av1_parse_loop_filter_params (GstAV1Parser * parser,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
GstAV1LoopFilterParams *lf_params;
gint i;
guint8 update_ref_deltas = 0;
guint8 update_mode_deltas = 0;
g_assert (parser->seq_header);
lf_params = &frame_header->loop_filter_params;
if (frame_header->coded_lossless || frame_header->allow_intrabc) {
lf_params->loop_filter_level[0] = 0;
lf_params->loop_filter_level[1] = 0;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME] = 1;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME] = 0;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME] = 0;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME] = 0;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME] = 0;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME] = -1;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME] = -1;
lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME] = -1;
for (i = 0; i < 2; i++)
lf_params->loop_filter_mode_deltas[i] = 0;
goto success;
}
if (AV1_REMAINING_BITS (br) < 6 + 6) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
lf_params->loop_filter_level[0] = AV1_READ_BITS (br, 6);
lf_params->loop_filter_level[1] = AV1_READ_BITS (br, 6);
if (parser->seq_header->num_planes > 1) {
if (lf_params->loop_filter_level[0] || lf_params->loop_filter_level[1]) {
if (AV1_REMAINING_BITS (br) < 6 + 6) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
lf_params->loop_filter_level[2] = AV1_READ_BITS (br, 6);
lf_params->loop_filter_level[3] = AV1_READ_BITS (br, 6);
}
}
if (AV1_REMAINING_BITS (br) < 3 + 1) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
lf_params->loop_filter_sharpness = AV1_READ_BITS (br, 3);
lf_params->loop_filter_delta_enabled = AV1_READ_BIT (br);
if (lf_params->loop_filter_delta_enabled) {
lf_params->loop_filter_delta_update = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (lf_params->loop_filter_delta_update) {
for (i = 0; i < GST_AV1_TOTAL_REFS_PER_FRAME; i++) {
update_ref_deltas = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (update_ref_deltas) {
lf_params->loop_filter_ref_deltas[i] =
av1_bitstreamfn_su (br, 7, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
}
for (i = 0; i < 2; i++) {
update_mode_deltas = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (update_mode_deltas) {
lf_params->loop_filter_mode_deltas[i] =
av1_bitstreamfn_su (br, 7, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
}
}
}
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse loop filter params error %d", retval);
return retval;
}
/* 5.9.17 */
static GstAV1ParserResult
gst_av1_parse_delta_q_params (GstAV1Parser * parser,
GstBitReader * br, GstAV1QuantizationParams * quant_params)
{
GstAV1ParserResult retval;
quant_params->delta_q_res = 0;
quant_params->delta_q_present = 0;
if (quant_params->base_q_idx > 0) {
quant_params->delta_q_present = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
}
if (quant_params->delta_q_present) {
quant_params->delta_q_res = AV1_READ_BITS_CHECKED (br, 2, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
}
return GST_AV1_PARSER_OK;
}
/* 5.9.18 */
static GstAV1ParserResult
gst_av1_parse_delta_lf_params (GstAV1Parser * parser,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval;
GstAV1LoopFilterParams *lf_params;
lf_params = &frame_header->loop_filter_params;
lf_params->delta_lf_present = 0;
lf_params->delta_lf_res = 0;
lf_params->delta_lf_multi = 0;
if (frame_header->quantization_params.delta_q_present) {
if (!frame_header->allow_intrabc) {
lf_params->delta_lf_present = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
}
if (lf_params->delta_lf_present) {
if (AV1_REMAINING_BITS (br) < 2 + 1)
return GST_AV1_PARSER_NO_MORE_DATA;
lf_params->delta_lf_res = AV1_READ_BITS (br, 2);
lf_params->delta_lf_multi = AV1_READ_BIT (br);
}
}
return GST_AV1_PARSER_OK;
}
/* 5.9.19 */
static GstAV1ParserResult
gst_av1_parse_cdef_params (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1SequenceHeaderOBU *seq_header;
GstAV1CDEFParams *cdef_params;
guint8 cdef_damping_minus_3;
gint i;
g_assert (parser->seq_header);
cdef_params = &frame_header->cdef_params;
seq_header = parser->seq_header;
if (frame_header->coded_lossless || frame_header->allow_intrabc
|| !seq_header->enable_cdef) {
cdef_params->cdef_bits = 0;
cdef_params->cdef_y_pri_strength[0] = 0;
cdef_params->cdef_y_sec_strength[0] = 0;
cdef_params->cdef_uv_pri_strength[0] = 0;
cdef_params->cdef_uv_sec_strength[0] = 0;
cdef_params->cdef_damping = 3;
return GST_AV1_PARSER_OK;
}
if (AV1_REMAINING_BITS (br) < 2 + 2)
return GST_AV1_PARSER_NO_MORE_DATA;
cdef_damping_minus_3 = AV1_READ_BITS (br, 2);
cdef_params->cdef_damping = cdef_damping_minus_3 + 3;
cdef_params->cdef_bits = AV1_READ_BITS (br, 2);
for (i = 0; i < (1 << cdef_params->cdef_bits); i++) {
if (AV1_REMAINING_BITS (br) < 4 + 2)
return GST_AV1_PARSER_NO_MORE_DATA;
cdef_params->cdef_y_pri_strength[i] = AV1_READ_BITS (br, 4);
cdef_params->cdef_y_sec_strength[i] = AV1_READ_BITS (br, 2);
if (cdef_params->cdef_y_sec_strength[i] == 3)
cdef_params->cdef_y_sec_strength[i] += 1;
if (parser->seq_header->num_planes > 1) {
if (AV1_REMAINING_BITS (br) < 4 + 2)
return GST_AV1_PARSER_NO_MORE_DATA;
cdef_params->cdef_uv_pri_strength[i] = AV1_READ_BITS (br, 4);
cdef_params->cdef_uv_sec_strength[i] = AV1_READ_BITS (br, 2);
if (cdef_params->cdef_uv_sec_strength[i] == 3)
cdef_params->cdef_uv_sec_strength[i] += 1;
}
}
return GST_AV1_PARSER_OK;
}
/* 5.9.20 */
static GstAV1ParserResult
gst_av1_parse_loop_restoration_params (GstAV1Parser * parser,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1LoopRestorationParams *lr_params;
GstAV1SequenceHeaderOBU *seq_header;
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
guint8 lr_type;
gint i;
guint8 use_chroma_lr /* useChromaLr */ ;
const GstAV1FrameRestorationType remap_lr_type /* Remap_Lr_Type */ [4] = {
GST_AV1_FRAME_RESTORE_NONE,
GST_AV1_FRAME_RESTORE_SWITCHABLE,
GST_AV1_FRAME_RESTORE_WIENER, GST_AV1_FRAME_RESTORE_SGRPROJ
};
g_assert (parser->seq_header);
lr_params = &frame_header->loop_restoration_params;
seq_header = parser->seq_header;
if (frame_header->all_lossless || frame_header->allow_intrabc
|| !seq_header->enable_restoration) {
for (i = 0; i < GST_AV1_MAX_NUM_PLANES; i++)
lr_params->frame_restoration_type[i] = GST_AV1_FRAME_RESTORE_NONE;
lr_params->uses_lr = 0;
goto success;
}
lr_params->uses_lr = 0;
use_chroma_lr = 0;
for (i = 0; i < seq_header->num_planes; i++) {
lr_type = AV1_READ_BITS_CHECKED (br, 2, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
lr_params->frame_restoration_type[i] = remap_lr_type[lr_type];
if (lr_params->frame_restoration_type[i] != GST_AV1_FRAME_RESTORE_NONE) {
lr_params->uses_lr = 1;
if (i > 0) {
use_chroma_lr = 1;
}
}
}
if (lr_params->uses_lr) {
if (seq_header->use_128x128_superblock) {
lr_params->lr_unit_shift = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
lr_params->lr_unit_shift++;
} else {
guint8 lr_unit_extra_shift;
lr_params->lr_unit_shift = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (lr_params->lr_unit_shift) {
lr_unit_extra_shift = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
lr_params->lr_unit_shift += lr_unit_extra_shift;
}
}
lr_params->loop_restoration_size[0] =
GST_AV1_RESTORATION_TILESIZE_MAX >> (2 - lr_params->lr_unit_shift);
if (seq_header->color_config.subsampling_x
&& seq_header->color_config.subsampling_y && use_chroma_lr) {
lr_params->lr_uv_shift = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
lr_params->lr_uv_shift = 0;
}
lr_params->loop_restoration_size[1] =
lr_params->loop_restoration_size[0] >> lr_params->lr_uv_shift;
lr_params->loop_restoration_size[2] =
lr_params->loop_restoration_size[0] >> lr_params->lr_uv_shift;
}
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse loop restoration params error %d", retval);
return retval;
}
/* 5.9.21 */
static GstAV1ParserResult
gst_av1_parse_tx_mode (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval;
if (frame_header->coded_lossless == 1) {
frame_header->tx_mode = GST_AV1_TX_MODE_ONLY_4x4;
} else {
frame_header->tx_mode_select = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
if (frame_header->tx_mode_select) {
frame_header->tx_mode = GST_AV1_TX_MODE_SELECT;
} else {
frame_header->tx_mode = GST_AV1_TX_MODE_LARGEST;
}
}
return GST_AV1_PARSER_OK;
}
/* 5.9.3 */
static gint
gst_av1_get_relative_dist (GstAV1SequenceHeaderOBU * seq_header, gint a, gint b)
{
gint m, diff;
if (!seq_header->enable_order_hint)
return 0;
diff = a - b;
m = 1 << seq_header->order_hint_bits_minus_1;
diff = (diff & (m - 1)) - (diff & m);
return diff;
}
/* 5.9.22 */
static GstAV1ParserResult
gst_av1_parse_skip_mode_params (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ReferenceFrameInfo *ref_info;
GstAV1SequenceHeaderOBU *seq_header;
gint i;
gint skip_mode_allowed /* skipModeAllowed */ ;
GstAV1ParserResult retval;
g_assert (parser->seq_header);
seq_header = parser->seq_header;
ref_info = &(parser->state.ref_info);
skip_mode_allowed = 0;
if (frame_header->frame_is_intra || !frame_header->reference_select
|| !seq_header->enable_order_hint) {
skip_mode_allowed = 0;
} else {
gint forward_idx = -1 /* forwardIdx */ ;
gint forward_hint = 0 /* forwardHint */ ;
gint backward_idx = -1 /* backwardIdx */ ;
gint backward_hint = 0 /* backwardHint */ ;
gint ref_hint = 0 /* refHint */ ;
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
ref_hint = ref_info->entry[frame_header->ref_frame_idx[i]].ref_order_hint;
if (gst_av1_get_relative_dist (parser->seq_header, ref_hint,
frame_header->order_hint) < 0) {
if (forward_idx < 0
|| gst_av1_get_relative_dist (parser->seq_header, ref_hint,
forward_hint) > 0) {
forward_idx = i;
forward_hint = ref_hint;
}
} else
if (gst_av1_get_relative_dist (parser->seq_header, ref_hint,
frame_header->order_hint) > 0) {
if (backward_idx < 0
|| gst_av1_get_relative_dist (parser->seq_header, ref_hint,
backward_hint) < 0) {
backward_idx = i;
backward_hint = ref_hint;
}
}
}
if (forward_idx < 0) {
skip_mode_allowed = 0;
} else if (backward_idx >= 0) {
skip_mode_allowed = 1;
frame_header->skip_mode_frame[0] =
GST_AV1_REF_LAST_FRAME + MIN (forward_idx, backward_idx);
frame_header->skip_mode_frame[1] =
GST_AV1_REF_LAST_FRAME + MAX (forward_idx, backward_idx);
} else {
gint second_forward_idx = -1 /* secondForwardIdx */ ;
gint second_forward_hint = 0 /* secondForwardHint */ ;
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
ref_hint =
ref_info->entry[frame_header->ref_frame_idx[i]].ref_order_hint;
if (gst_av1_get_relative_dist (parser->seq_header, ref_hint,
forward_hint) < 0) {
if (second_forward_idx < 0
|| gst_av1_get_relative_dist (parser->seq_header, ref_hint,
second_forward_hint) > 0) {
second_forward_idx = i;
second_forward_hint = ref_hint;
}
}
}
if (second_forward_idx < 0) {
skip_mode_allowed = 0;
} else {
skip_mode_allowed = 1;
frame_header->skip_mode_frame[0] =
GST_AV1_REF_LAST_FRAME + MIN (forward_idx, second_forward_idx);
frame_header->skip_mode_frame[1] =
GST_AV1_REF_LAST_FRAME + MAX (forward_idx, second_forward_idx);
}
}
}
if (skip_mode_allowed) {
frame_header->skip_mode_present = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
return retval;
} else {
frame_header->skip_mode_present = 0;
}
return GST_AV1_PARSER_OK;
}
/* 5.9.28 */
static gint
gst_av1_decode_subexp (GstBitReader * br, gint numSyms,
GstAV1ParserResult * retval)
{
gint i = 0;
gint mk = 0;
gint k = 3;
gint subexp_final_bits = 0;
gint subexp_more_bits = 0;
gint subexp_bits = 0;
while (1) {
gint b2 = i ? k + i - 1 : k;
gint a = 1 << b2;
if (numSyms <= mk + 3 * a) {
subexp_final_bits = av1_bitstreamfn_ns (br, numSyms - mk, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
return subexp_final_bits + mk;
} else {
subexp_more_bits = AV1_READ_BITS_CHECKED (br, 1, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
if (subexp_more_bits) {
i++;
mk += a;
} else {
subexp_bits = AV1_READ_BITS_CHECKED (br, b2, retval);
if (*retval != GST_AV1_PARSER_OK)
return 0;
return subexp_bits + mk;
}
}
}
}
/* 5.9.27 */
static gint
gst_av1_decode_unsigned_subexp_with_ref (GstBitReader * br, gint mx,
gint r, GstAV1ParserResult * retval)
{
gint v;
v = gst_av1_decode_subexp (br, mx, retval);
if ((r << 1) <= mx) {
return av1_helper_inverse_recenter (r, v);
} else {
return mx - 1 - av1_helper_inverse_recenter (mx - 1 - r, v);
}
}
/* 5.9.26 */
static gint
gst_av1_decode_signed_subexp_with_ref (GstBitReader * br, gint low,
gint high, gint r, GstAV1ParserResult * retval)
{
return gst_av1_decode_unsigned_subexp_with_ref (br,
high - low, r - low, retval) + low;
}
/* 5.9.25 */
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)
{
GstAV1ParserResult retval;
gint prec_diff /* precDiff */ , wm_round, mx, r;
gint abs_bits /* absBits */ = GST_AV1_GM_ABS_ALPHA_BITS;
gint prec_bits /* precBits */ = GST_AV1_GM_ALPHA_PREC_BITS;
gint sub;
if (idx < 2) {
if (type == GST_AV1_WARP_MODEL_TRANSLATION) {
abs_bits =
GST_AV1_GM_ABS_TRANS_ONLY_BITS -
(frame_header->allow_high_precision_mv ? 0 : 1);
prec_bits =
GST_AV1_GM_TRANS_ONLY_PREC_BITS -
(frame_header->allow_high_precision_mv ? 0 : 1);
} else {
abs_bits = GST_AV1_GM_ABS_TRANS_BITS;
prec_bits = GST_AV1_GM_TRANS_PREC_BITS;
}
}
prec_diff = GST_AV1_WARPEDMODEL_PREC_BITS - prec_bits;
wm_round = (idx % 3) == 2 ? (1 << GST_AV1_WARPEDMODEL_PREC_BITS) : 0;
sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
mx = (1 << abs_bits);
r = (prev_gm_params[ref][idx] >> prec_diff) - sub;
gm_params->gm_params[ref][idx] =
(gst_av1_decode_signed_subexp_with_ref (br, -mx, mx + 1, r,
&retval) << prec_diff) + wm_round;
if (retval != GST_AV1_PARSER_OK)
return retval;
return GST_AV1_PARSER_OK;
}
static gboolean
gst_av1_parser_is_shear_params_valid (gint32 gm_params[6])
{
const gint32 *mat = gm_params;
gint16 alpha, beta, gamma, delta;
gint16 shift;
gint16 y;
gint16 v;
guint i;
gboolean default_warp_params;
if (!(mat[2] > 0))
return FALSE;
default_warp_params = TRUE;
for (i = 0; i < 6; i++) {
if (gm_params[i] != ((i % 3 == 2) ? 1 << GST_AV1_WARPEDMODEL_PREC_BITS : 0)) {
default_warp_params = FALSE;
break;
}
}
if (default_warp_params)
return TRUE;
alpha = CLAMP (mat[2] - (1 << GST_AV1_WARPEDMODEL_PREC_BITS),
G_MININT16, G_MAXINT16);
beta = CLAMP (mat[3], G_MININT16, G_MAXINT16);
y = av1_helper_resolve_divisor_32 (ABS (mat[2]), &shift)
* (mat[2] < 0 ? -1 : 1);
v = ((gint64) mat[4] * (1 << GST_AV1_WARPEDMODEL_PREC_BITS)) * y;
gamma =
CLAMP ((gint) av1_helper_round_power_of_two_signed (v, shift), G_MININT16,
G_MAXINT16);
v = ((gint64) mat[3] * mat[4]) * y;
delta =
CLAMP (mat[5] - (gint) av1_helper_round_power_of_two_signed (v,
shift) - (1 << GST_AV1_WARPEDMODEL_PREC_BITS), G_MININT16,
G_MAXINT16);
alpha =
av1_helper_round_power_of_two_signed (alpha,
GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
beta =
av1_helper_round_power_of_two_signed (beta,
GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
gamma =
av1_helper_round_power_of_two_signed (gamma,
GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
delta =
av1_helper_round_power_of_two_signed (delta,
GST_AV1_WARP_PARAM_REDUCE_BITS) * (1 << GST_AV1_WARP_PARAM_REDUCE_BITS);
if ((4 * ABS (alpha) + 7 * ABS (beta) >= (1 << GST_AV1_WARPEDMODEL_PREC_BITS))
|| (4 * ABS (gamma) + 4 * ABS (delta) >=
(1 << GST_AV1_WARPEDMODEL_PREC_BITS)))
return FALSE;
return TRUE;
}
/* 5.9.24 */
static GstAV1ParserResult
gst_av1_parse_global_motion_params (GstAV1Parser * parser,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1WarpModelType type;
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
gint i, ref;
GstAV1GlobalMotionParams *gm_params = &(frame_header->global_motion_params);
gint32 prev_gm_params[GST_AV1_NUM_REF_FRAMES][6] /* PrevGmParams */ ;
/* init value */
gm_params->gm_type[GST_AV1_REF_INTRA_FRAME] = GST_AV1_WARP_MODEL_IDENTITY;
for (ref = GST_AV1_REF_LAST_FRAME; ref <= GST_AV1_REF_ALTREF_FRAME; ref++) {
gm_params->invalid[ref] = 0;
gm_params->gm_type[ref] = GST_AV1_WARP_MODEL_IDENTITY;
for (i = 0; i < 6; i++) {
gm_params->gm_params[ref][i] =
((i % 3 == 2) ? 1 << GST_AV1_WARPEDMODEL_PREC_BITS : 0);
}
}
if (frame_header->frame_is_intra)
goto success;
if (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE) {
GstAV1GlobalMotionParams *ref_global_motion_params =
&parser->state.ref_info.entry[frame_header->
ref_frame_idx[frame_header->primary_ref_frame]].
ref_global_motion_params;
memcpy (prev_gm_params, ref_global_motion_params->gm_params,
sizeof (gint32) * GST_AV1_NUM_REF_FRAMES * 6);
} else {
for (ref = GST_AV1_REF_INTRA_FRAME; ref < GST_AV1_NUM_REF_FRAMES; ref++)
for (i = 0; i < 6; i++)
prev_gm_params[ref][i] =
((i % 3 == 2) ? 1 << GST_AV1_WARPEDMODEL_PREC_BITS : 0);
}
for (ref = GST_AV1_REF_LAST_FRAME; ref <= GST_AV1_REF_ALTREF_FRAME; ref++) {
gm_params->is_global[ref] = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (gm_params->is_global[ref]) {
gm_params->is_rot_zoom[ref] = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (gm_params->is_rot_zoom[ref]) {
type = GST_AV1_WARP_MODEL_ROTZOOM;
} else {
gm_params->is_translation[ref] = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
type =
gm_params->is_translation[ref] ? GST_AV1_WARP_MODEL_TRANSLATION :
GST_AV1_WARP_MODEL_AFFINE;
}
} else {
type = GST_AV1_WARP_MODEL_IDENTITY;
}
gm_params->gm_type[ref] = type;
if (type >= GST_AV1_WARP_MODEL_ROTZOOM) {
retval =
gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
prev_gm_params, ref, 2);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval =
gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
prev_gm_params, ref, 3);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (type == GST_AV1_WARP_MODEL_AFFINE) {
retval =
gst_av1_parse_global_param (parser, frame_header, br, gm_params,
type, prev_gm_params, ref, 4);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval =
gst_av1_parse_global_param (parser, frame_header, br, gm_params,
type, prev_gm_params, ref, 5);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
gm_params->gm_params[ref][4] = gm_params->gm_params[ref][3] * (-1);
gm_params->gm_params[ref][5] = gm_params->gm_params[ref][2];
}
}
if (type >= GST_AV1_WARP_MODEL_TRANSLATION) {
retval =
gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
prev_gm_params, ref, 0);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval =
gst_av1_parse_global_param (parser, frame_header, br, gm_params, type,
prev_gm_params, ref, 1);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (type <= GST_AV1_WARP_MODEL_AFFINE)
gm_params->invalid[ref] =
!gst_av1_parser_is_shear_params_valid (gm_params->gm_params[ref]);
}
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse global motion params error %d", retval);
return retval;
}
/* 5.9.30 */
static GstAV1ParserResult
gst_av1_parse_film_grain_params (GstAV1Parser * parser, GstBitReader * br,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1FilmGrainParams *fg_params;
GstAV1SequenceHeaderOBU *seq_header;
gint i;
gint num_pos_chroma /* numPosChroma */ , num_pos_luma /* numPosLuma */ ;
GstAV1ParserResult ret = GST_AV1_PARSER_OK;
g_assert (parser->seq_header);
fg_params = &frame_header->film_grain_params;
seq_header = parser->seq_header;
if (!seq_header->film_grain_params_present || (!frame_header->show_frame
&& !frame_header->showable_frame)) {
/* reset_grain_params() is a function call that indicates that all the
syntax elements read in film_grain_params should be set equal to 0. */
memset (fg_params, 0, sizeof (*fg_params));
goto success;
}
fg_params->apply_grain = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (!fg_params->apply_grain) {
/* reset_grain_params() */
memset (fg_params, 0, sizeof (*fg_params));
goto success;
}
fg_params->grain_seed = AV1_READ_UINT16_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
if (frame_header->frame_type == GST_AV1_INTER_FRAME) {
fg_params->update_grain = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
} else {
fg_params->update_grain = 1;
}
if (!fg_params->update_grain) {
guint16 temp_grain_seed /* tempGrainSeed */ ;
gint j;
gboolean found = FALSE;
fg_params->film_grain_params_ref_idx = AV1_READ_BITS_CHECKED (br, 3, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
for (j = 0; j < GST_AV1_REFS_PER_FRAME; j++) {
if (frame_header->ref_frame_idx[j] ==
fg_params->film_grain_params_ref_idx) {
found = TRUE;
break;
}
}
if (!found) {
GST_INFO ("Invalid film grain reference idx %d.",
fg_params->film_grain_params_ref_idx);
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (!parser->state.ref_info.entry[fg_params->film_grain_params_ref_idx].
ref_valid) {
GST_INFO ("Invalid ref info of film grain idx %d.",
fg_params->film_grain_params_ref_idx);
ret = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
temp_grain_seed = fg_params->grain_seed;
memcpy (fg_params,
&parser->state.ref_info.entry[fg_params->film_grain_params_ref_idx].
ref_film_grain_params, sizeof (GstAV1FilmGrainParams));
fg_params->grain_seed = temp_grain_seed;
goto success;
}
fg_params->num_y_points = AV1_READ_BITS_CHECKED (br, 4, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
for (i = 0; i < fg_params->num_y_points; i++) {
if (AV1_REMAINING_BITS (br) < 8 + 8) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->point_y_value[i] = AV1_READ_UINT8 (br);
fg_params->point_y_scaling[i] = AV1_READ_UINT8 (br);
}
if (seq_header->color_config.mono_chrome) {
fg_params->chroma_scaling_from_luma = 0;
} else {
fg_params->chroma_scaling_from_luma = AV1_READ_BIT_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
if (seq_header->color_config.mono_chrome
|| fg_params->chroma_scaling_from_luma
|| (seq_header->color_config.subsampling_x == 1
&& seq_header->color_config.subsampling_y == 1
&& fg_params->num_y_points == 0)) {
fg_params->num_cb_points = 0;
fg_params->num_cr_points = 0;
} else {
fg_params->num_cb_points = AV1_READ_BITS_CHECKED (br, 4, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
for (i = 0; i < fg_params->num_cb_points; i++) {
if (AV1_REMAINING_BITS (br) < 8 + 8) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->point_cb_value[i] = AV1_READ_UINT8 (br);
fg_params->point_cb_scaling[i] = AV1_READ_UINT8 (br);
}
fg_params->num_cr_points = AV1_READ_BITS_CHECKED (br, 4, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
for (i = 0; i < fg_params->num_cr_points; i++) {
if (AV1_REMAINING_BITS (br) < 8 + 8) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->point_cr_value[i] = AV1_READ_UINT8 (br);
fg_params->point_cr_scaling[i] = AV1_READ_UINT8 (br);
}
}
fg_params->grain_scaling_minus_8 = AV1_READ_BITS_CHECKED (br, 2, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
fg_params->ar_coeff_lag = AV1_READ_BITS_CHECKED (br, 2, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
num_pos_luma = 2 * fg_params->ar_coeff_lag * (fg_params->ar_coeff_lag + 1);
if (fg_params->num_y_points) {
num_pos_chroma = num_pos_luma + 1;
for (i = 0; i < num_pos_luma; i++) {
fg_params->ar_coeffs_y_plus_128[i] = AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
} else {
num_pos_chroma = num_pos_luma;
}
if (fg_params->chroma_scaling_from_luma || fg_params->num_cb_points) {
for (i = 0; i < num_pos_chroma; i++) {
fg_params->ar_coeffs_cb_plus_128[i] = AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
}
if (fg_params->chroma_scaling_from_luma || fg_params->num_cr_points) {
for (i = 0; i < num_pos_chroma; i++) {
fg_params->ar_coeffs_cr_plus_128[i] = AV1_READ_UINT8_CHECKED (br, &ret);
if (ret != GST_AV1_PARSER_OK)
goto error;
}
}
if (AV1_REMAINING_BITS (br) < 2 + 2) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->ar_coeff_shift_minus_6 = AV1_READ_BITS (br, 2);
fg_params->grain_scale_shift = AV1_READ_BITS (br, 2);
if (fg_params->num_cb_points) {
if (AV1_REMAINING_BITS (br) < 8 + 8 + 9) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->cb_mult = AV1_READ_BITS (br, 8);
fg_params->cb_luma_mult = AV1_READ_BITS (br, 8);
fg_params->cb_offset = AV1_READ_BITS (br, 9);
}
if (fg_params->num_cr_points) {
if (AV1_REMAINING_BITS (br) < 8 + 8 + 9) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->cr_mult = AV1_READ_BITS (br, 8);
fg_params->cr_luma_mult = AV1_READ_BITS (br, 8);
fg_params->cr_offset = AV1_READ_BITS (br, 9);
}
if (AV1_REMAINING_BITS (br) < 2) {
ret = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
fg_params->overlap_flag = AV1_READ_BIT (br);
fg_params->clip_to_restricted_range = AV1_READ_BIT (br);
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse film grain params error %d", ret);
return ret;
}
/* 5.9.4 */
static void
gst_av1_mark_ref_frames (GstAV1Parser * parser, GstBitReader * br, gint idLen)
{
GstAV1ReferenceFrameInfo *ref_info;
GstAV1SequenceHeaderOBU *seq_header;
gint i, diff_len /* diffLen */ ;
seq_header = parser->seq_header;
ref_info = &(parser->state.ref_info);
diff_len = seq_header->delta_frame_id_length_minus_2 + 2;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
if (parser->state.current_frame_id > (1 << diff_len)) {
if (ref_info->entry[i].ref_frame_id > parser->state.current_frame_id
|| ref_info->entry[i].ref_frame_id <
(parser->state.current_frame_id - (1 << diff_len)))
ref_info->entry[i].ref_valid = 0;
} else {
if (ref_info->entry[i].ref_frame_id > parser->state.current_frame_id
&& ref_info->entry[i].ref_frame_id <
((1 << idLen) + parser->state.current_frame_id - (1 << diff_len)))
ref_info->entry[i].ref_valid = 0;
}
}
}
/* 5.11.14 */
static gboolean
gst_av1_seg_feature_active_idx (GstAV1Parser * parser,
GstAV1FrameHeaderOBU * frame_header, gint idx, gint feature)
{
return frame_header->segmentation_params.segmentation_enabled
&& frame_header->segmentation_params.feature_enabled[idx][feature];
}
/* 7.12.2 */
static gint
gst_av1_get_qindex (GstAV1Parser * parser,
GstAV1FrameHeaderOBU * frame_header, gboolean ignoreDeltaQ, gint segmentId)
{
gint qindex;
if (gst_av1_seg_feature_active_idx (parser, frame_header, segmentId,
GST_AV1_SEG_LVL_ALT_Q)) {
gint data =
frame_header->
segmentation_params.feature_data[segmentId][GST_AV1_SEG_LVL_ALT_Q];
qindex = frame_header->quantization_params.base_q_idx + data;
if (ignoreDeltaQ == 0 && frame_header->quantization_params.delta_q_present)
qindex = qindex + frame_header->quantization_params.delta_q_res;
return CLAMP (qindex, 0, 255);
} else
return frame_header->quantization_params.base_q_idx;
}
/* 7.8 */
static void
gst_av1_set_frame_refs (GstAV1Parser * parser,
GstAV1SequenceHeaderOBU * seq_header, GstAV1FrameHeaderOBU * frame_header)
{
const GstAV1ReferenceFrame ref_frame_list[GST_AV1_REFS_PER_FRAME - 2] = {
GST_AV1_REF_LAST2_FRAME,
GST_AV1_REF_LAST3_FRAME,
GST_AV1_REF_BWDREF_FRAME,
GST_AV1_REF_ALTREF2_FRAME,
GST_AV1_REF_ALTREF_FRAME
};
gboolean used_frame[GST_AV1_NUM_REF_FRAMES];
gint shifted_order_hints[GST_AV1_NUM_REF_FRAMES];
gint cur_frame_hint = 1 << (seq_header->order_hint_bits - 1);
gint last_order_hint, earliest_order_hint;
gint ref, hint;
gint i, j;
g_assert (seq_header->enable_order_hint);
g_assert (seq_header->order_hint_bits_minus_1 >= 0);
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
frame_header->ref_frame_idx[i] = -1;
frame_header->ref_frame_idx[GST_AV1_REF_LAST_FRAME -
GST_AV1_REF_LAST_FRAME] = frame_header->last_frame_idx;
frame_header->ref_frame_idx[GST_AV1_REF_GOLDEN_FRAME -
GST_AV1_REF_LAST_FRAME] = frame_header->gold_frame_idx;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++)
used_frame[i] = 0;
used_frame[frame_header->last_frame_idx] = 1;
used_frame[frame_header->gold_frame_idx] = 1;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++)
shifted_order_hints[i] = cur_frame_hint +
gst_av1_get_relative_dist (seq_header,
parser->state.ref_info.entry[i].ref_order_hint,
frame_header->order_hint);
last_order_hint = shifted_order_hints[frame_header->last_frame_idx];
earliest_order_hint = shifted_order_hints[frame_header->gold_frame_idx];
/* === Backward Reference Frames === */
/* The ALTREF_FRAME reference is set to be a backward
reference to the frame with highest output order. */
ref = -1;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
hint = shifted_order_hints[i];
if (!used_frame[i] && hint >= cur_frame_hint
&& (ref < 0 || hint >= last_order_hint)) {
ref = i;
last_order_hint = hint;
}
}
if (ref >= 0) {
frame_header->ref_frame_idx[GST_AV1_REF_ALTREF_FRAME -
GST_AV1_REF_LAST_FRAME] = ref;
used_frame[ref] = 1;
}
/* The BWDREF_FRAME reference is set to be a backward reference
to the closest frame. */
ref = -1;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
hint = shifted_order_hints[i];
if (!used_frame[i] && hint >= cur_frame_hint
&& (ref < 0 || hint < earliest_order_hint)) {
ref = i;
earliest_order_hint = hint;
}
}
if (ref >= 0) {
frame_header->ref_frame_idx[GST_AV1_REF_BWDREF_FRAME -
GST_AV1_REF_LAST_FRAME] = ref;
used_frame[ref] = 1;
}
/* The ALTREF2_FRAME reference is set to the next closest
backward reference. */
ref = -1;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
hint = shifted_order_hints[i];
if (!used_frame[i] && hint >= cur_frame_hint
&& (ref < 0 || hint < earliest_order_hint)) {
ref = i;
earliest_order_hint = hint;
}
}
if (ref >= 0) {
frame_header->ref_frame_idx[GST_AV1_REF_ALTREF2_FRAME -
GST_AV1_REF_LAST_FRAME] = ref;
used_frame[ref] = 1;
}
/* === Forward Reference Frames === */
/* The remaining references are set to be forward references
in anti-chronological order. */
for (i = 0; i < GST_AV1_REFS_PER_FRAME - 2; i++) {
GstAV1ReferenceFrame ref_frame = ref_frame_list[i];
if (frame_header->ref_frame_idx[ref_frame - GST_AV1_REF_LAST_FRAME] < 0) {
ref = -1;
for (j = 0; j < GST_AV1_NUM_REF_FRAMES; j++) {
hint = shifted_order_hints[j];
if (!used_frame[j] && hint < cur_frame_hint &&
(ref < 0 || hint >= last_order_hint)) {
ref = j;
last_order_hint = hint;
}
}
if (ref >= 0) {
frame_header->ref_frame_idx[ref_frame - GST_AV1_REF_LAST_FRAME] = ref;
used_frame[ref] = 1;
}
}
}
/* Finally, any remaining references are set to the reference frame
with smallest output order. */
ref = -1;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
hint = shifted_order_hints[i];
if (ref < 0 || hint < earliest_order_hint) {
ref = i;
earliest_order_hint = hint;
}
}
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
if (frame_header->ref_frame_idx[i] < 0)
frame_header->ref_frame_idx[i] = ref;
}
/* 7.21 */
static void
gst_av1_parser_reference_frame_loading (GstAV1Parser * parser,
GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ReferenceFrameInfo *ref_info = &(parser->state.ref_info);
gint idx = frame_header->frame_to_show_map_idx;
GstAV1TileInfo *ref_tile_info = &ref_info->entry[idx].ref_tile_info;
const gint all_frames = (1 << GST_AV1_NUM_REF_FRAMES) - 1;
/* copy the relevant frame information as these will be needed by
* all subclasses. */
frame_header->frame_type = ref_info->entry[idx].ref_frame_type;
frame_header->upscaled_width = ref_info->entry[idx].ref_upscaled_width;
frame_header->frame_width = ref_info->entry[idx].ref_frame_width;
frame_header->frame_height = ref_info->entry[idx].ref_frame_height;
frame_header->render_width = ref_info->entry[idx].ref_render_width;
frame_header->render_height = ref_info->entry[idx].ref_render_height;
if (parser->seq_header->film_grain_params_present)
frame_header->film_grain_params =
ref_info->entry[idx].ref_film_grain_params;
/* the remaining is only relevant to ensure proper state update and only
* keyframe updates the state. */
if (frame_header->frame_type != GST_AV1_KEY_FRAME)
return;
frame_header->refresh_frame_flags = all_frames;
frame_header->current_frame_id = ref_info->entry[idx].ref_frame_id;
frame_header->order_hint = ref_info->entry[idx].ref_order_hint;
frame_header->segmentation_params =
ref_info->entry[idx].ref_segmentation_params;
frame_header->global_motion_params =
ref_info->entry[idx].ref_global_motion_params;
frame_header->loop_filter_params = ref_info->entry[idx].ref_lf_params;
frame_header->tile_info = *ref_tile_info;
parser->state.current_frame_id = ref_info->entry[idx].ref_frame_id;
parser->state.upscaled_width = ref_info->entry[idx].ref_upscaled_width;
parser->state.frame_width = ref_info->entry[idx].ref_frame_width;
parser->state.frame_height = ref_info->entry[idx].ref_frame_height;
parser->state.render_width = ref_info->entry[idx].ref_render_width;
parser->state.render_height = ref_info->entry[idx].ref_render_height;
parser->state.mi_cols = ref_info->entry[idx].ref_mi_cols;
parser->state.mi_rows = ref_info->entry[idx].ref_mi_rows;
memcpy (parser->state.mi_col_starts, ref_tile_info->mi_col_starts,
sizeof (guint32) * (GST_AV1_MAX_TILE_COLS + 1));
memcpy (parser->state.mi_row_starts, ref_tile_info->mi_row_starts,
sizeof (guint32) * (GST_AV1_MAX_TILE_ROWS + 1));
parser->state.tile_cols_log2 = ref_tile_info->tile_cols_log2;
parser->state.tile_cols = ref_tile_info->tile_cols;
parser->state.tile_rows_log2 = ref_tile_info->tile_rows_log2;
parser->state.tile_rows = ref_tile_info->tile_rows;
parser->state.tile_size_bytes = ref_tile_info->tile_size_bytes;
}
/* 5.9.2 */
static GstAV1ParserResult
gst_av1_parse_uncompressed_frame_header (GstAV1Parser * parser, GstAV1OBU * obu,
GstBitReader * br, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
GstAV1ReferenceFrameInfo *ref_info;
GstAV1SequenceHeaderOBU *seq_header;
gint i, op_num /* opNum */ ;
gint segment_id /* segmentId */ , all_frames /* allFrames */ ;
gint id_len /* idLen */ = 0;
if (!parser->seq_header) {
GST_WARNING ("Missing OBU Reference: seq_header");
retval = GST_AV1_PARSER_MISSING_OBU_REFERENCE;
goto error;
}
seq_header = parser->seq_header;
ref_info = &(parser->state.ref_info);
if (seq_header->frame_id_numbers_present_flag)
id_len = seq_header->additional_frame_id_length_minus_1 + 1 +
seq_header->delta_frame_id_length_minus_2 + 2;
all_frames = (1 << GST_AV1_NUM_REF_FRAMES) - 1;
if (seq_header->reduced_still_picture_header) {
frame_header->show_existing_frame = 0;
frame_header->frame_type = GST_AV1_KEY_FRAME;
frame_header->frame_is_intra = 1;
frame_header->show_frame = 1;
frame_header->showable_frame = 0;
if (parser->state.sequence_changed) {
/* This is the start of a new coded video sequence. */
parser->state.sequence_changed = 0;
parser->state.begin_first_frame = 1;
}
} else {
frame_header->show_existing_frame = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->show_existing_frame) {
if (parser->state.sequence_changed) {
GST_INFO ("New sequence header starts with a show_existing_frame.");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
frame_header->frame_to_show_map_idx =
AV1_READ_BITS_CHECKED (br, 3, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (!ref_info->entry[frame_header->frame_to_show_map_idx].ref_valid) {
GST_INFO ("The frame_to_show %d is invalid.",
frame_header->frame_to_show_map_idx);
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (seq_header->decoder_model_info_present_flag
&& !seq_header->timing_info.equal_picture_interval)
frame_header->frame_presentation_time =
AV1_READ_BITS_CHECKED (br,
seq_header->
decoder_model_info.frame_presentation_time_length_minus_1 + 1,
&retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
frame_header->refresh_frame_flags = 0;
if (seq_header->frame_id_numbers_present_flag) {
g_assert (id_len > 0);
frame_header->display_frame_id =
AV1_READ_BITS_CHECKED (br, id_len, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->display_frame_id !=
ref_info->entry[frame_header->frame_to_show_map_idx].ref_frame_id) {
GST_INFO ("Reference frame ID mismatch");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
gst_av1_parser_reference_frame_loading (parser, frame_header);
goto success;
}
frame_header->frame_type = AV1_READ_BITS_CHECKED (br, 2, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (parser->state.sequence_changed) {
if (frame_header->frame_type == GST_AV1_KEY_FRAME) {
/* This is the start of a new coded video sequence. */
parser->state.sequence_changed = FALSE;
parser->state.begin_first_frame = TRUE;
} else {
GST_INFO ("Sequence header has changed without a keyframe.");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
frame_header->frame_is_intra =
(frame_header->frame_type == GST_AV1_INTRA_ONLY_FRAME
|| frame_header->frame_type == GST_AV1_KEY_FRAME);
frame_header->show_frame = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->still_picture &&
(frame_header->frame_type != GST_AV1_KEY_FRAME
|| !frame_header->show_frame)) {
GST_INFO ("Still pictures must be coded as shown keyframes");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (frame_header->show_frame
&& seq_header->decoder_model_info_present_flag
&& !seq_header->timing_info.equal_picture_interval) {
frame_header->frame_presentation_time =
AV1_READ_BITS_CHECKED (br,
seq_header->decoder_model_info.
frame_presentation_time_length_minus_1 + 1, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (frame_header->show_frame) {
frame_header->showable_frame =
(frame_header->frame_type != GST_AV1_KEY_FRAME);
} else {
frame_header->showable_frame = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (frame_header->frame_type == GST_AV1_SWITCH_FRAME
|| (frame_header->frame_type == GST_AV1_KEY_FRAME
&& frame_header->show_frame))
frame_header->error_resilient_mode = 1;
else {
frame_header->error_resilient_mode = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
}
if (frame_header->frame_type == GST_AV1_KEY_FRAME && frame_header->show_frame) {
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
ref_info->entry[i].ref_valid = 0;
ref_info->entry[i].ref_order_hint = 0;
}
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
frame_header->order_hints[GST_AV1_REF_LAST_FRAME + i] = 0;
}
}
frame_header->disable_cdf_update = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (seq_header->seq_force_screen_content_tools ==
GST_AV1_SELECT_SCREEN_CONTENT_TOOLS) {
frame_header->allow_screen_content_tools =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
frame_header->allow_screen_content_tools =
seq_header->seq_force_screen_content_tools;
}
if (frame_header->allow_screen_content_tools) {
if (seq_header->seq_force_integer_mv == GST_AV1_SELECT_INTEGER_MV) {
frame_header->force_integer_mv = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
frame_header->force_integer_mv = seq_header->seq_force_integer_mv;
}
} else {
frame_header->force_integer_mv = 0;
}
if (frame_header->frame_is_intra) {
frame_header->force_integer_mv = 1;
}
if (seq_header->frame_id_numbers_present_flag) {
gboolean have_prev_frame_id =
!parser->state.begin_first_frame &&
(!(frame_header->frame_type == GST_AV1_KEY_FRAME
&& frame_header->show_frame));
if (have_prev_frame_id)
parser->state.prev_frame_id = parser->state.current_frame_id;
g_assert (id_len > 0);
frame_header->current_frame_id =
AV1_READ_BITS_CHECKED (br, id_len, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
parser->state.current_frame_id = frame_header->current_frame_id;
/* Check whether the id and id diff is valid */
if (have_prev_frame_id) {
gint32 diff_frame_id;
if (parser->state.current_frame_id > parser->state.prev_frame_id) {
diff_frame_id =
parser->state.current_frame_id - parser->state.prev_frame_id;
} else {
diff_frame_id = (1 << id_len) +
parser->state.current_frame_id - parser->state.prev_frame_id;
}
if (parser->state.current_frame_id == parser->state.prev_frame_id ||
diff_frame_id >= (1 << (id_len - 1))) {
GST_INFO ("Invalid value of current_frame_id");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
gst_av1_mark_ref_frames (parser, br, id_len);
} else {
frame_header->current_frame_id = 0;
parser->state.prev_frame_id = parser->state.current_frame_id;
parser->state.current_frame_id = frame_header->current_frame_id;
}
if (frame_header->frame_type == GST_AV1_SWITCH_FRAME) {
frame_header->frame_size_override_flag = 1;
} else if (seq_header->reduced_still_picture_header) {
frame_header->frame_size_override_flag = 0;
} else {
frame_header->frame_size_override_flag = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
frame_header->order_hint =
AV1_READ_BITS_CHECKED (br, seq_header->order_hint_bits_minus_1 + 1,
&retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->frame_is_intra || frame_header->error_resilient_mode) {
frame_header->primary_ref_frame = GST_AV1_PRIMARY_REF_NONE;
} else {
frame_header->primary_ref_frame = AV1_READ_BITS_CHECKED (br, 3, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (seq_header->decoder_model_info_present_flag) {
frame_header->buffer_removal_time_present_flag =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->buffer_removal_time_present_flag) {
for (op_num = 0; op_num <= seq_header->operating_points_cnt_minus_1;
op_num++) {
if (seq_header->
operating_points[op_num].decoder_model_present_for_this_op) {
gint op_pt_idc = seq_header->operating_points[op_num].idc;
gint in_temporal_layer =
(op_pt_idc >> obu->header.obu_temporal_id) & 1;
gint in_spatial_layer =
(op_pt_idc >> (obu->header.obu_spatial_id + 8)) & 1;
if (op_pt_idc == 0 || (in_temporal_layer && in_spatial_layer)) {
frame_header->buffer_removal_time[op_num] =
AV1_READ_BITS_CHECKED (br,
seq_header->decoder_model_info.
buffer_removal_time_length_minus_1 + 1, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
frame_header->buffer_removal_time[op_num] = 0;
}
} else {
frame_header->buffer_removal_time[op_num] = 0;
}
}
}
}
frame_header->allow_high_precision_mv = 0;
frame_header->use_ref_frame_mvs = 0;
frame_header->allow_intrabc = 0;
if (frame_header->frame_type == GST_AV1_SWITCH_FRAME ||
(frame_header->frame_type == GST_AV1_KEY_FRAME
&& frame_header->show_frame)) {
frame_header->refresh_frame_flags = all_frames;
} else {
frame_header->refresh_frame_flags = AV1_READ_UINT8_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (frame_header->frame_type == GST_AV1_INTRA_ONLY_FRAME) {
if (frame_header->refresh_frame_flags == 0xFF) {
GST_INFO ("Intra only frames cannot have refresh flags 0xFF");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
}
if (!frame_header->frame_is_intra
|| frame_header->refresh_frame_flags != all_frames) {
if (frame_header->error_resilient_mode && seq_header->enable_order_hint) {
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
frame_header->ref_order_hint[i] = AV1_READ_BITS_CHECKED (br,
seq_header->order_hint_bits_minus_1 + 1, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->ref_order_hint[i] !=
ref_info->entry[i].ref_order_hint)
ref_info->entry[i].ref_valid = 0;
}
}
}
if (frame_header->frame_is_intra) {
retval = gst_av1_parse_frame_size (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_render_size (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->allow_screen_content_tools
&& parser->state.upscaled_width == parser->state.frame_width) {
frame_header->allow_intrabc = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
frame_header->upscaled_width = parser->state.upscaled_width;
frame_header->frame_width = parser->state.frame_width;
frame_header->frame_height = parser->state.frame_height;
frame_header->render_width = parser->state.render_width;
frame_header->render_height = parser->state.render_height;
} else {
if (!seq_header->enable_order_hint) {
frame_header->frame_refs_short_signaling = 0;
} else {
frame_header->frame_refs_short_signaling =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->frame_refs_short_signaling) {
if (AV1_REMAINING_BITS (br) < 3 + 3) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
frame_header->last_frame_idx = AV1_READ_BITS (br, 3);
frame_header->gold_frame_idx = AV1_READ_BITS (br, 3);
gst_av1_set_frame_refs (parser, seq_header, frame_header);
}
}
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
if (!frame_header->frame_refs_short_signaling) {
frame_header->ref_frame_idx[i] = AV1_READ_BITS_CHECKED (br, 3, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (seq_header->frame_id_numbers_present_flag) {
gint32 delta_frame_id /* DeltaFrameId */ ;
gint32 expected_frame_id;
guint32 delta_frame_id_minus_1;
g_assert (id_len > 0);
delta_frame_id_minus_1 = AV1_READ_BITS_CHECKED (br,
seq_header->delta_frame_id_length_minus_2 + 2, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
delta_frame_id = delta_frame_id_minus_1 + 1;
expected_frame_id = (frame_header->current_frame_id + (1 << id_len) -
delta_frame_id) % (1 << id_len);
if (expected_frame_id !=
parser->state.ref_info.entry[frame_header->
ref_frame_idx[i]].ref_frame_id) {
GST_DEBUG ("Reference buffer frame ID mismatch, expectedFrameId"
" is %d while ref frame id is %d", expected_frame_id,
parser->state.ref_info.entry[frame_header->
ref_frame_idx[i]].ref_frame_id);
}
}
}
if (frame_header->frame_size_override_flag
&& !frame_header->error_resilient_mode) {
retval = gst_av1_parse_frame_size_with_refs (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
} else {
retval = gst_av1_parse_frame_size (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_render_size (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
frame_header->upscaled_width = parser->state.upscaled_width;
frame_header->frame_width = parser->state.frame_width;
frame_header->frame_height = parser->state.frame_height;
frame_header->render_width = parser->state.render_width;
frame_header->render_height = parser->state.render_height;
if (frame_header->force_integer_mv) {
frame_header->allow_high_precision_mv = 0;
} else {
frame_header->allow_high_precision_mv =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
/* read_interpolation_filter() expand */
frame_header->is_filter_switchable = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->is_filter_switchable) {
frame_header->interpolation_filter =
GST_AV1_INTERPOLATION_FILTER_SWITCHABLE;
} else {
frame_header->interpolation_filter =
AV1_READ_BITS_CHECKED (br, 2, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
frame_header->is_motion_mode_switchable =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->error_resilient_mode || !seq_header->enable_ref_frame_mvs) {
frame_header->use_ref_frame_mvs = 0;
} else {
frame_header->use_ref_frame_mvs = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
}
if (!frame_header->frame_is_intra) {
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
gint refFrame = GST_AV1_REF_LAST_FRAME + i;
gint hint =
ref_info->entry[frame_header->ref_frame_idx[i]].ref_order_hint;
frame_header->order_hints[refFrame] = hint;
if (!seq_header->enable_order_hint) {
frame_header->ref_frame_sign_bias[refFrame] = 0;
} else {
frame_header->ref_frame_sign_bias[refFrame] =
(gst_av1_get_relative_dist (parser->seq_header, hint,
frame_header->order_hint) > 0);
}
}
}
if (seq_header->reduced_still_picture_header
|| frame_header->disable_cdf_update)
frame_header->disable_frame_end_update_cdf = 1;
else {
frame_header->disable_frame_end_update_cdf =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE &&
!ref_info->entry[frame_header->ref_frame_idx[frame_header->
primary_ref_frame]].ref_valid) {
GST_INFO ("Primary ref point to an invalid frame");
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
if (frame_header->primary_ref_frame == GST_AV1_PRIMARY_REF_NONE) {
/* do something in setup_past_independence() of parser level */
gint8 *loop_filter_ref_deltas =
frame_header->loop_filter_params.loop_filter_ref_deltas;
frame_header->loop_filter_params.loop_filter_delta_enabled = 1;
loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME] = 1;
loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME] = 0;
loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME] = 0;
loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME] = 0;
loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME] = 0;
loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME] = -1;
loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME] = -1;
loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME] = -1;
frame_header->loop_filter_params.loop_filter_mode_deltas[0] = 0;
frame_header->loop_filter_params.loop_filter_mode_deltas[1] = 0;
} else {
/* do something in load_previous() of parser level */
/* load_loop_filter_params() */
GstAV1LoopFilterParams *ref_lf_params =
&parser->state.ref_info.entry[frame_header->
ref_frame_idx[frame_header->primary_ref_frame]].ref_lf_params;
gint8 *loop_filter_ref_deltas =
frame_header->loop_filter_params.loop_filter_ref_deltas;
/* Copy all from prime_ref */
g_assert (parser->state.ref_info.
entry[frame_header->ref_frame_idx[frame_header->primary_ref_frame]].
ref_valid);
loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_INTRA_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST2_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_LAST3_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_BWDREF_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_GOLDEN_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF2_FRAME];
loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME] =
ref_lf_params->loop_filter_ref_deltas[GST_AV1_REF_ALTREF_FRAME];
for (i = 0; i < 2; i++)
frame_header->loop_filter_params.loop_filter_mode_deltas[i] =
ref_lf_params->loop_filter_mode_deltas[i];
}
/* @TODO:
if ( primary_ref_frame == PRIMARY_REF_NONE ) {
init_non_coeff_cdfs( )
} else {
load_cdfs( ref_frame_idx[primary_ref_frame] )
}
*/
/* @TODO:
if ( use_ref_frame_mvs == 1 )
motion_field_estimation( )
*/
retval = gst_av1_parse_tile_info (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_quantization_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_segmentation_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_delta_q_params (parser, br,
&(frame_header->quantization_params));
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_delta_lf_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
/* @TODO:
if ( primary_ref_frame == PRIMARY_REF_NONE ) {
init_coeff_cdfs( )
} else {
load_previous_segment_ids( )
}
*/
frame_header->coded_lossless = 1;
for (segment_id = 0; segment_id < GST_AV1_MAX_SEGMENTS; segment_id++) {
gint qindex = gst_av1_get_qindex (parser, frame_header, 1, segment_id);
frame_header->lossless_array[segment_id] = (qindex == 0)
&& (frame_header->quantization_params.delta_q_y_dc == 0)
&& (frame_header->quantization_params.delta_q_u_ac == 0)
&& (frame_header->quantization_params.delta_q_u_dc == 0)
&& (frame_header->quantization_params.delta_q_v_ac == 0)
&& (frame_header->quantization_params.delta_q_v_dc == 0);
if (!frame_header->lossless_array[segment_id])
frame_header->coded_lossless = 0;
if (frame_header->quantization_params.using_qmatrix) {
if (frame_header->lossless_array[segment_id]) {
frame_header->seg_qm_Level[0][segment_id] = 15;
frame_header->seg_qm_Level[1][segment_id] = 15;
frame_header->seg_qm_Level[2][segment_id] = 15;
} else {
frame_header->seg_qm_Level[0][segment_id] =
frame_header->quantization_params.qm_y;
frame_header->seg_qm_Level[1][segment_id] =
frame_header->quantization_params.qm_u;
frame_header->seg_qm_Level[2][segment_id] =
frame_header->quantization_params.qm_v;
}
}
}
frame_header->all_lossless = frame_header->coded_lossless
&& (parser->state.frame_width == parser->state.upscaled_width);
retval = gst_av1_parse_loop_filter_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_cdef_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_loop_restoration_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_tx_mode (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
/* 5.9.23 inlined frame_reference_mode () */
if (frame_header->frame_is_intra) {
frame_header->reference_select = 0;
} else {
frame_header->reference_select = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
retval = gst_av1_parse_skip_mode_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
if (frame_header->frame_is_intra ||
frame_header->error_resilient_mode || !seq_header->enable_warped_motion)
frame_header->allow_warped_motion = 0;
else {
frame_header->allow_warped_motion = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
frame_header->reduced_tx_set = AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_global_motion_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
retval = gst_av1_parse_film_grain_params (parser, br, frame_header);
if (retval != GST_AV1_PARSER_OK)
goto error;
success:
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse uncompressed frame header error %d", retval);
return retval;
}
/**
* gst_av1_parser_reference_frame_update:
* @parser: the #GstAV1Parser
* @frame_header: a #GstAV1FrameHeaderOBU to load
*
* Update the context of @frame_header to parser's state. This function is
* used when we finish one frame's decoding/showing, and need to update info
* such as reference, global parameters.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_reference_frame_update (GstAV1Parser * parser,
GstAV1FrameHeaderOBU * frame_header)
{
gint i;
GstAV1SequenceHeaderOBU *seq_header;
GstAV1ReferenceFrameInfo *ref_info;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (frame_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
if (!parser->seq_header) {
GST_WARNING ("Missing OBU Reference: seq_header");
return GST_AV1_PARSER_MISSING_OBU_REFERENCE;
}
seq_header = parser->seq_header;
ref_info = &(parser->state.ref_info);
if (frame_header->frame_type == GST_AV1_INTRA_ONLY_FRAME
&& frame_header->refresh_frame_flags == 0xff)
return GST_AV1_PARSER_BITSTREAM_ERROR;
for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++) {
if ((frame_header->refresh_frame_flags >> i) & 1) {
ref_info->entry[i].ref_valid = 1;
ref_info->entry[i].ref_frame_id = frame_header->current_frame_id;
ref_info->entry[i].ref_frame_type = frame_header->frame_type;
ref_info->entry[i].ref_upscaled_width = frame_header->upscaled_width;
ref_info->entry[i].ref_frame_width = frame_header->frame_width;
ref_info->entry[i].ref_frame_height = frame_header->frame_height;
ref_info->entry[i].ref_render_width = frame_header->render_width;
ref_info->entry[i].ref_render_height = frame_header->render_height;
ref_info->entry[i].ref_order_hint = frame_header->order_hint;
ref_info->entry[i].ref_mi_cols = parser->state.mi_cols;
ref_info->entry[i].ref_mi_rows = parser->state.mi_rows;
ref_info->entry[i].ref_subsampling_x =
seq_header->color_config.subsampling_x;
ref_info->entry[i].ref_subsampling_y =
seq_header->color_config.subsampling_y;
ref_info->entry[i].ref_bit_depth = seq_header->bit_depth;
ref_info->entry[i].ref_segmentation_params =
frame_header->segmentation_params;
ref_info->entry[i].ref_global_motion_params =
frame_header->global_motion_params;
ref_info->entry[i].ref_lf_params = frame_header->loop_filter_params;
ref_info->entry[i].ref_tile_info = frame_header->tile_info;
if (seq_header->film_grain_params_present)
ref_info->entry[i].ref_film_grain_params =
frame_header->film_grain_params;
}
}
return GST_AV1_PARSER_OK;
}
/* 5.12.1 */
/**
* gst_av1_parser_parse_tile_list_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
* @tile_list: a #GstAV1TileListOBU to store the parsed result.
*
* Parse one tile list @obu based on the @parser context, store the result
* in the @tile_list. It is for large scale tile coding mode.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_tile_list_obu (GstAV1Parser * parser,
GstAV1OBU * obu, GstAV1TileListOBU * tile_list)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
GstBitReader *br;
GstBitReader bitreader;
gint tile;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_TILE_LIST,
GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (tile_list != NULL, GST_AV1_PARSER_INVALID_OPERATION);
br = &bitreader;
memset (tile_list, 0, sizeof (*tile_list));
gst_bit_reader_init (br, obu->data, obu->obu_size);
if (AV1_REMAINING_BITS (br) < 8 + 8 + 16) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
tile_list->output_frame_width_in_tiles_minus_1 = AV1_READ_BITS (br, 8);
tile_list->output_frame_height_in_tiles_minus_1 = AV1_READ_BITS (br, 8);
tile_list->tile_count_minus_1 = AV1_READ_BITS (br, 16);
if (tile_list->tile_count_minus_1 + 1 > GST_AV1_MAX_TILE_COUNT) {
GST_WARNING ("Invalid tile_count_minus_1 %d",
tile_list->tile_count_minus_1);
retval = GST_AV1_PARSER_BITSTREAM_ERROR;
goto error;
}
for (tile = 0; tile <= tile_list->tile_count_minus_1; tile++) {
if (AV1_REMAINING_BITS (br) < 8 + 8 + 8 + 16) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
tile_list->entry[tile].anchor_frame_idx = AV1_READ_BITS (br, 8);
tile_list->entry[tile].anchor_tile_row = AV1_READ_BITS (br, 8);
tile_list->entry[tile].anchor_tile_col = AV1_READ_BITS (br, 8);
tile_list->entry[tile].tile_data_size_minus_1 = AV1_READ_BITS (br, 16);
g_assert (gst_bit_reader_get_pos (br) % 8 == 0);
tile_list->entry[tile].coded_tile_data =
obu->data + gst_bit_reader_get_pos (br) / 8;
/* skip the coded_tile_data */
if (!gst_bit_reader_skip (br,
tile_list->entry[tile].tile_data_size_minus_1 + 1)) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
}
retval = av1_skip_trailing_bits (parser, br, obu);
if (retval != GST_AV1_PARSER_OK)
goto error;
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse tile list error %d", retval);
return retval;
}
/* 5.11.1 */
static GstAV1ParserResult
gst_av1_parse_tile_group (GstAV1Parser * parser, GstBitReader * br,
GstAV1TileGroupOBU * tile_group)
{
GstAV1ParserResult retval = GST_AV1_PARSER_OK;
gint tile_num /* TileNum */ , end_bit_pos /* endBitPos */ ;
gint header_bytes /* headerBytes */ , start_bitpos /* startBitPos */ ;
guint32 sz = AV1_REMAINING_BYTES (br);
guint32 tile_row /* tileRow */ ;
guint32 tile_col /* tileCol */ ;
guint32 tile_size /* tileSize */ ;
memset (tile_group, 0, sizeof (*tile_group));
tile_group->num_tiles = parser->state.tile_cols * parser->state.tile_rows;
start_bitpos = gst_bit_reader_get_pos (br);
tile_group->tile_start_and_end_present_flag = 0;
if (tile_group->num_tiles > 1) {
tile_group->tile_start_and_end_present_flag =
AV1_READ_BIT_CHECKED (br, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (tile_group->num_tiles == 1
|| !tile_group->tile_start_and_end_present_flag) {
tile_group->tg_start = 0;
tile_group->tg_end = tile_group->num_tiles - 1;
} else {
gint tileBits = parser->state.tile_cols_log2 + parser->state.tile_rows_log2;
tile_group->tg_start = AV1_READ_BITS_CHECKED (br, tileBits, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
tile_group->tg_end = AV1_READ_BITS_CHECKED (br, tileBits, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
}
if (tile_group->tg_end < tile_group->tg_start) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
if (!gst_bit_reader_skip_to_byte (br)) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
end_bit_pos = gst_bit_reader_get_pos (br);
header_bytes = (end_bit_pos - start_bitpos) / 8;
sz -= header_bytes;
for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end;
tile_num++) {
tile_row = tile_num / parser->state.tile_cols;
tile_col = tile_num % parser->state.tile_cols;
/* if last tile */
if (tile_num == tile_group->tg_end) {
tile_size = sz;
} else {
gint tile_size_minus_1 = av1_bitstreamfn_le (br,
parser->state.tile_size_bytes, &retval);
if (retval != GST_AV1_PARSER_OK)
goto error;
tile_size = tile_size_minus_1 + 1;
sz -= (tile_size + parser->state.tile_size_bytes);
}
tile_group->entry[tile_num].tile_size = tile_size;
tile_group->entry[tile_num].tile_offset = gst_bit_reader_get_pos (br) / 8;
tile_group->entry[tile_num].tile_row = tile_row;
tile_group->entry[tile_num].tile_col = tile_col;
tile_group->entry[tile_num].mi_row_start =
parser->state.mi_row_starts[tile_row];
tile_group->entry[tile_num].mi_row_end =
parser->state.mi_row_starts[tile_row + 1];
tile_group->entry[tile_num].mi_col_start =
parser->state.mi_col_starts[tile_col];
tile_group->entry[tile_num].mi_col_end =
parser->state.mi_col_starts[tile_col + 1];
/* Not implement here, the real decoder process
init_symbol( tileSize )
decode_tile( )
exit_symbol( )
*/
/* Skip the real data to the next one */
if (tile_num < tile_group->tg_end &&
!gst_bit_reader_skip (br, tile_size * 8)) {
retval = GST_AV1_PARSER_NO_MORE_DATA;
goto error;
}
}
if (tile_group->tg_end == tile_group->num_tiles - 1) {
/* Not implement here, the real decoder process
if ( !disable_frame_end_update_cdf ) {
frame_end_update_cdf( )
}
decode_frame_wrapup( )
*/
parser->state.seen_frame_header = 0;
}
return GST_AV1_PARSER_OK;
error:
GST_WARNING ("parse tile group error %d", retval);
return retval;
}
/**
* gst_av1_parser_parse_tile_group_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
* @tile_group: a #GstAV1TileGroupOBU to store the parsed result.
*
* Parse one tile group @obu based on the @parser context, store the result
* in the @tile_group.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_tile_group_obu (GstAV1Parser * parser, GstAV1OBU * obu,
GstAV1TileGroupOBU * tile_group)
{
GstAV1ParserResult ret;
GstBitReader bit_reader;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_TILE_GROUP,
GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (tile_group != NULL, GST_AV1_PARSER_INVALID_OPERATION);
if (!parser->state.seen_frame_header) {
GST_WARNING ("Missing OBU Reference: frame_header");
return GST_AV1_PARSER_MISSING_OBU_REFERENCE;
}
gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
ret = gst_av1_parse_tile_group (parser, &bit_reader, tile_group);
return ret;
}
static GstAV1ParserResult
gst_av1_parse_frame_header (GstAV1Parser * parser, GstAV1OBU * obu,
GstBitReader * bit_reader, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult ret;
guint i;
memset (frame_header, 0, sizeof (*frame_header));
frame_header->frame_is_intra = 1;
frame_header->last_frame_idx = -1;
frame_header->gold_frame_idx = -1;
for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
frame_header->ref_frame_idx[i] = -1;
ret = gst_av1_parse_uncompressed_frame_header (parser, obu, bit_reader,
frame_header);
if (ret != GST_AV1_PARSER_OK)
return ret;
if (frame_header->show_existing_frame) {
parser->state.seen_frame_header = 0;
} else {
parser->state.seen_frame_header = 1;
}
return GST_AV1_PARSER_OK;
}
/**
* gst_av1_parser_parse_frame_header_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
* @frame_header: a #GstAV1FrameHeaderOBU to store the parsed result.
*
* Parse one frame header @obu based on the @parser context, store the result
* in the @frame.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_frame_header_obu (GstAV1Parser * parser,
GstAV1OBU * obu, GstAV1FrameHeaderOBU * frame_header)
{
GstAV1ParserResult ret;
GstBitReader bit_reader;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_FRAME_HEADER ||
obu->obu_type == GST_AV1_OBU_REDUNDANT_FRAME_HEADER,
GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (frame_header != NULL, GST_AV1_PARSER_INVALID_OPERATION);
if (obu->obu_type == GST_AV1_OBU_REDUNDANT_FRAME_HEADER
&& !parser->state.seen_frame_header) {
GST_WARNING ("no seen of frame header while get redundant frame header");
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
if (obu->obu_type == GST_AV1_OBU_FRAME_HEADER
&& parser->state.seen_frame_header) {
GST_WARNING ("already seen a frame header");
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
ret = gst_av1_parse_frame_header (parser, obu, &bit_reader, frame_header);
if (ret != GST_AV1_PARSER_OK)
return ret;
ret = av1_skip_trailing_bits (parser, &bit_reader, obu);
return ret;
}
/**
* gst_av1_parser_parse_frame_obu:
* @parser: the #GstAV1Parser
* @obu: a #GstAV1OBU to be parsed
* @frame: a #GstAV1FrameOBU to store the parsed result.
*
* Parse one frame @obu based on the @parser context, store the result
* in the @frame.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.18
*/
GstAV1ParserResult
gst_av1_parser_parse_frame_obu (GstAV1Parser * parser, GstAV1OBU * obu,
GstAV1FrameOBU * frame)
{
GstAV1ParserResult retval;
GstBitReader bit_reader;
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (obu->obu_type == GST_AV1_OBU_FRAME,
GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (frame != NULL, GST_AV1_PARSER_INVALID_OPERATION);
if (parser->state.seen_frame_header) {
GST_WARNING ("already seen a frame header");
return GST_AV1_PARSER_BITSTREAM_ERROR;
}
gst_bit_reader_init (&bit_reader, obu->data, obu->obu_size);
retval = gst_av1_parse_frame_header (parser, obu, &bit_reader,
&(frame->frame_header));
if (retval != GST_AV1_PARSER_OK)
return retval;
if (!gst_bit_reader_skip_to_byte (&bit_reader))
return GST_AV1_PARSER_NO_MORE_DATA;
retval = gst_av1_parse_tile_group (parser, &bit_reader, &(frame->tile_group));
return retval;
}
/**
* gst_av1_parser_set_operating_point:
* @parser: the #GstAV1Parser
* @operating_point: the operating point to set
*
* Set the operating point to filter OBUs.
*
* Returns: The #GstAV1ParserResult.
*
* Since: 1.20
*/
GstAV1ParserResult
gst_av1_parser_set_operating_point (GstAV1Parser * parser,
gint32 operating_point)
{
g_return_val_if_fail (parser != NULL, GST_AV1_PARSER_INVALID_OPERATION);
g_return_val_if_fail (operating_point >= 0, GST_AV1_PARSER_INVALID_OPERATION);
if (parser->seq_header &&
operating_point > parser->seq_header->operating_points_cnt_minus_1)
return GST_AV1_PARSER_INVALID_OPERATION;
/* Decide whether it is valid when sequence comes. */
parser->state.operating_point = operating_point;
return GST_AV1_PARSER_OK;
}
/**
* gst_av1_parser_new:
*
* Allocates a new #GstAV1Parser,
*
* Returns: (transfer full): a newly-allocated #GstAV1Parser
*
* Since: 1.18
*/
GstAV1Parser *
gst_av1_parser_new (void)
{
return g_new0 (GstAV1Parser, 1);
}
/**
* gst_av1_parser_free:
* @parser: the #GstAV1Parser to free
*
* If parser is not %NULL, frees its allocated memory.
*
* It cannot be used afterwards.
*
* Since: 1.18
*/
void
gst_av1_parser_free (GstAV1Parser * parser)
{
g_return_if_fail (parser != NULL);
if (parser->seq_header)
g_free (parser->seq_header);
g_free (parser);
}
Reference in a new issue View git blame Copy permalink