gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/codecparsers/gstav1bitwriter.c

/* GStreamer
 *  Copyright (C) 2022 Intel Corporation
 *     Author: He Junyan <junyan.he@intel.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the0
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "gstav1bitwriter.h"
#include <gst/base/gstbitwriter.h>

#define WRITE_BITS_UNCHECK(bw, val, nbits)                                    \
  (nbits <= 8 ? gst_bit_writer_put_bits_uint8 (bw, val, nbits) :              \
   (nbits <= 16 ? gst_bit_writer_put_bits_uint16 (bw, val, nbits) :           \
    (nbits <= 32 ? gst_bit_writer_put_bits_uint32 (bw, val, nbits) :          \
     FALSE)))

#define WRITE_BITS(bw, val, nbits)                                            \
  if (!WRITE_BITS_UNCHECK (bw, val, nbits)) {                                 \
    g_warning ("Unsupported bit size: %u", nbits);                            \
    have_space = FALSE;                                                       \
    goto error;                                                               \
  }

static guint
_av1_uleb_size_in_bytes (guint64 value)
{
  guint size = 0;

  do {
    ++size;
  } while ((value >>= 7) != 0);
  return size;
}

static gboolean
_av1_encode_uleb (guint64 value, guint available,
    guint8 * coded_value, guint coded_size)
{
  const guint kMaximumLeb128Size = 8;
  const guint leb_size = _av1_uleb_size_in_bytes (value);
  const guint64 kMaximumLeb128Value = 0xffffffff /* 4294967295U */ ;
  guint i;

  g_assert (coded_size >= leb_size);

  if (value > kMaximumLeb128Value || coded_size > kMaximumLeb128Size ||
      coded_size > available || !coded_value) {
    return FALSE;
  }

  if (leb_size == coded_size) {
    for (i = 0; i < leb_size; i++) {
      guint8 byte = value & 0x7f;
      value >>= 7;

      if (value != 0)
        byte |= 0x80;           // Signal that more bytes follow.

      *(coded_value + i) = byte;
    }
  } else {
    memset (coded_value, 0, coded_size);

    i = 0;
    do {
      *(coded_value + i) = value & 0x7fU;
      value >>= 7;
      i++;
    } while (value);

    for (i = 0; i < coded_size - 1; i++)
      *(coded_value + i) |= 0x80;
  }

  return TRUE;
}

/* 4.10.3
 *
 * Variable length unsigned n-bit number appearing directly in the
 * bitstream */
