mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
7589647c13
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/7047>
4714 lines
151 KiB
C
4714 lines
151 KiB
C
/* 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);
|
|
}
|