static gboolean
_av1_write_uvlc (GstBitWriter * bw, guint32 value, gboolean * space)
{
  gboolean have_space = TRUE;
  gint64 shift_val = value;
  gint32 leading_zeroes = 1;

  value++;

  g_assert (shift_val > 0);

  while (shift_val >>= 1)
    leading_zeroes += 2;

  WRITE_BITS (bw, 0, leading_zeroes >> 1);
  WRITE_BITS (bw, value, (leading_zeroes + 1) >> 1);

  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

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 gboolean
_av1_write_uniform (GstBitWriter * bw, guint32 max_value, guint32 value,
    gboolean * space)
{
  gboolean have_space = TRUE;
  const gint l = max_value ? _av1_helper_msb (max_value) + 1 : 0;
  const gint m = (1 << l) - max_value;

  if (l == 0)
    goto success;

  if (value < m) {
    WRITE_BITS (bw, value, l - 1);
  } else {
    WRITE_BITS (bw, m + ((value - m) >> 1), l - 1);
    WRITE_BITS (bw, (value - m) & 1, 1);
  }

success:
  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

/* 5.9.13
 *
 * Delta quantizer */
static gboolean
_av1_write_delta_q (GstBitWriter * bw, gint32 delta_q, gboolean * space)
{
  gboolean have_space = TRUE;

  if (delta_q != 0) {
    WRITE_BITS (bw, 1, 1);
    WRITE_BITS (bw, delta_q, 7);
  } else {
    WRITE_BITS (bw, 0, 1);
  }

  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

/* 4.10.6
 *
 * su(n) */
static gboolean
_av1_write_su (GstBitWriter * bw, gint32 val, guint n, gboolean * space)
{
  gboolean have_space = TRUE;

  g_assert (n < 31);
  WRITE_BITS (bw, val, n + 1);

  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

/* 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;
}

static gboolean
_av1_write_primitive_quniform (GstBitWriter * bw, guint16 n, guint16 v,
    gboolean * space)
{
  gboolean have_space = TRUE;
  const gint l = _av1_helper_msb (n) + 1;
  const gint m = (1 << l) - n;

  if (n <= 1)
    goto success;

  if (v < m) {
    WRITE_BITS (bw, v, l - 1);
  } else {
    WRITE_BITS (bw, m + ((v - m) >> 1), l - 1);
    WRITE_BITS (bw, (v - m) & 1, 1);
  }

success:
  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_write_primitive_subexpfin (GstBitWriter * bw, guint16 n, guint16 k,
    guint16 v, gboolean * space)
{
  gboolean have_space = TRUE;
  gint i = 0;
  gint mk = 0;

  while (1) {
    gint b = (i ? k + i - 1 : k);
    gint a = (1 << b);

    if (n <= mk + 3 * a) {
      if (!_av1_write_primitive_quniform (bw, n - mk, v - mk, space))
        goto error;

      break;
    } else {
      gint t = (v >= mk + a);
      WRITE_BITS (bw, t, 1);
      if (t) {
        i = i + 1;
        mk += a;
      } else {
        WRITE_BITS (bw, v - mk, b);
        break;
      }
    }
  }

  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

/* Recenters a non-negative literal v around a reference r */
static guint16
_av1_helper_recenter_nonneg (guint16 r, guint16 v)
{
  if (v > (r << 1))
    return v;
  else if (v >= r)
    return ((v - r) << 1);
  else
    return ((r - v) << 1) - 1;
}

/* Recenters a non-negative literal v in [0, n-1] around
   a reference r also in [0, n-1] */
static guint16
_av1_helper_recenter_finite_nonneg (guint16 n, guint16 r, guint16 v)
{
  if ((r << 1) <= n) {
    return _av1_helper_recenter_nonneg (r, v);
  } else {
    return _av1_helper_recenter_nonneg (n - 1 - r, n - 1 - v);
  }
}

static gboolean
_av1_write_primitive_refsubexpfin (GstBitWriter * bw,
    guint16 n, guint16 k, guint16 ref, guint16 v, gboolean * space)
{
  gboolean have_space = TRUE;

  if (!_av1_write_primitive_subexpfin (bw, n, k,
          _av1_helper_recenter_finite_nonneg (n, ref, v), space))
    goto error;

  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_write_signed_primitive_refsubexpfin (GstBitWriter * bw,
    guint16 n, guint16 k, gint16 ref, gint16 v, gboolean * space)
{
  gboolean have_space = TRUE;
  const guint16 scaled_n = (n << 1) - 1;
  ref += n - 1;
  v += n - 1;

  if (!_av1_write_primitive_refsubexpfin (bw, scaled_n, k, ref, v, space))
    goto error;

  *space = TRUE;
  return TRUE;

error:
  *space = have_space;
  return FALSE;
}

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 gboolean
_av1_bit_writer_timing_info (const GstAV1TimingInfo * timing_info,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing timing info");

  if (timing_info->num_units_in_display_tick == 0 ||
      timing_info->time_scale == 0)
    goto error;

  WRITE_BITS (bw, timing_info->num_units_in_display_tick, 32);
  WRITE_BITS (bw, timing_info->time_scale, 32);

  WRITE_BITS (bw, timing_info->equal_picture_interval, 1);
  if (timing_info->equal_picture_interval) {
    if (timing_info->num_ticks_per_picture_minus_1 == G_MAXUINT)
      goto error;

    if (!_av1_write_uvlc (bw, timing_info->num_ticks_per_picture_minus_1,
            &have_space))
      goto error;
  }

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write timing info");
  *space = have_space;
  return FALSE;
}

/* 5.5.4 */
static gboolean
_av1_bit_writer_decoder_model_info (const GstAV1DecoderModelInfo *
    decoder_model_info, GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing decoder model info");

  WRITE_BITS (bw, decoder_model_info->buffer_delay_length_minus_1, 5);
  WRITE_BITS (bw, decoder_model_info->num_units_in_decoding_tick, 32);
  WRITE_BITS (bw, decoder_model_info->buffer_removal_time_length_minus_1, 5);
  WRITE_BITS (bw, decoder_model_info->frame_presentation_time_length_minus_1,
      5);

  *space = TRUE;
  return TRUE;
error:
  GST_WARNING ("failed to write decoder model info");
  *space = have_space;
  return FALSE;
}

/* 5.5.5 */
static gboolean
_av1_bit_writer_operating_parameters_info (const GstAV1SequenceHeaderOBU *
    seq_header, const GstAV1OperatingPoint * op_point, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;
  guint32 n = seq_header->decoder_model_info.buffer_delay_length_minus_1 + 1;

  GST_DEBUG ("writing operating parameters info");

  if (n > 32)
    goto error;

  WRITE_BITS (bw, op_point->decoder_buffer_delay, n);
  WRITE_BITS (bw, op_point->encoder_buffer_delay, n);
  WRITE_BITS (bw, op_point->low_delay_mode_flag, 1);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write operating parameters info");
  *space = have_space;
  return FALSE;
}

/* 5.5.2 */
static gboolean
_av1_bit_writer_color_config (const GstAV1SequenceHeaderOBU * seq_header,
    const GstAV1ColorConfig * color_config, GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing color config");

  WRITE_BITS (bw, color_config->high_bitdepth, 1);

  if (seq_header->seq_profile == GST_AV1_PROFILE_2
      && color_config->high_bitdepth) {
    WRITE_BITS (bw, color_config->twelve_bit, 1);
  } else if (seq_header->seq_profile > GST_AV1_PROFILE_2) {
    GST_WARNING ("Unsupported profile/bit-depth combination");
    goto error;
  }

  if (seq_header->seq_profile != GST_AV1_PROFILE_1)
    WRITE_BITS (bw, color_config->mono_chrome, 1);

  if (seq_header->num_planes != 1 && seq_header->num_planes != 3) {
    GST_WARNING ("num_planes is not correct");
    goto error;
  }
  if (!color_config->mono_chrome && seq_header->num_planes != 3) {
    GST_WARNING ("num_planes is not correct");
    goto error;
  }

  WRITE_BITS (bw, color_config->color_description_present_flag, 1);

  if (color_config->color_description_present_flag) {
    WRITE_BITS (bw, color_config->color_primaries, 8);
    WRITE_BITS (bw, color_config->transfer_characteristics, 8);
    WRITE_BITS (bw, color_config->matrix_coefficients, 8);
  }

  if (color_config->mono_chrome) {
    if (color_config->subsampling_x != 1 || color_config->subsampling_y != 1) {
      GST_WARNING ("set subsampling_x or subsampling_y wrong value");
      goto error;
    }

    WRITE_BITS (bw, color_config->color_range, 1);
    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) {

    if (color_config->color_range != 1) {
      GST_WARNING ("set color_range wrong value");
      goto error;
    }

    if (color_config->subsampling_x != 0 || color_config->subsampling_y != 0) {
      GST_WARNING ("set subsampling_x or subsampling_y wrong value");
      goto error;
    }

    if (!(seq_header->seq_profile == GST_AV1_PROFILE_1 ||
            (seq_header->seq_profile == GST_AV1_PROFILE_2
                && seq_header->bit_depth == 12))) {
      GST_WARNING ("sRGB colorspace not compatible with specified profile");
      goto error;
    }
  } else {
    WRITE_BITS (bw, color_config->color_range, 1);

    if (seq_header->seq_profile == GST_AV1_PROFILE_0) {
      if (color_config->subsampling_x != 1 || color_config->subsampling_y != 1) {
        GST_WARNING ("set subsampling_x or subsampling_y wrong value");
        goto error;
      }
    } else if (seq_header->seq_profile == GST_AV1_PROFILE_1) {
      if (color_config->subsampling_x != 0 || color_config->subsampling_y != 0) {
        GST_WARNING ("set subsampling_x or subsampling_y wrong value");
        goto error;
      }
    } else if (seq_header->seq_profile == GST_AV1_PROFILE_2) {
      if (seq_header->bit_depth == 12) {
        WRITE_BITS (bw, color_config->subsampling_x, 1);

        if (color_config->subsampling_x) {
          /* 422 or 420 */
          WRITE_BITS (bw, color_config->subsampling_y, 1);
        }
      }
    }

    if (color_config->subsampling_x && color_config->subsampling_y)
      WRITE_BITS (bw, color_config->chroma_sample_position, 2);
  }

  WRITE_BITS (bw, color_config->separate_uv_delta_q, 1);

  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_WARNING ("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);
    goto error;
  }

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write color config");
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_bit_writer_sequence_header (const GstAV1SequenceHeaderOBU * seq_header,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  gint i;

  GST_DEBUG ("writing sequence header");

  if (seq_header->seq_profile > GST_AV1_PROFILE_2) {
    GST_WARNING ("Unsupported profile %d", seq_header->seq_profile);
    goto error;
  }
  WRITE_BITS (bw, seq_header->seq_profile, 3);

  WRITE_BITS (bw, seq_header->still_picture, 1);

  if (!seq_header->still_picture && seq_header->reduced_still_picture_header) {
    GST_WARNING (" If reduced_still_picture_header is equal to 1, it is a"
        " requirement of bitstream conformance that still_picture is equal"
        " to 1. ");
    goto error;
  }
  WRITE_BITS (bw, seq_header->reduced_still_picture_header, 1);

  if (seq_header->reduced_still_picture_header) {
    if (!_av1_seq_level_idx_is_valid
        (seq_header->operating_points[0].seq_level_idx)) {
      GST_WARNING ("The seq_level_idx is unsupported");
      goto error;
    }
    WRITE_BITS (bw, seq_header->operating_points[0].seq_level_idx, 5);
  } else {
    WRITE_BITS (bw, seq_header->timing_info_present_flag, 1);
    if (seq_header->timing_info_present_flag) {
      if (!_av1_bit_writer_timing_info (&seq_header->timing_info, bw,
              &have_space))
        goto error;

      WRITE_BITS (bw, seq_header->decoder_model_info_present_flag, 1);
      if (seq_header->decoder_model_info_present_flag) {
        if (!_av1_bit_writer_decoder_model_info
            (&seq_header->decoder_model_info, bw, &have_space))
          goto error;
      }
    }

    WRITE_BITS (bw, seq_header->initial_display_delay_present_flag, 1);

    if (seq_header->operating_points_cnt_minus_1 + 1 >
        GST_AV1_MAX_OPERATING_POINTS) {
      GST_WARNING ("The operating points number %d is too big",
          seq_header->operating_points_cnt_minus_1 + 1);
      goto error;
    }
    WRITE_BITS (bw, seq_header->operating_points_cnt_minus_1, 5);

    for (i = 0; i < seq_header->operating_points_cnt_minus_1 + 1; i++) {
      const GstAV1OperatingPoint *op = &seq_header->operating_points[i];

      WRITE_BITS (bw, op->idc, 12);

      if (!_av1_seq_level_idx_is_valid (op->seq_level_idx)) {
        GST_WARNING ("The seq_level_idx is unsupported");
        goto error;
      }
      WRITE_BITS (bw, op->seq_level_idx, 5);

      if (op->seq_level_idx > GST_AV1_SEQ_LEVEL_3_3)
        WRITE_BITS (bw, op->seq_tier, 1);

      if (seq_header->decoder_model_info_present_flag) {
        WRITE_BITS (bw, op->decoder_model_present_for_this_op, 1);
        if (op->decoder_model_present_for_this_op) {
          if (!_av1_bit_writer_operating_parameters_info (seq_header,
                  op, bw, &have_space))
            goto error;
        }
      }

      if (seq_header->initial_display_delay_present_flag) {
        WRITE_BITS (bw, op->initial_display_delay_present_for_this_op, 1);

        if (op->initial_display_delay_present_for_this_op) {
          if (op->initial_display_delay_minus_1 + 1 > 10) {
            GST_INFO ("AV1 does not support more than 10 decoded frames delay");
            goto error;
          }

          WRITE_BITS (bw, op->initial_display_delay_minus_1, 4);
        }
      }
    }
  }

  WRITE_BITS (bw, seq_header->frame_width_bits_minus_1, 4);
  WRITE_BITS (bw, seq_header->frame_height_bits_minus_1, 4);
  WRITE_BITS (bw, seq_header->max_frame_width_minus_1,
      seq_header->frame_width_bits_minus_1 + 1);
  WRITE_BITS (bw, seq_header->max_frame_height_minus_1,
      seq_header->frame_height_bits_minus_1 + 1);

  if (!seq_header->reduced_still_picture_header)
    WRITE_BITS (bw, seq_header->frame_id_numbers_present_flag, 1);

  if (seq_header->frame_id_numbers_present_flag) {
    if (seq_header->additional_frame_id_length_minus_1 + 1 +
        seq_header->delta_frame_id_length_minus_2 + 2 > 16) {
      GST_WARNING ("Invalid frame_id_length");
      goto error;
    }
    WRITE_BITS (bw, seq_header->delta_frame_id_length_minus_2, 4);
    WRITE_BITS (bw, seq_header->additional_frame_id_length_minus_1, 3);
  }

  WRITE_BITS (bw, seq_header->use_128x128_superblock, 1);
  WRITE_BITS (bw, seq_header->enable_filter_intra, 1);
  WRITE_BITS (bw, seq_header->enable_intra_edge_filter, 1);

  if (!seq_header->reduced_still_picture_header) {
    WRITE_BITS (bw, seq_header->enable_interintra_compound, 1);
    WRITE_BITS (bw, seq_header->enable_masked_compound, 1);
    WRITE_BITS (bw, seq_header->enable_warped_motion, 1);
    WRITE_BITS (bw, seq_header->enable_dual_filter, 1);
    WRITE_BITS (bw, seq_header->enable_order_hint, 1);
    if (seq_header->enable_order_hint) {
      WRITE_BITS (bw, seq_header->enable_jnt_comp, 1);
      WRITE_BITS (bw, seq_header->enable_ref_frame_mvs, 1);
    }

    WRITE_BITS (bw, seq_header->seq_choose_screen_content_tools, 1);
    if (!seq_header->seq_choose_screen_content_tools)
      WRITE_BITS (bw, seq_header->seq_force_screen_content_tools, 1);

    if (seq_header->seq_force_screen_content_tools > 0) {
      WRITE_BITS (bw, seq_header->seq_choose_integer_mv, 1);
      if (!seq_header->seq_choose_integer_mv)
        WRITE_BITS (bw, seq_header->seq_force_integer_mv, 1);
    }

    if (seq_header->enable_order_hint)
      WRITE_BITS (bw, seq_header->order_hint_bits_minus_1, 3);
  }

  WRITE_BITS (bw, seq_header->enable_superres, 1);
  WRITE_BITS (bw, seq_header->enable_cdef, 1);
  WRITE_BITS (bw, seq_header->enable_restoration, 1);

  if (!_av1_bit_writer_color_config (seq_header, &seq_header->color_config,
          bw, &have_space))
    goto error;

  WRITE_BITS (bw, seq_header->film_grain_params_present, 1);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write sequence header");
  *space = have_space;
  return FALSE;
}

/* Return the actual size field size. */
static guint
_av1_bit_writer_add_size_field (guint8 * data, guint * size, guint header_size,
    guint payload_size, guint size_field_size, gboolean * space)
{
  guint size_field_sz;

  size_field_sz = _av1_uleb_size_in_bytes (payload_size);
  g_assert (size_field_sz > 0);

  if (size_field_size > 0) {
    if (size_field_sz > size_field_size) {
      GST_WARNING ("the fixed size field size is too small");
      goto error;
    }

    size_field_sz = size_field_size;
  }

  /* Move and write the data size field */
  if (header_size + payload_size + size_field_sz > *size) {
    *space = FALSE;
    goto error;
  }
  *space = TRUE;

  memmove (data + header_size + size_field_sz,
      data + header_size, payload_size);

  if (!_av1_encode_uleb (payload_size, sizeof (payload_size),
          data + header_size, size_field_sz))
    goto error;

  *size = header_size + payload_size + size_field_sz;
  return size_field_sz;

error:
  GST_WARNING ("failed to write the size field");
  return 0;
}

/**
 * gst_av1_bit_writer_sequence_header_obu:
 * @seq_hdr: the sequence header of #GstAV1SequenceHeaderOBU to write
 * @size_field: whether the header contain size feild
 * @data: (out): the bit stream generated by the sequence header
 * @size: (inout): the size in bytes of the input and output
 *
 * Generating the according AV1 bit stream OBU by providing the sequence header.
 *
 * Returns: a #GstAV1BitWriterResult
 *
 * Since: 1.22
 **/
GstAV1BitWriterResult
gst_av1_bit_writer_sequence_header_obu (const GstAV1SequenceHeaderOBU *
    seq_hdr, gboolean size_field, guint8 * data, guint * size)
{
  gboolean have_space = TRUE;
  GstBitWriter bw;
  guint header_size;
  guint payload_size;

  g_return_val_if_fail (seq_hdr != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (data != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (size != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (*size > 0, GST_AV1_BIT_WRITER_ERROR);

  gst_bit_writer_init_with_data (&bw, data, *size, FALSE);

  /* obu_forbidden_bit */
  WRITE_BITS (&bw, 0, 1);
  /* obu_type */
  WRITE_BITS (&bw, GST_AV1_OBU_SEQUENCE_HEADER, 4);
  /* obu_extention_flag */
  WRITE_BITS (&bw, 0, 1);
  /* obu_has_size_field */
  WRITE_BITS (&bw, 1, 1);
  /* obu_reserved_1bit */
  WRITE_BITS (&bw, 0, 1);

  header_size = gst_bit_writer_get_size (&bw);
  g_assert (header_size % 8 == 0);
  header_size /= 8;

  if (!_av1_bit_writer_sequence_header (seq_hdr, &bw, &have_space))
    goto error;

  /* Add trailings. */
  WRITE_BITS (&bw, 1, 1);
  if (!gst_bit_writer_align_bytes (&bw, 0)) {
    have_space = FALSE;
    goto error;
  }

  payload_size = gst_bit_writer_get_size (&bw);
  g_assert (payload_size % 8 == 0);
  payload_size /= 8;
  payload_size -= header_size;

  gst_bit_writer_reset (&bw);

  if (size_field) {
    if (!_av1_bit_writer_add_size_field (data, size,
            header_size, payload_size, 0, &have_space))
      goto error;
  } else {
    *size = header_size + payload_size;
  }

  return GST_AV1_BIT_WRITER_OK;

error:
  gst_bit_writer_reset (&bw);
  *size = 0;
  return have_space ? GST_AV1_BIT_WRITER_INVALID_DATA :
      GST_AV1_BIT_WRITER_NO_MORE_SPACE;
}

/* 5.9.5 */
static gboolean
_av1_bit_writer_superres_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing superres param");

  if (seq_header->enable_superres)
    WRITE_BITS (bw, frame_header->use_superres, 1);

  if (frame_header->use_superres) {
    guint8 coded_denom;

    if (frame_header->superres_denom < GST_AV1_SUPERRES_DENOM_MIN)
      goto error;

    coded_denom = frame_header->superres_denom - GST_AV1_SUPERRES_DENOM_MIN;
    if (coded_denom > (1 << GST_AV1_SUPERRES_DENOM_BITS) - 1)
      goto error;

    WRITE_BITS (bw, coded_denom, GST_AV1_SUPERRES_DENOM_BITS);
  }

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write superres param");
  *space = have_space;
  return FALSE;
}

/* 5.9.5 */
static gboolean
_av1_bit_writer_frame_size (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing frame size");

  if (frame_header->frame_size_override_flag) {
    guint16 frame_width_minus_1;
    guint16 frame_height_minus_1;

    frame_width_minus_1 = frame_header->frame_width - 1;
    WRITE_BITS (bw, frame_width_minus_1,
        seq_header->frame_width_bits_minus_1 + 1);
    frame_height_minus_1 = frame_header->frame_height - 1;
    WRITE_BITS (bw, frame_height_minus_1,
        seq_header->frame_height_bits_minus_1 + 1);
  }

  if (!_av1_bit_writer_superres_params (frame_header, seq_header, bw, space))
    goto error;

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write frame size");
  *space = have_space;
  return FALSE;
}

/* 5.9.6 */
static gboolean
_av1_bit_writer_render_size (const GstAV1FrameHeaderOBU * frame_header,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing render size");

  WRITE_BITS (bw, frame_header->render_and_frame_size_different, 1);

  if (frame_header->render_and_frame_size_different) {
    guint16 render_width_minus_1 = frame_header->render_width - 1;
    guint16 render_height_minus_1 = frame_header->render_height - 1;

    WRITE_BITS (bw, render_width_minus_1, 16);
    WRITE_BITS (bw, render_height_minus_1, 16);
  }

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write render size");
  *space = have_space;
  return FALSE;
}

/* 5.9.15 */
static gboolean
_av1_bit_writer_tile_info (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;
  const GstAV1TileInfo *tile_info;
  guint32 mi_cols /* MiCols */ ;
  guint32 mi_rows /* MiRows */ ;
  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 size_sb /* sizeSb */ ;
  gint widest_tile_sb /* widestTileSb */ ;

  tile_info = &frame_header->tile_info;

  GST_DEBUG ("writing tile info");

  /* User must specify the frame resolution. */
  if (frame_header->frame_width == 0 || frame_header->frame_height == 0) {
    GST_WARNING ("unknown frame_width or frame_height");
    goto error;
  }

  mi_cols = 2 * ((frame_header->frame_width + 7) >> 3);
  mi_rows = 2 * ((frame_header->frame_height + 7) >> 3);

  sb_cols = seq_header->use_128x128_superblock ?
      ((mi_cols + 31) >> 5) : ((mi_cols + 15) >> 4);
  sb_rows = seq_header->use_128x128_superblock ?
      ((mi_rows + 31) >> 5) : ((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));

  WRITE_BITS (bw, tile_info->uniform_tile_spacing_flag, 1);
  if (tile_info->uniform_tile_spacing_flag) {
    /* columns */
    gint ones = tile_info->tile_cols_log2 - min_log2_tile_cols;
    if (ones < 0)
      goto error;

    while (ones--)
      WRITE_BITS (bw, 1, 1);
    if (tile_info->tile_cols_log2 < max_log2_tile_cols)
      WRITE_BITS (bw, 0, 1);

    /* rows */
    min_log2_tile_rows = MAX (min_log2_tiles - tile_info->tile_cols_log2, 0);
    ones = tile_info->tile_rows_log2 - min_log2_tile_rows;
    if (ones < 0)
      goto error;

    while (ones--)
      WRITE_BITS (bw, 1, 1);
    if (tile_info->tile_rows_log2 < max_log2_tile_rows)
      WRITE_BITS (bw, 0, 1);
  } else {
    /* Explicit tiles with configurable tile widths and heights */
    guint i;
    guint width_sb;
    guint height_sb;

    widest_tile_sb = 0;

    /* columns */
    width_sb = sb_cols;
    for (i = 0; i < tile_info->tile_cols; i++) {
      size_sb = tile_info->mi_col_starts[i + 1] - tile_info->mi_col_starts[i];
      size_sb = size_sb >> sb_shift;
      widest_tile_sb = MAX (size_sb, widest_tile_sb);
      if (_av1_write_uniform (bw, MIN (width_sb, max_tile_width_sb),
              size_sb - 1, &have_space))
        goto error;

      width_sb -= size_sb;
    }

    if (width_sb != 0)
      goto error;

    // rows
    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);

    height_sb = sb_rows;
    for (i = 0; i < tile_info->tile_rows; i++) {
      size_sb = tile_info->mi_row_starts[i + 1] - tile_info->mi_row_starts[i];
      size_sb = size_sb >> sb_shift;
      if (_av1_write_uniform (bw, MIN (height_sb, max_tile_height_sb),
              size_sb - 1, &have_space))
        goto error;

      height_sb -= size_sb;
    }

    if (height_sb != 0)
      goto error;
  }

  if (tile_info->tile_cols_log2 > 0 || tile_info->tile_rows_log2 > 0) {
    WRITE_BITS (bw, tile_info->context_update_tile_id,
        tile_info->tile_cols_log2 + tile_info->tile_rows_log2);

    WRITE_BITS (bw, tile_info->tile_size_bytes_minus_1, 2);
  }

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write tile info");
  *space = have_space;
  return FALSE;
}

/* 5.9.12 */
static gboolean
_av1_bit_writer_quantization_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, guint * qindex_offset,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  const GstAV1QuantizationParams *quant_params =
      &(frame_header->quantization_params);

  GST_DEBUG ("writing quantization params");

  if (qindex_offset)
    *qindex_offset = gst_bit_writer_get_size (bw);

  WRITE_BITS (bw, quant_params->base_q_idx, 8);

  if (!_av1_write_delta_q (bw,
          frame_header->quantization_params.delta_q_y_dc, &have_space))
    goto error;

  if (seq_header->num_planes > 1) {
    if (seq_header->color_config.separate_uv_delta_q)
      WRITE_BITS (bw, quant_params->diff_uv_delta, 1);

    if (!_av1_write_delta_q (bw,
            frame_header->quantization_params.delta_q_u_dc, &have_space))
      goto error;

    if (!_av1_write_delta_q (bw,
            frame_header->quantization_params.delta_q_u_ac, &have_space))
      goto error;

    if (quant_params->diff_uv_delta) {
      if (!_av1_write_delta_q (bw,
              frame_header->quantization_params.delta_q_v_dc, &have_space))
        goto error;

      if (!_av1_write_delta_q (bw,
              frame_header->quantization_params.delta_q_v_ac, &have_space))
        goto error;
    }
  }

  WRITE_BITS (bw, quant_params->using_qmatrix, 1);
  if (quant_params->using_qmatrix) {
    WRITE_BITS (bw, quant_params->qm_y, 4);
    WRITE_BITS (bw, quant_params->qm_u, 4);

    if (seq_header->color_config.separate_uv_delta_q)
      WRITE_BITS (bw, quant_params->qm_v, 4);
  }

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write quantization params");
  *space = have_space;
  return FALSE;
}

/* 5.9.14 */
static gboolean
_av1_bit_writer_segmentation_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, guint * segmentation_offset,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing segmentation params");

  if (segmentation_offset)
    *segmentation_offset = gst_bit_writer_get_size (bw);

  /* TODO: segmentation support. */
  if (frame_header->segmentation_params.segmentation_enabled) {
    GST_WARNING ("segmentation is not supported now");
    goto error;
  }

  WRITE_BITS (bw, frame_header->segmentation_params.segmentation_enabled, 1);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write segmentation params");
  *space = have_space;
  return FALSE;
}

/* 5.9.17 */
static gboolean
_av1_bit_writer_delta_q_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing delta q params");

  if (frame_header->quantization_params.base_q_idx > 0)
    WRITE_BITS (bw, frame_header->quantization_params.delta_q_present, 1);

  if (frame_header->quantization_params.delta_q_present)
    WRITE_BITS (bw, frame_header->quantization_params.delta_q_res, 2);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write delta q params");
  *space = have_space;
  return FALSE;
}

/* 5.9.18 */
static gboolean
_av1_bit_writer_delta_lf_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing delta lf params");

  if (frame_header->quantization_params.delta_q_present) {
    if (!frame_header->allow_intrabc)
      WRITE_BITS (bw, frame_header->loop_filter_params.delta_lf_present, 1);

    if (frame_header->loop_filter_params.delta_lf_present) {
      WRITE_BITS (bw, frame_header->loop_filter_params.delta_lf_res, 2);
      WRITE_BITS (bw, frame_header->loop_filter_params.delta_lf_multi, 1);
    }
  }

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write delta lf params");
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_bit_writer_loop_filter_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, guint * loopfilter_offset,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  const GstAV1LoopFilterParams *lf_params = &frame_header->loop_filter_params;

  GST_DEBUG ("writing loop filter params");

  if (frame_header->coded_lossless || frame_header->allow_intrabc)
    goto success;

  if (loopfilter_offset)
    *loopfilter_offset = gst_bit_writer_get_size (bw);

  WRITE_BITS (bw, lf_params->loop_filter_level[0], 6);
  WRITE_BITS (bw, lf_params->loop_filter_level[1], 6);
  if (seq_header->num_planes > 1) {
    if (lf_params->loop_filter_level[0] || lf_params->loop_filter_level[1]) {
      WRITE_BITS (bw, lf_params->loop_filter_level[2], 6);
      WRITE_BITS (bw, lf_params->loop_filter_level[3], 6);
    }
  }

  WRITE_BITS (bw, lf_params->loop_filter_sharpness, 3);

  WRITE_BITS (bw, lf_params->loop_filter_delta_enabled, 1);
  if (lf_params->loop_filter_delta_enabled) {
    guint i;

    WRITE_BITS (bw, lf_params->loop_filter_delta_update, 1);

    if (lf_params->loop_filter_delta_update) {
      const gint8 default_loop_filter_ref_deltas[] =
          { 1, 0, 0, 0, -1, 0, -1, -1 };
      gboolean update_ref_deltas;

      for (i = 0; i < GST_AV1_TOTAL_REFS_PER_FRAME; i++) {
        /* If loop_filter_ref_deltas[i] is different from default
           value, we update it. */
        update_ref_deltas = (lf_params->loop_filter_ref_deltas[i] !=
            default_loop_filter_ref_deltas[i]);

        WRITE_BITS (bw, update_ref_deltas, 1);

        if (update_ref_deltas) {
          if (!_av1_write_su (bw, lf_params->loop_filter_ref_deltas[i],
                  6, space))
            goto error;
        }
      }

      for (i = 0; i < 2; i++) {
        /* If loop_filter_mode_deltas[i] is different from default
           value, we update it. */
        update_ref_deltas = (lf_params->loop_filter_mode_deltas[i] != 0);

        WRITE_BITS (bw, update_ref_deltas, 1);

        if (update_ref_deltas) {
          if (!_av1_write_su (bw, lf_params->loop_filter_mode_deltas[i],
                  6, space))
            goto error;
        }
      }
    }
  }

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write loop filter params");
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_bit_writer_cdef_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, guint * cdef_offset,
    guint * cdef_size, GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  const GstAV1CDEFParams *cdef_params = &frame_header->cdef_params;
  guint cdef_start;
  guint i;

  GST_DEBUG ("writing cdef params");

  if (frame_header->coded_lossless || frame_header->allow_intrabc
      || !seq_header->enable_cdef)
    goto success;

  cdef_start = gst_bit_writer_get_size (bw);
  if (cdef_offset)
    *cdef_offset = cdef_start;

  WRITE_BITS (bw, cdef_params->cdef_damping - 3, 2);
  WRITE_BITS (bw, cdef_params->cdef_bits, 2);

  for (i = 0; i < (1 << cdef_params->cdef_bits); i++) {
    guint8 cdef_y_sec_strength;

    WRITE_BITS (bw, cdef_params->cdef_y_pri_strength[i], 4);

    cdef_y_sec_strength = cdef_params->cdef_y_sec_strength[i];

    if (cdef_y_sec_strength >= 4) {
      GST_WARNING ("cdef_y_sec_strength is not valid");
      goto error;
    }
    WRITE_BITS (bw, cdef_y_sec_strength, 2);

    if (seq_header->num_planes > 1) {
      guint8 cdef_uv_sec_strength;

      WRITE_BITS (bw, cdef_params->cdef_uv_pri_strength[i], 4);

      cdef_uv_sec_strength = cdef_params->cdef_uv_sec_strength[i];

      if (cdef_uv_sec_strength >= 4) {
        GST_WARNING ("cdef_uv_sec_strength is not valid");
        goto error;
      }
      WRITE_BITS (bw, cdef_uv_sec_strength, 2);
    }
  }

  if (cdef_size)
    *cdef_size = gst_bit_writer_get_size (bw) - cdef_start;

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write cdef params");
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_bit_writer_loop_restoration_params (const GstAV1FrameHeaderOBU *
    frame_header, const GstAV1SequenceHeaderOBU * seq_header,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  guint i, j;
  guint8 use_chroma_lr = 0 /* useChromaLr */ ;
  const GstAV1LoopRestorationParams *lr_params =
      &frame_header->loop_restoration_params;
  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
  };

  GST_DEBUG ("writing loop restoration params");

  if (frame_header->all_lossless || frame_header->allow_intrabc
      || !seq_header->enable_restoration)
    goto success;

  for (i = 0; i < seq_header->num_planes; i++) {
    for (j = 0; j < 4; j++) {
      if (lr_params->frame_restoration_type[i] == remap_lr_type[j])
        break;
    }
    if (j == 4)
      goto error;

    if (lr_params->frame_restoration_type[i] != GST_AV1_FRAME_RESTORE_NONE) {
      if (!lr_params->uses_lr) {
        GST_WARNING ("uses_lr set to wrong value");
        goto error;
      }

      if (i > 1)
        use_chroma_lr = 1;
    }

    WRITE_BITS (bw, j, 2);
  }

  if (lr_params->uses_lr) {
    if (lr_params->lr_unit_shift > 2)
      goto error;

    if (seq_header->use_128x128_superblock) {
      WRITE_BITS (bw, lr_params->lr_unit_shift - 1, 1);
    } else {
      WRITE_BITS (bw, 1, 1);

      if (lr_params->lr_unit_shift > 1)
        /* lr_unit_extra_shift */
        WRITE_BITS (bw, 1, 1);
    }

    if (seq_header->color_config.subsampling_x
        && seq_header->color_config.subsampling_y && use_chroma_lr)
      WRITE_BITS (bw, lr_params->lr_uv_shift, 1);
  }

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write loop restoration params");
  *space = have_space;
  return FALSE;
}

/* 5.9.22 */
static gboolean
_av1_bit_writer_skip_mode_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing skip mode params");

  /* if skipModeAllowed is true */
  if (frame_header->skip_mode_frame[0] > 0
      || frame_header->skip_mode_frame[1] > 0)
    WRITE_BITS (bw, frame_header->skip_mode_present, 1);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write skip mode params");
  *space = have_space;
  return FALSE;
}

/* 5.9.24 */
static gboolean
_av1_bit_writer_global_motion_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;
  gint ref, i;
  const GstAV1GlobalMotionParams *gm_params =
      &(frame_header->global_motion_params);
  gint32 prev_gm_params[GST_AV1_NUM_REF_FRAMES][6] /* PrevGmParams */ ;

  GST_DEBUG ("writing global motion params");

  if (frame_header->frame_is_intra)
    goto success;

  if (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE) {
    memcpy (prev_gm_params, &frame_header->ref_global_motion_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++) {
    WRITE_BITS (bw, gm_params->gm_type[ref] != GST_AV1_WARP_MODEL_IDENTITY, 1);

    if (gm_params->gm_type[ref] != GST_AV1_WARP_MODEL_IDENTITY) {
      WRITE_BITS (bw, gm_params->gm_type[ref] == GST_AV1_WARP_MODEL_ROTZOOM, 1);

      if (gm_params->gm_type[ref] != GST_AV1_WARP_MODEL_ROTZOOM)
        WRITE_BITS (bw,
            gm_params->gm_type[ref] == GST_AV1_WARP_MODEL_TRANSLATION, 1);
    }

    if (gm_params->gm_type[ref] >= GST_AV1_WARP_MODEL_ROTZOOM) {
      if (!_av1_write_signed_primitive_refsubexpfin (bw,
              (1 << GST_AV1_GM_ABS_ALPHA_BITS) + 1, 3,
              (prev_gm_params[ref][2] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)) -
              (1 << GST_AV1_GM_ALPHA_PREC_BITS),
              (gm_params->gm_params[ref][2] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)) -
              (1 << GST_AV1_GM_ALPHA_PREC_BITS), space))
        goto error;

      if (!_av1_write_signed_primitive_refsubexpfin (bw,
              (1 << GST_AV1_GM_ABS_ALPHA_BITS) + 1, 3,
              (prev_gm_params[ref][3] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)),
              (gm_params->gm_params[ref][3] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)), space))
        goto error;
    }

    if (gm_params->gm_type[ref] >= GST_AV1_WARP_MODEL_AFFINE) {
      if (!_av1_write_signed_primitive_refsubexpfin (bw,
              (1 << GST_AV1_GM_ABS_ALPHA_BITS) + 1, 3,
              (prev_gm_params[ref][4] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)),
              (gm_params->gm_params[ref][4] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)), space))
        goto error;

      if (!_av1_write_signed_primitive_refsubexpfin (bw,
              (1 << GST_AV1_GM_ABS_ALPHA_BITS) + 1, 3,
              (prev_gm_params[ref][5] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)) -
              (1 << GST_AV1_GM_ALPHA_PREC_BITS),
              (gm_params->gm_params[ref][5] >> (GST_AV1_WARPEDMODEL_PREC_BITS -
                      GST_AV1_GM_ALPHA_PREC_BITS)) -
              (1 << GST_AV1_GM_ALPHA_PREC_BITS), space))
        goto error;
    }

    if (gm_params->gm_type[ref] >= GST_AV1_WARP_MODEL_TRANSLATION) {
      const gint trans_bits =
          (gm_params->gm_type[ref] == GST_AV1_WARP_MODEL_TRANSLATION) ?
          GST_AV1_GM_ABS_TRANS_ONLY_BITS -
          !frame_header->allow_high_precision_mv : GST_AV1_GM_ABS_TRANS_BITS;
      const gint trans_prec_diff =
          (gm_params->gm_type[ref] == GST_AV1_WARP_MODEL_TRANSLATION) ?
          GST_AV1_WARPEDMODEL_PREC_BITS - 3 +
          !frame_header->allow_high_precision_mv :
          (GST_AV1_WARPEDMODEL_PREC_BITS - GST_AV1_GM_TRANS_PREC_BITS);

      if (!_av1_write_signed_primitive_refsubexpfin (bw, (1 << trans_bits) + 1,
              3, (prev_gm_params[ref][0] >> trans_prec_diff),
              (gm_params->gm_params[ref][0] >> trans_prec_diff), space))
        goto error;

      if (!_av1_write_signed_primitive_refsubexpfin (bw, (1 << trans_bits) + 1,
              3, (prev_gm_params[ref][1] >> trans_prec_diff),
              (gm_params->gm_params[ref][1] >> trans_prec_diff), space))
        goto error;
    }
  }

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write global motion params");
  *space = have_space;
  return FALSE;
}

/* 5.9.30 */
static gboolean
_av1_bit_writer_film_grain_params (const GstAV1FrameHeaderOBU * frame_header,
    const GstAV1SequenceHeaderOBU * seq_header, GstBitWriter * bw,
    gboolean * space)
{
  gboolean have_space = TRUE;
  guint i;
  gint num_pos_chroma /* numPosChroma */ , num_pos_luma /* numPosLuma */ ;
  const GstAV1FilmGrainParams *fg_params = &frame_header->film_grain_params;

  GST_DEBUG ("writing film grain params");

  fg_params = &frame_header->film_grain_params;
  if (!seq_header->film_grain_params_present || (!frame_header->show_frame
          && !frame_header->showable_frame))
    goto success;

  WRITE_BITS (bw, fg_params->apply_grain, 1);
  if (!fg_params->apply_grain)
    goto success;

  WRITE_BITS (bw, fg_params->grain_seed, 16);

  if (frame_header->frame_type == GST_AV1_INTER_FRAME)
    WRITE_BITS (bw, fg_params->update_grain, 1);

  if (!fg_params->update_grain) {
    WRITE_BITS (bw, fg_params->film_grain_params_ref_idx, 3);
    goto success;
  }

  WRITE_BITS (bw, fg_params->num_y_points, 4);

  for (i = 0; i < fg_params->num_y_points; i++) {
    WRITE_BITS (bw, fg_params->point_y_value[i], 8);
    WRITE_BITS (bw, fg_params->point_y_scaling[i], 8);
  }

  if (!seq_header->color_config.mono_chrome)
    WRITE_BITS (bw, fg_params->chroma_scaling_from_luma, 1);

  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))) {
    WRITE_BITS (bw, fg_params->num_cb_points, 4);

    for (i = 0; i < fg_params->num_cb_points; i++) {
      WRITE_BITS (bw, fg_params->point_cb_value[i], 8);
      WRITE_BITS (bw, fg_params->point_cb_scaling[i], 8);
    }

    WRITE_BITS (bw, fg_params->num_cr_points, 4);
    for (i = 0; i < fg_params->num_cr_points; i++) {
      WRITE_BITS (bw, fg_params->point_cr_value[i], 8);
      WRITE_BITS (bw, fg_params->point_cr_scaling[i], 8);
    }
  }

  WRITE_BITS (bw, fg_params->grain_scaling_minus_8, 2);

  WRITE_BITS (bw, fg_params->ar_coeff_lag, 2);

  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++)
      WRITE_BITS (bw, fg_params->ar_coeffs_y_plus_128[i], 8);
  } 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++)
      WRITE_BITS (bw, fg_params->ar_coeffs_cb_plus_128[i], 8);
  }

  if (fg_params->chroma_scaling_from_luma || fg_params->num_cr_points) {
    for (i = 0; i < num_pos_chroma; i++)
      WRITE_BITS (bw, fg_params->ar_coeffs_cr_plus_128[i], 8);
  }

  WRITE_BITS (bw, fg_params->ar_coeff_shift_minus_6, 2);

  WRITE_BITS (bw, fg_params->grain_scale_shift, 2);

  if (fg_params->num_cb_points) {
    WRITE_BITS (bw, fg_params->cb_mult, 8);
    WRITE_BITS (bw, fg_params->cb_luma_mult, 8);
    WRITE_BITS (bw, fg_params->cb_offset, 9);
  }

  if (fg_params->num_cr_points) {
    WRITE_BITS (bw, fg_params->cr_mult, 8);
    WRITE_BITS (bw, fg_params->cr_luma_mult, 8);
    WRITE_BITS (bw, fg_params->cr_offset, 9);
  }

  WRITE_BITS (bw, fg_params->overlap_flag, 1);
  WRITE_BITS (bw, fg_params->clip_to_restricted_range, 1);

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write film grain params");
  *space = have_space;
  return FALSE;
}

static gboolean
_av1_bit_writer_uncompressed_frame_header (const GstAV1FrameHeaderOBU *
    frame_header, const GstAV1SequenceHeaderOBU * seq_header,
    guint8 temporal_id, guint8 spatial_id, guint * qindex_offset,
    guint * segmentation_offset, guint * loopfilter_offset,
    guint * cdef_offset, guint * cdef_size, GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  guint i;
  gint id_len /* idLen */  = 0;
  const GstAV1DecoderModelInfo *cmi = &seq_header->decoder_model_info;

  GST_DEBUG ("writing frame header");

  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;

  if (!seq_header->reduced_still_picture_header) {
    WRITE_BITS (bw, frame_header->show_existing_frame, 1);
    if (frame_header->show_existing_frame) {
      WRITE_BITS (bw, frame_header->frame_to_show_map_idx, 3);

      if (seq_header->decoder_model_info_present_flag
          && !seq_header->timing_info.equal_picture_interval)
        WRITE_BITS (bw, frame_header->frame_presentation_time,
            cmi->frame_presentation_time_length_minus_1 + 1);

      if (seq_header->frame_id_numbers_present_flag) {
        if (id_len <= 0)
          goto error;

        WRITE_BITS (bw, frame_header->display_frame_id, id_len);
      }

      goto success;
    }

    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");
      goto error;
    }
    WRITE_BITS (bw, frame_header->frame_type, 2);
    WRITE_BITS (bw, frame_header->show_frame, 1);

    if (frame_header->show_frame
        && seq_header->decoder_model_info_present_flag
        && !seq_header->timing_info.equal_picture_interval)
      WRITE_BITS (bw, frame_header->frame_presentation_time,
          cmi->frame_presentation_time_length_minus_1 + 1);

    if (!frame_header->show_frame)
      WRITE_BITS (bw, frame_header->showable_frame, 1);

    if (!(frame_header->frame_type == GST_AV1_SWITCH_FRAME
            || (frame_header->frame_type == GST_AV1_KEY_FRAME
                && frame_header->show_frame)))
      WRITE_BITS (bw, frame_header->error_resilient_mode, 1);
  }

  WRITE_BITS (bw, frame_header->disable_cdf_update, 1);

  if (seq_header->seq_force_screen_content_tools ==
      GST_AV1_SELECT_SCREEN_CONTENT_TOOLS)
    WRITE_BITS (bw, frame_header->allow_screen_content_tools, 1);

  if (frame_header->allow_screen_content_tools) {
    if (seq_header->seq_force_integer_mv == GST_AV1_SELECT_INTEGER_MV)
      WRITE_BITS (bw, frame_header->force_integer_mv, 1);
  }

  if (seq_header->frame_id_numbers_present_flag) {
    if (id_len <= 0)
      goto error;

    WRITE_BITS (bw, frame_header->current_frame_id, id_len);
  }

  if (frame_header->frame_type != GST_AV1_SWITCH_FRAME
      && !seq_header->reduced_still_picture_header)
    WRITE_BITS (bw, frame_header->frame_size_override_flag, 1);

  WRITE_BITS (bw, frame_header->order_hint,
      seq_header->order_hint_bits_minus_1 + 1);

  if (frame_header->frame_is_intra || frame_header->error_resilient_mode) {
    if (frame_header->primary_ref_frame != GST_AV1_PRIMARY_REF_NONE) {
      GST_WARNING ("primary_ref_frame is not none.");
      goto error;
    }
  } else {
    WRITE_BITS (bw, frame_header->primary_ref_frame, 3);
  }

  if (seq_header->decoder_model_info_present_flag) {
    if (frame_header->buffer_removal_time_present_flag) {
      guint op_num;
      const GstAV1OperatingPoint *operating_points;

      for (op_num = 0; op_num <= seq_header->operating_points_cnt_minus_1;
          op_num++) {
        operating_points = &seq_header->operating_points[op_num];

        if (operating_points->decoder_model_present_for_this_op) {
          gint op_pt_idc = operating_points->idc;
          gint in_temporal_layer = (op_pt_idc >> temporal_id) & 1;
          gint in_spatial_layer = (op_pt_idc >> (spatial_id + 8)) & 1;

          if (op_pt_idc == 0 || (in_temporal_layer && in_spatial_layer))
            WRITE_BITS (bw, frame_header->buffer_removal_time[op_num],
                cmi->buffer_removal_time_length_minus_1 + 1);
        }
      }
    }
  }

  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");
      goto error;
    }
  }
  if (!(frame_header->frame_type == GST_AV1_SWITCH_FRAME ||
          (frame_header->frame_type == GST_AV1_KEY_FRAME
              && frame_header->show_frame)))
    WRITE_BITS (bw, frame_header->refresh_frame_flags, 8);

  if (!frame_header->frame_is_intra
      || frame_header->refresh_frame_flags !=
      (1 << GST_AV1_NUM_REF_FRAMES) - 1) {
    if (frame_header->error_resilient_mode && seq_header->enable_order_hint) {
      for (i = 0; i < GST_AV1_NUM_REF_FRAMES; i++)
        WRITE_BITS (bw, frame_header->ref_order_hint[i],
            seq_header->order_hint_bits_minus_1 + 1);
    }
  }

  if (frame_header->frame_is_intra) {
    if (!_av1_bit_writer_frame_size (frame_header, seq_header, bw, space))
      goto error;

    if (!_av1_bit_writer_render_size (frame_header, bw, space))
      goto error;

    if (frame_header->allow_screen_content_tools
        && frame_header->upscaled_width == frame_header->frame_width)
      WRITE_BITS (bw, frame_header->allow_intrabc, 1);
  } else {
    if (seq_header->enable_order_hint) {
      WRITE_BITS (bw, frame_header->frame_refs_short_signaling, 1);

      if (frame_header->frame_refs_short_signaling) {
        WRITE_BITS (bw, frame_header->last_frame_idx, 3);
        WRITE_BITS (bw, frame_header->gold_frame_idx, 3);
      }
    }

    for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++) {
      if (!frame_header->frame_refs_short_signaling)
        WRITE_BITS (bw, frame_header->ref_frame_idx[i], 3);

      if (seq_header->frame_id_numbers_present_flag) {
        gint32 delta_frame_id /* DeltaFrameId */ ;

        if (id_len <= 0)
          goto error;

        delta_frame_id =
            frame_header->current_frame_id - frame_header->expected_frame_id[i];
        delta_frame_id = delta_frame_id + (1 << id_len);
        delta_frame_id = delta_frame_id % (1 << id_len);
        WRITE_BITS (bw, delta_frame_id - 1,
            seq_header->delta_frame_id_length_minus_2 + 2);
      }
    }

    if (frame_header->frame_size_override_flag
        && !frame_header->error_resilient_mode) {
      /* 5.9.7 */
      /* TODO: reuse reference frame width/height. Just disable now. */
      for (i = 0; i < GST_AV1_REFS_PER_FRAME; i++)
        WRITE_BITS (bw, 0, 1);
    }

    if (!_av1_bit_writer_frame_size (frame_header, seq_header, bw, space))
      goto error;

    if (!_av1_bit_writer_render_size (frame_header, bw, space))
      goto error;

    if (!frame_header->force_integer_mv)
      WRITE_BITS (bw, frame_header->allow_high_precision_mv, 1);

    WRITE_BITS (bw, frame_header->is_filter_switchable, 1);
    if (!frame_header->is_filter_switchable)
      WRITE_BITS (bw, frame_header->interpolation_filter, 2);

    WRITE_BITS (bw, frame_header->is_motion_mode_switchable, 1);

    if (!(frame_header->error_resilient_mode
            || !seq_header->enable_ref_frame_mvs))
      WRITE_BITS (bw, frame_header->use_ref_frame_mvs, 1);
  }

  if (!(seq_header->reduced_still_picture_header
          || frame_header->disable_cdf_update))
    WRITE_BITS (bw, frame_header->disable_frame_end_update_cdf, 1);

  if (!_av1_bit_writer_tile_info (frame_header, seq_header, bw, space))
    goto error;

  if (!_av1_bit_writer_quantization_params (frame_header, seq_header,
          qindex_offset, bw, space))
    goto error;

  if (!_av1_bit_writer_segmentation_params (frame_header, seq_header,
          segmentation_offset, bw, space))
    goto error;

  if (!_av1_bit_writer_delta_q_params (frame_header, seq_header, bw, space))
    goto error;

  if (!_av1_bit_writer_delta_lf_params (frame_header, seq_header, bw, space))
    goto error;

  if (!_av1_bit_writer_loop_filter_params (frame_header, seq_header,
          loopfilter_offset, bw, space))
    goto error;

  if (!_av1_bit_writer_cdef_params (frame_header, seq_header,
          cdef_offset, cdef_size, bw, space))
    goto error;

  if (!_av1_bit_writer_loop_restoration_params (frame_header, seq_header,
          bw, space))
    goto error;

  /* 5.9.21 tx_mode() */
  if (frame_header->coded_lossless != 1) {
    /* Write the tx_mode_select bit. */
    if (frame_header->tx_mode == GST_AV1_TX_MODE_SELECT) {
      WRITE_BITS (bw, 1, 1);
    } else {
      WRITE_BITS (bw, 0, 1);
    }
  }

  /* 5.9.23 inlined frame_reference_mode () */
  if (!frame_header->frame_is_intra)
    WRITE_BITS (bw, frame_header->reference_select, 1);

  if (!_av1_bit_writer_skip_mode_params (frame_header, seq_header, bw, space))
    goto error;

  if (!(frame_header->frame_is_intra || frame_header->error_resilient_mode ||
          !seq_header->enable_warped_motion))
    WRITE_BITS (bw, frame_header->allow_warped_motion, 1);

  WRITE_BITS (bw, frame_header->reduced_tx_set, 1);

  if (!_av1_bit_writer_global_motion_params (frame_header,
          seq_header, bw, space))
    goto error;

  if (!_av1_bit_writer_film_grain_params (frame_header, seq_header, bw, space))
    goto error;

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write frame header");
  *space = have_space;
  return FALSE;
}

/**
 * gst_av1_bit_writer_frame_header_obu:
 * @frame_hdr: the frame header of #GstAV1FrameHeaderOBU to write
 * @seq_hdr: the sequence header of #GstAV1SequenceHeaderOBU to refer
 * @temporal_id: specifies the temporal level of the data contained in the OBU.
 * @spatial_id: specifies the spatial level of the data contained in the OBU.
 * @size_field: whether the OBU header contains the OBU size.
 * @data: (out): the bit stream generated by the frame header
 * @size: (inout): the size in bytes of the input and output
 *
 * Generating the according AV1 bit stream OBU by providing the frame header.
 *
 * Returns: a #GstAV1BitWriterResult
 *
 * Since: 1.22
 **/
GstAV1BitWriterResult
gst_av1_bit_writer_frame_header_obu (const GstAV1FrameHeaderOBU * frame_hdr,
    const GstAV1SequenceHeaderOBU * seq_hdr, guint8 temporal_id,
    guint8 spatial_id, gboolean size_field, guint8 * data, guint * size)
{
  return gst_av1_bit_writer_frame_header_obu_with_offsets (frame_hdr, seq_hdr,
      temporal_id, spatial_id, size_field, 0, NULL, NULL, NULL, NULL, NULL,
      data, size);
}

/**
 * gst_av1_bit_writer_frame_header_obu_with_offsets:
 * @frame_hdr: the frame header of #GstAV1FrameHeaderOBU to write
 * @seq_hdr: the sequence header of #GstAV1SequenceHeaderOBU to refer
 * @temporal_id: specifies the temporal level of the data contained in the OBU.
 * @spatial_id: specifies the spatial level of the data contained in the OBU.
 * @size_field: whether the OBU header contains the OBU size.
 * @size_field_size: >0 means a fixed OBU header size field.
 * @qindex_offset: (out): return the qindex fields offset in bits.
 * @segmentation_offset: (out): return the segmentation fields offset in bits.
 * @lf_offset: (out): return the loopfilter fields offset in bits.
 * @cdef_offset: (out): return the cdef fields offset in bits.
 * @cdef_size: (out): return the cdef fields size in bits.
 * @data: (out): the bit stream generated by the frame header
 * @size: (inout): the size in bytes of the input and output
 *
 * While Generating the according AV1 bit stream OBU by providing the frame
 * header, this function also return bit offsets of qindex, segmentation and
 * cdef, etc. These offsets can help to change the content of these fields
 * later. This function is useful if the encoder may change the content of
 * the frame header after generating it. For example, some HW needs user to
 * provide a frame header before the real encoding job, and it will change
 * the according fields in the frame header during the real encoding job.
 *
 * Returns: a #GstAV1BitWriterResult
 *
 * Since: 1.22
 **/
GstAV1BitWriterResult
gst_av1_bit_writer_frame_header_obu_with_offsets (const GstAV1FrameHeaderOBU *
    frame_hdr, const GstAV1SequenceHeaderOBU * seq_hdr, guint8 temporal_id,
    guint8 spatial_id, gboolean size_field, guint size_field_size,
    guint * qindex_offset, guint * segmentation_offset, guint * lf_offset,
    guint * cdef_offset, guint * cdef_size, guint8 * data, guint * size)
{
  gboolean have_space = TRUE;
  GstBitWriter bw;
  guint payload_size;
  guint header_size;

  g_return_val_if_fail (frame_hdr != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (seq_hdr != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (temporal_id < GST_AV1_MAX_NUM_TEMPORAL_LAYERS,
      GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (spatial_id < GST_AV1_MAX_NUM_SPATIAL_LAYERS,
      GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (data != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (size != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (*size > 0, GST_AV1_BIT_WRITER_ERROR);

  gst_bit_writer_init_with_data (&bw, data, *size, FALSE);

  WRITE_BITS (&bw, 0, 1);
  /* obu_type */
  WRITE_BITS (&bw, GST_AV1_OBU_FRAME_HEADER, 4);
  /* obu_extention_flag */
  if (temporal_id > 0 || spatial_id > 0) {
    WRITE_BITS (&bw, 1, 1);
  } else {
    WRITE_BITS (&bw, 0, 1);
  }

  /* obu_has_size_field */
  if (size_field > 0) {
    WRITE_BITS (&bw, 1, 1);
  } else {
    WRITE_BITS (&bw, 0, 1);
  }
  /* obu_reserved_1bit */
  WRITE_BITS (&bw, 0, 1);

  header_size = 1;

  /* 5.3.3 OBU extension header */
  if (temporal_id > 0 || spatial_id > 0) {
    WRITE_BITS (&bw, temporal_id, 3);
    WRITE_BITS (&bw, spatial_id, 2);
    /* obu_extension_header_reserved_3bits */
    WRITE_BITS (&bw, 0, 3);
    header_size = 2;
  }

  /* Write size field later */

  if (!_av1_bit_writer_uncompressed_frame_header (frame_hdr, seq_hdr,
          temporal_id, spatial_id, qindex_offset, segmentation_offset,
          lf_offset, cdef_offset, cdef_size, &bw, &have_space))
    goto error;

  /* Add trailings. */
  WRITE_BITS (&bw, 1, 1);
  if (!gst_bit_writer_align_bytes (&bw, 0)) {
    have_space = FALSE;
    goto error;
  }

  payload_size = gst_bit_writer_get_size (&bw);
  g_assert (payload_size % 8 == 0);
  payload_size /= 8;
  payload_size -= header_size;

  gst_bit_writer_reset (&bw);

  if (size_field) {
    size_field_size = _av1_bit_writer_add_size_field (data, size,
        header_size, payload_size, size_field_size, &have_space);
    if (!size_field_size)
      goto error;
  } else {
    *size = header_size + payload_size;
    size_field_size = 0;
  }

  if (qindex_offset)
    *qindex_offset = *qindex_offset + size_field_size * 8;
  if (segmentation_offset)
    *segmentation_offset = *segmentation_offset + size_field_size * 8;
  if (lf_offset)
    *lf_offset = *lf_offset + size_field_size * 8;
  if (cdef_offset)
    *cdef_offset = *cdef_offset + size_field_size * 8;

  return GST_AV1_BIT_WRITER_OK;

error:
  gst_bit_writer_reset (&bw);
  *size = 0;
  return have_space ? GST_AV1_BIT_WRITER_INVALID_DATA :
      GST_AV1_BIT_WRITER_NO_MORE_SPACE;
}

/**
 * gst_av1_bit_writer_temporal_delimiter_obu:
 * @size_field: whether the header contain size feild
 * @data: (out): the bit stream generated
 * @size: (inout): the size in bytes of the input and output
 *
 * Generating the according temporal delimiter AV1 bit stream OBU.
 *
 * Returns: a #GstAV1BitWriterResult
 *
 * Since: 1.22
 **/
GstAV1BitWriterResult
gst_av1_bit_writer_temporal_delimiter_obu (gboolean size_field,
    guint8 * data, guint * size)
{
  gboolean have_space = TRUE;
  GstBitWriter bw;

  g_return_val_if_fail (data != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (size != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (*size > 0, GST_AV1_BIT_WRITER_ERROR);

  gst_bit_writer_init_with_data (&bw, data, *size, FALSE);

  /* obu_forbidden_bit */
  WRITE_BITS (&bw, 0, 1);
  /* obu_type */
  WRITE_BITS (&bw, GST_AV1_OBU_TEMPORAL_DELIMITER, 4);
  /* obu_extention_flag */
  WRITE_BITS (&bw, 0, 1);
  /* obu_has_size_field */
  if (size_field) {
    WRITE_BITS (&bw, 1, 1);
  } else {
    WRITE_BITS (&bw, 0, 1);
  }
  /* obu_reserved_1bit */
  WRITE_BITS (&bw, 0, 1);

  /* No need to add trailings */

  /* header_size is 1 and payload_size is 0 */
  if (size_field) {
    if (!_av1_bit_writer_add_size_field (data, size, 1, 0, 0, &have_space))
      goto error;
  } else {
    *size = 1 + 0;
  }

  return GST_AV1_BIT_WRITER_OK;

error:
  gst_bit_writer_reset (&bw);
  *size = 0;
  return have_space ? GST_AV1_BIT_WRITER_INVALID_DATA :
      GST_AV1_BIT_WRITER_NO_MORE_SPACE;
}

/* 5.8.2 */
static gboolean
_av1_bit_writer_metadata_itut_t35 (const GstAV1MetadataITUT_T35 * itut_t35,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing metadata itut t35");

  WRITE_BITS (bw, itut_t35->itu_t_t35_country_code, 8);

  if (itut_t35->itu_t_t35_country_code == 0xFF)
    WRITE_BITS (bw, itut_t35->itu_t_t35_country_code_extention_byte, 8);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write metadata itut t35");
  *space = have_space;
  return FALSE;
}

/* 5.8.3 */
static gboolean
_av1_bit_writer_metadata_hdr_cll (const GstAV1MetadataHdrCll * hdr_cll,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;

  GST_DEBUG ("writing metadata hdr cll");

  WRITE_BITS (bw, hdr_cll->max_cll, 16);
  WRITE_BITS (bw, hdr_cll->max_fall, 16);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write metadata hdr cll");
  *space = have_space;
  return FALSE;
}

/* 5.8.4 */
static gboolean
_av1_bit_writer_metadata_hdr_mdcv (const GstAV1MetadataHdrMdcv * hdr_mdcv,
    GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  gint i;

  GST_DEBUG ("writing metadata hdr mdcv");

  for (i = 0; i < 3; i++) {
    WRITE_BITS (bw, hdr_mdcv->primary_chromaticity_x[i], 16);
    WRITE_BITS (bw, hdr_mdcv->primary_chromaticity_y[i], 16);
  }

  WRITE_BITS (bw, hdr_mdcv->white_point_chromaticity_x, 16);
  WRITE_BITS (bw, hdr_mdcv->white_point_chromaticity_y, 16);

  WRITE_BITS (bw, hdr_mdcv->luminance_max, 32);
  WRITE_BITS (bw, hdr_mdcv->luminance_min, 32);

  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write metadata hdr mdcv");
  *space = have_space;
  return FALSE;
}

/* 5.8.5 */
static gboolean
_av1_bit_writer_metadata_scalability (const GstAV1MetadataScalability *
    scalability, GstBitWriter * bw, gboolean * space)
{
  gboolean have_space = TRUE;
  guint i, j;

  GST_DEBUG ("writing metadata scalability");

  WRITE_BITS (bw, scalability->scalability_mode_idc, 8);

  if (scalability->scalability_mode_idc != GST_AV1_SCALABILITY_SS)
    goto success;

  /* 5.8.6 */
  WRITE_BITS (bw, scalability->spatial_layers_cnt_minus_1, 2);
  WRITE_BITS (bw, scalability->spatial_layer_dimensions_present_flag, 1);
  WRITE_BITS (bw, scalability->spatial_layer_description_present_flag, 1);
  WRITE_BITS (bw, scalability->temporal_group_description_present_flag, 1);
  /* scalability_structure_reserved_3bits */
  WRITE_BITS (bw, 0, 3);

  if (scalability->spatial_layer_dimensions_present_flag) {
    for (i = 0; i <= scalability->spatial_layers_cnt_minus_1; i++) {
      WRITE_BITS (bw, scalability->spatial_layer_max_width[i], 16);
      WRITE_BITS (bw, scalability->spatial_layer_max_height[i], 16);
    }
  }

  if (scalability->spatial_layer_description_present_flag) {
    for (i = 0; i <= scalability->spatial_layers_cnt_minus_1; i++)
      WRITE_BITS (bw, scalability->spatial_layer_ref_id[i], 8);
  }

  if (scalability->temporal_group_description_present_flag) {
    WRITE_BITS (bw, scalability->temporal_group_size, 8);

    for (i = 0; i < scalability->temporal_group_size; i++) {
      WRITE_BITS (bw, scalability->temporal_group_temporal_id[i], 3);
      WRITE_BITS (bw,
          scalability->temporal_group_temporal_switching_up_point_flag[i], 1);
      WRITE_BITS (bw,
          scalability->temporal_group_spatial_switching_up_point_flag[i], 1);
      WRITE_BITS (bw, scalability->temporal_group_ref_cnt[i], 3);
      for (j = 0; j < scalability->temporal_group_ref_cnt[i]; j++)
        WRITE_BITS (bw, scalability->temporal_group_ref_pic_diff[i][j], 8);
    }
  }

success:
  *space = TRUE;
  return TRUE;

error:
  GST_WARNING ("failed to write metadata scalability");
  *space = have_space;
  return FALSE;
}

/**
 * gst_av1_bit_writer_metadata_obu:
 * @metadata: the meta data of #GstAV1MetadataOBU to write
 * @temporal_id: specifies the temporal level of the data contained in the OBU.
 * @spatial_id: specifies the spatial level of the data contained in the OBU.
 * @size_field: whether the header contain size feild
 * @data: (out): the bit stream generated by the meta data
 * @size: (inout): the size in bytes of the input and output
 *
 * Generating the according AV1 bit stream OBU by providing the meta data.
 *
 * Returns: a #GstAV1BitWriterResult
 *
 * Since: 1.22
 **/
GstAV1BitWriterResult
gst_av1_bit_writer_metadata_obu (const GstAV1MetadataOBU * metadata,
    guint8 temporal_id, guint8 spatial_id, gboolean size_field,
    guint8 * data, guint * size)
{
  gboolean have_space = TRUE;
  GstBitWriter bw;
  guint header_size;
  guint payload_size;
  guint8 metadata_type_data[4];
  guint metadata_size;
  guint i;

  g_return_val_if_fail (metadata != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (temporal_id < GST_AV1_MAX_NUM_TEMPORAL_LAYERS,
      GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (spatial_id < GST_AV1_MAX_NUM_SPATIAL_LAYERS,
      GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (data != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (size != NULL, GST_AV1_BIT_WRITER_ERROR);
  g_return_val_if_fail (*size > 0, GST_AV1_BIT_WRITER_ERROR);

  gst_bit_writer_init_with_data (&bw, data, *size, FALSE);

  /* obu_forbidden_bit */
  WRITE_BITS (&bw, 0, 1);
  /* obu_type */
  WRITE_BITS (&bw, GST_AV1_OBU_METADATA, 4);
  /* obu_extention_flag */
  if (temporal_id > 0 || spatial_id > 0) {
    WRITE_BITS (&bw, 1, 1);
  } else {
    WRITE_BITS (&bw, 0, 1);
  }
  /* obu_has_size_field */
  if (size_field) {
    WRITE_BITS (&bw, 1, 1);
  } else {
    WRITE_BITS (&bw, 0, 1);
  }
  /* obu_reserved_1bit */
  WRITE_BITS (&bw, 0, 1);

  header_size = 1;
  /* 5.3.3 OBU extension header */
  if (temporal_id > 0 || spatial_id > 0) {
    WRITE_BITS (&bw, temporal_id, 3);
    WRITE_BITS (&bw, spatial_id, 2);
    /* obu_extension_header_reserved_3bits */
    WRITE_BITS (&bw, 0, 3);
    header_size = 2;
  }

  /* Generate the metadata_type first */
  metadata_size = _av1_uleb_size_in_bytes (metadata->metadata_type);
  if (metadata_size > 4) {
    GST_WARNING ("Invalid metadata_type");
    goto error;
  }
  if (!_av1_encode_uleb (metadata->metadata_type,
          sizeof (metadata->metadata_type),
          metadata_type_data, metadata_size)) {
    GST_WARNING ("Failed to write metadata_type");
    goto error;
  }
  for (i = 0; i < metadata_size; i++)
    WRITE_BITS (&bw, metadata_type_data[i], 8);

  switch (metadata->metadata_type) {
    case GST_AV1_METADATA_TYPE_ITUT_T35:
      if (!_av1_bit_writer_metadata_itut_t35 (&metadata->itut_t35,
              &bw, &have_space))
        goto error;
      break;
    case GST_AV1_METADATA_TYPE_HDR_CLL:
      if (!_av1_bit_writer_metadata_hdr_cll (&metadata->hdr_cll,
              &bw, &have_space))
        goto error;
      break;
    case GST_AV1_METADATA_TYPE_HDR_MDCV:
      if (!_av1_bit_writer_metadata_hdr_mdcv (&metadata->hdr_mdcv,
              &bw, &have_space))
        goto error;
      break;
    case GST_AV1_METADATA_TYPE_SCALABILITY:
      if (!_av1_bit_writer_metadata_scalability (&metadata->scalability,
              &bw, &have_space))
        goto error;
      break;
    default:
      GST_WARNING ("Unsupported metadata_type");
      goto error;
  }

  /* Add trailings. */
  WRITE_BITS (&bw, 1, 1);
  if (!gst_bit_writer_align_bytes (&bw, 0)) {
    have_space = FALSE;
    goto error;
  }

  payload_size = gst_bit_writer_get_size (&bw);
  g_assert (payload_size % 8 == 0);
  payload_size /= 8;
  payload_size -= header_size;

  gst_bit_writer_reset (&bw);

  if (size_field) {
    if (!_av1_bit_writer_add_size_field (data, size,
            header_size, payload_size, 0, &have_space))
      goto error;
  } else {
    *size = header_size + payload_size;
  }

  return GST_AV1_BIT_WRITER_OK;

error:
  gst_bit_writer_reset (&bw);
  *size = 0;
  return have_space ? GST_AV1_BIT_WRITER_INVALID_DATA :
      GST_AV1_BIT_WRITER_NO_MORE_SPACE;
}