shithub: dav1d

ref: 67bab2ba199ad42e6d18aac1198ec059489d3c20
dir: /src/obu.c/

View raw version
/*
 * Copyright © 2018, VideoLAN and dav1d authors
 * Copyright © 2018, Two Orioles, LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"

#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>

#include "dav1d/data.h"

#include "common/intops.h"

#include "src/decode.h"
#include "src/getbits.h"
#include "src/levels.h"
#include "src/obu.h"
#include "src/ref.h"
#include "src/warpmv.h"

static int parse_seq_hdr(Dav1dContext *const c, GetBits *const gb) {
    const uint8_t *const init_ptr = gb->ptr;
    Av1SequenceHeader *const hdr = &c->seq_hdr;

#define DEBUG_SEQ_HDR 0

    hdr->profile = dav1d_get_bits(gb, 3);
    if (hdr->profile > 2) goto error;
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-profile: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    hdr->still_picture = dav1d_get_bits(gb, 1);
    hdr->reduced_still_picture_header = dav1d_get_bits(gb, 1);
    if (hdr->reduced_still_picture_header && !hdr->still_picture) goto error;
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-stillpicture_flags: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    if (hdr->reduced_still_picture_header) {
        hdr->timing_info_present = 0;
        hdr->decoder_model_info_present = 0;
        hdr->display_model_info_present = 0;
        hdr->num_operating_points = 1;
        hdr->operating_points[0].idc = 0;
        hdr->operating_points[0].major_level = dav1d_get_bits(gb, 3);
        hdr->operating_points[0].minor_level = dav1d_get_bits(gb, 2);
        hdr->operating_points[0].tier = 0;
        hdr->operating_points[0].decoder_model_param_present = 0;
        hdr->operating_points[0].display_model_param_present = 0;
    } else {
        hdr->timing_info_present = dav1d_get_bits(gb, 1);
        if (hdr->timing_info_present) {
            hdr->num_units_in_tick = dav1d_get_bits(gb, 32);
            hdr->time_scale = dav1d_get_bits(gb, 32);
            hdr->equal_picture_interval = dav1d_get_bits(gb, 1);
            if (hdr->equal_picture_interval)
                hdr->num_ticks_per_picture = dav1d_get_vlc(gb) + 1;

            hdr->decoder_model_info_present = dav1d_get_bits(gb, 1);
            if (hdr->decoder_model_info_present) {
                hdr->bitrate_scale = dav1d_get_bits(gb, 4);
                hdr->buffer_size_scale = dav1d_get_bits(gb, 4);
                hdr->encoder_decoder_buffer_delay_length = dav1d_get_bits(gb, 5) + 1;
                hdr->num_units_in_decoding_tick = dav1d_get_bits(gb, 32);
                hdr->buffer_removal_delay_length = dav1d_get_bits(gb, 5) + 1;
                hdr->frame_presentation_delay_length = dav1d_get_bits(gb, 5) + 1;
            }
        } else {
            hdr->decoder_model_info_present = 0;
        }
#if DEBUG_SEQ_HDR
        printf("SEQHDR: post-timinginfo: off=%ld\n",
               (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

        hdr->display_model_info_present = dav1d_get_bits(gb, 1);
        hdr->num_operating_points = dav1d_get_bits(gb, 5) + 1;
        for (int i = 0; i < c->seq_hdr.num_operating_points; i++) {
            struct Av1SequenceHeaderOperatingPoint *const op =
                &hdr->operating_points[i];
            op->idc = dav1d_get_bits(gb, 12);
            op->major_level = 2 + dav1d_get_bits(gb, 3);
            op->minor_level = dav1d_get_bits(gb, 2);
            op->tier = op->major_level > 3 ? dav1d_get_bits(gb, 1) : 0;
            op->decoder_model_param_present =
                hdr->decoder_model_info_present && dav1d_get_bits(gb, 1);
            if (op->decoder_model_param_present) {
                op->bitrate = dav1d_get_vlc(gb) + 1;
                op->buffer_size = dav1d_get_vlc(gb) + 1;
                op->cbr = dav1d_get_bits(gb, 1);
                op->decoder_buffer_delay =
                    dav1d_get_bits(gb, hdr->encoder_decoder_buffer_delay_length);
                op->encoder_buffer_delay =
                    dav1d_get_bits(gb, hdr->encoder_decoder_buffer_delay_length);
                op->low_delay_mode = dav1d_get_bits(gb, 1);
            }
            op->display_model_param_present =
                hdr->display_model_info_present && dav1d_get_bits(gb, 1);
            if (op->display_model_param_present) {
                op->initial_display_delay = dav1d_get_bits(gb, 4) + 1;
            }
        }
#if DEBUG_SEQ_HDR
        printf("SEQHDR: post-operating-points: off=%ld\n",
               (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    }

    hdr->width_n_bits = dav1d_get_bits(gb, 4) + 1;
    hdr->height_n_bits = dav1d_get_bits(gb, 4) + 1;
    hdr->max_width = dav1d_get_bits(gb, hdr->width_n_bits) + 1;
    hdr->max_height = dav1d_get_bits(gb, hdr->height_n_bits) + 1;
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-size: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->frame_id_numbers_present =
        hdr->reduced_still_picture_header ? 0 : dav1d_get_bits(gb, 1);
    if (hdr->frame_id_numbers_present) {
        hdr->delta_frame_id_n_bits = dav1d_get_bits(gb, 4) + 2;
        hdr->frame_id_n_bits = dav1d_get_bits(gb, 3) + hdr->delta_frame_id_n_bits + 1;
    }
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-frame-id-numbers-present: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    hdr->sb128 = dav1d_get_bits(gb, 1);
    hdr->filter_intra = dav1d_get_bits(gb, 1);
    hdr->intra_edge_filter = dav1d_get_bits(gb, 1);
    if (hdr->reduced_still_picture_header) {
        hdr->inter_intra = 0;
        hdr->masked_compound = 0;
        hdr->warped_motion = 0;
        hdr->dual_filter = 0;
        hdr->order_hint = 0;
        hdr->jnt_comp = 0;
        hdr->ref_frame_mvs = 0;
        hdr->order_hint_n_bits = 0;
        hdr->screen_content_tools = ADAPTIVE;
        hdr->force_integer_mv = ADAPTIVE;
    } else {
        hdr->inter_intra = dav1d_get_bits(gb, 1);
        hdr->masked_compound = dav1d_get_bits(gb, 1);
        hdr->warped_motion = dav1d_get_bits(gb, 1);
        hdr->dual_filter = dav1d_get_bits(gb, 1);
        hdr->order_hint = dav1d_get_bits(gb, 1);
        if (hdr->order_hint) {
            hdr->jnt_comp = dav1d_get_bits(gb, 1);
            hdr->ref_frame_mvs = dav1d_get_bits(gb, 1);
        } else {
            hdr->jnt_comp = 0;
            hdr->ref_frame_mvs = 0;
            hdr->order_hint_n_bits = 0;
        }
        hdr->screen_content_tools = dav1d_get_bits(gb, 1) ? ADAPTIVE : dav1d_get_bits(gb, 1);
    #if DEBUG_SEQ_HDR
        printf("SEQHDR: post-screentools: off=%ld\n",
               (gb->ptr - init_ptr) * 8 - gb->bits_left);
    #endif
        hdr->force_integer_mv = hdr->screen_content_tools ?
                                dav1d_get_bits(gb, 1) ? ADAPTIVE : dav1d_get_bits(gb, 1) : 2;
        if (hdr->order_hint)
            hdr->order_hint_n_bits = dav1d_get_bits(gb, 3) + 1;
    }
    hdr->super_res = dav1d_get_bits(gb, 1);
    hdr->cdef = dav1d_get_bits(gb, 1);
    hdr->restoration = dav1d_get_bits(gb, 1);
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-featurebits: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    const int hbd = dav1d_get_bits(gb, 1);
    hdr->bpc = hdr->profile == 2 && hbd ? 10U + 2 * dav1d_get_bits(gb, 1) : 8U + 2 * hbd;
    hdr->hbd = hdr->bpc > 8;
    const int monochrome = hdr->profile != 1 ? dav1d_get_bits(gb, 1) : 0;
    hdr->color_description_present = dav1d_get_bits(gb, 1);
    if (hdr->color_description_present) {
        hdr->pri = dav1d_get_bits(gb, 8);
        hdr->trc = dav1d_get_bits(gb, 8);
        hdr->mtrx = dav1d_get_bits(gb, 8);
    } else {
        hdr->pri = DAV1D_COLOR_PRI_UNKNOWN;
        hdr->trc = DAV1D_TRC_UNKNOWN;
        hdr->mtrx = DAV1D_MC_UNKNOWN;
    }
    if (monochrome) {
        hdr->color_range = dav1d_get_bits(gb, 1);
        hdr->layout = DAV1D_PIXEL_LAYOUT_I400;
        hdr->chr = DAV1D_CHR_UNKNOWN;
        hdr->separate_uv_delta_q = 0;
    } else if (hdr->pri == DAV1D_COLOR_PRI_BT709 &&
               hdr->trc == DAV1D_TRC_SRGB &&
               hdr->mtrx == DAV1D_MC_IDENTITY)
    {
        hdr->layout = DAV1D_PIXEL_LAYOUT_I444;
        hdr->color_range = 1;
        if (hdr->profile != 1 && !(hdr->profile == 2 && hdr->bpc == 12))
            goto error;
    } else {
        hdr->color_range = dav1d_get_bits(gb, 1);
        switch (hdr->profile) {
        case 0: hdr->layout = DAV1D_PIXEL_LAYOUT_I420; break;
        case 1: hdr->layout = DAV1D_PIXEL_LAYOUT_I444; break;
        case 2:
            if (hdr->bpc == 12) {
                hdr->layout = dav1d_get_bits(gb, 1) ?
                              dav1d_get_bits(gb, 1) ? DAV1D_PIXEL_LAYOUT_I420 :
                                                      DAV1D_PIXEL_LAYOUT_I422 :
                                                      DAV1D_PIXEL_LAYOUT_I444;
            } else
                hdr->layout = DAV1D_PIXEL_LAYOUT_I422;
            break;
        }
        if (hdr->layout == DAV1D_PIXEL_LAYOUT_I420)
            hdr->chr = dav1d_get_bits(gb, 2);
        hdr->separate_uv_delta_q = dav1d_get_bits(gb, 1);
    }
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-colorinfo: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    c->seq_hdr.film_grain_present = dav1d_get_bits(gb, 1);
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-filmgrain: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    dav1d_get_bits(gb, 1); // dummy bit

    return dav1d_flush_get_bits(gb) - init_ptr;

error:
    fprintf(stderr, "Error parsing sequence header\n");
    return -EINVAL;
}

static int read_frame_size(Dav1dContext *const c, GetBits *const gb,
                           const int use_ref)
{
    const Av1SequenceHeader *const seqhdr = &c->seq_hdr;
    Av1FrameHeader *const hdr = &c->frame_hdr;

    if (use_ref) {
        for (int i = 0; i < 7; i++) {
            if (dav1d_get_bits(gb, 1)) {
                Dav1dThreadPicture *const ref =
                    &c->refs[c->frame_hdr.refidx[i]].p;
                if (!ref->p.data[0]) return -1;
                // FIXME render_* may be wrong
                hdr->render_width = hdr->width = ref->p.p.w;
                hdr->render_height = hdr->height = ref->p.p.h;
                hdr->super_res = 0; // FIXME probably wrong
                return 0;
            }
        }
    }

    if (hdr->frame_size_override) {
        hdr->width = dav1d_get_bits(gb, seqhdr->width_n_bits) + 1;
        hdr->height = dav1d_get_bits(gb, seqhdr->height_n_bits) + 1;
    } else {
        hdr->width = seqhdr->max_width;
        hdr->height = seqhdr->max_height;
    }
    hdr->super_res = seqhdr->super_res && dav1d_get_bits(gb, 1);
    if (hdr->super_res) return -1; // FIXME
    hdr->have_render_size = dav1d_get_bits(gb, 1);
    if (hdr->have_render_size) {
        hdr->render_width = dav1d_get_bits(gb, seqhdr->width_n_bits) + 1;
        hdr->render_height = dav1d_get_bits(gb, seqhdr->height_n_bits) + 1;
    } else {
        hdr->render_width = hdr->width;
        hdr->render_height = hdr->height;
    }
    return 0;
}

static inline int tile_log2(int sz, int tgt) {
    int k;
    for (k = 0; (sz << k) < tgt; k++) ;
    return k;
}

static const Av1LoopfilterModeRefDeltas default_mode_ref_deltas = {
    .mode_delta = { 0, 0 },
    .ref_delta = { 1, 0, 0, 0, -1, 0, -1, -1 },
};

static int parse_frame_hdr(Dav1dContext *const c, GetBits *const gb,
                           const int have_trailing_bit)
{
    const uint8_t *const init_ptr = gb->ptr;
    const Av1SequenceHeader *const seqhdr = &c->seq_hdr;
    Av1FrameHeader *const hdr = &c->frame_hdr;
    int res;

#define DEBUG_FRAME_HDR 0

    hdr->show_existing_frame =
        !seqhdr->reduced_still_picture_header && dav1d_get_bits(gb, 1);
#if DEBUG_FRAME_HDR
    printf("HDR: post-show_existing_frame: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    if (hdr->show_existing_frame) {
        hdr->existing_frame_idx = dav1d_get_bits(gb, 3);
        if (seqhdr->frame_id_numbers_present)
            hdr->frame_id = dav1d_get_bits(gb, seqhdr->frame_id_n_bits);
        goto end;
    }

    hdr->frame_type = seqhdr->reduced_still_picture_header ? DAV1D_FRAME_TYPE_KEY : dav1d_get_bits(gb, 2);
    hdr->show_frame = seqhdr->reduced_still_picture_header || dav1d_get_bits(gb, 1);
    if (!hdr->show_frame)
        hdr->showable_frame = dav1d_get_bits(gb, 1);
    hdr->error_resilient_mode =
        (hdr->frame_type == DAV1D_FRAME_TYPE_KEY && hdr->show_frame) ||
        hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ||
        seqhdr->reduced_still_picture_header || dav1d_get_bits(gb, 1);
#if DEBUG_FRAME_HDR
    printf("HDR: post-frametype_bits: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->disable_cdf_update = dav1d_get_bits(gb, 1);
    hdr->allow_screen_content_tools = seqhdr->screen_content_tools == ADAPTIVE ?
                                 dav1d_get_bits(gb, 1) : seqhdr->screen_content_tools;
    if (hdr->allow_screen_content_tools)
        hdr->force_integer_mv = seqhdr->force_integer_mv == ADAPTIVE ?
                                dav1d_get_bits(gb, 1) : seqhdr->force_integer_mv;

    if (seqhdr->frame_id_numbers_present)
        hdr->frame_id = dav1d_get_bits(gb, seqhdr->frame_id_n_bits);

    hdr->frame_size_override = seqhdr->reduced_still_picture_header ? 0 :
                               hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ? 1 : dav1d_get_bits(gb, 1);
#if DEBUG_FRAME_HDR
    printf("HDR: post-frame_size_override_flag: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->frame_offset = seqhdr->order_hint ?
                        dav1d_get_bits(gb, seqhdr->order_hint_n_bits) : 0;
    hdr->primary_ref_frame = !hdr->error_resilient_mode && hdr->frame_type & 1 ?
                             dav1d_get_bits(gb, 3) : PRIMARY_REF_NONE;

    if (hdr->frame_type == DAV1D_FRAME_TYPE_KEY ||
        hdr->frame_type == DAV1D_FRAME_TYPE_INTRA)
    {
        hdr->refresh_frame_flags = (hdr->frame_type == DAV1D_FRAME_TYPE_KEY &&
                                    hdr->show_frame) ? 0xff : dav1d_get_bits(gb, 8);
        if (hdr->refresh_frame_flags != 0xff && hdr->error_resilient_mode && seqhdr->order_hint)
            for (int i = 0; i < 8; i++)
                dav1d_get_bits(gb, seqhdr->order_hint_n_bits);
        if ((res = read_frame_size(c, gb, 0)) < 0) goto error;
        hdr->allow_intrabc = hdr->allow_screen_content_tools &&
                             /* FIXME: no superres scaling && */ dav1d_get_bits(gb, 1);
        hdr->use_ref_frame_mvs = 0;
    } else {
        hdr->allow_intrabc = 0;
        hdr->refresh_frame_flags = hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ? 0xff :
                                   dav1d_get_bits(gb, 8);
        if (hdr->error_resilient_mode && seqhdr->order_hint)
            for (int i = 0; i < 8; i++)
                dav1d_get_bits(gb, seqhdr->order_hint_n_bits);
        hdr->frame_ref_short_signaling =
            seqhdr->order_hint && dav1d_get_bits(gb, 1);
        if (hdr->frame_ref_short_signaling) goto error; // FIXME
        for (int i = 0; i < 7; i++) {
            hdr->refidx[i] = dav1d_get_bits(gb, 3);
            if (seqhdr->frame_id_numbers_present)
                dav1d_get_bits(gb, seqhdr->delta_frame_id_n_bits);
        }
        const int use_ref = !hdr->error_resilient_mode &&
                            hdr->frame_size_override;
        if ((res = read_frame_size(c, gb, use_ref)) < 0) goto error;
        hdr->hp = !hdr->force_integer_mv && dav1d_get_bits(gb, 1);
        hdr->subpel_filter_mode = dav1d_get_bits(gb, 1) ? FILTER_SWITCHABLE :
                                                          dav1d_get_bits(gb, 2);
        hdr->switchable_motion_mode = dav1d_get_bits(gb, 1);
        hdr->use_ref_frame_mvs = !hdr->error_resilient_mode &&
            seqhdr->ref_frame_mvs && seqhdr->order_hint &&
            hdr->frame_type & 1 && dav1d_get_bits(gb, 1);
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-frametype-specific-bits: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    hdr->refresh_context = !seqhdr->reduced_still_picture_header &&
                           !hdr->disable_cdf_update && !dav1d_get_bits(gb, 1);
#if DEBUG_FRAME_HDR
    printf("HDR: post-refresh_context: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // tile data
    hdr->tiling.uniform = dav1d_get_bits(gb, 1);
    const int sbsz_min1 = (64 << seqhdr->sb128) - 1;
    int sbsz_log2 = 6 + seqhdr->sb128;
    int sbw = (hdr->width + sbsz_min1) >> sbsz_log2;
    int sbh = (hdr->height + sbsz_min1) >> sbsz_log2;
    int max_tile_width_sb = 4096 >> sbsz_log2, max_tile_height_sb;
    int max_tile_area_sb = 4096 * 2304 >> (2 * sbsz_log2);
    hdr->tiling.min_log2_cols = tile_log2(max_tile_width_sb, sbw);
    hdr->tiling.max_log2_cols = tile_log2(1, imin(sbw, 1024));
    hdr->tiling.max_log2_rows = tile_log2(1, imin(sbh, 1024));
    int min_log2_tiles = imax(tile_log2(max_tile_area_sb, sbw * sbh),
                              hdr->tiling.min_log2_cols);
    if (hdr->tiling.uniform) {
        for (hdr->tiling.log2_cols = hdr->tiling.min_log2_cols;
             hdr->tiling.log2_cols < hdr->tiling.max_log2_cols && dav1d_get_bits(gb, 1);
             hdr->tiling.log2_cols++) ;
        const int tile_w = 1 + ((sbw - 1) >> hdr->tiling.log2_cols);
        hdr->tiling.cols = 0;
        for (int sbx = 0; sbx < sbw; sbx += tile_w, hdr->tiling.cols++)
            hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx;
        hdr->tiling.min_log2_rows =
            imax(min_log2_tiles - hdr->tiling.log2_cols, 0);
        max_tile_height_sb = sbh >> hdr->tiling.min_log2_rows;

        for (hdr->tiling.log2_rows = hdr->tiling.min_log2_rows;
             hdr->tiling.log2_rows < hdr->tiling.max_log2_rows && dav1d_get_bits(gb, 1);
             hdr->tiling.log2_rows++) ;
        const int tile_h = 1 + ((sbh - 1) >> hdr->tiling.log2_rows);
        hdr->tiling.rows = 0;
        for (int sby = 0; sby < sbh; sby += tile_h, hdr->tiling.rows++)
            hdr->tiling.row_start_sb[hdr->tiling.rows] = sby;
    } else {
        hdr->tiling.cols = 0;
        int widest_tile = 0, max_tile_area_sb = sbw * sbh;
        for (int sbx = 0; sbx < sbw; hdr->tiling.cols++) {
            const int tile_w = 1 + dav1d_get_uniform(gb, imin(sbw - sbx,
                                                              max_tile_width_sb));
            hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx;
            sbx += tile_w;
            widest_tile = imax(widest_tile, tile_w);
        }
        hdr->tiling.log2_cols = tile_log2(1, hdr->tiling.cols);
        if (min_log2_tiles) max_tile_area_sb >>= min_log2_tiles + 1;
        max_tile_height_sb = imax(max_tile_area_sb / widest_tile, 1);

        hdr->tiling.rows = 0;
        for (int sby = 0; sby < sbh; hdr->tiling.rows++) {
            const int tile_h = 1 + dav1d_get_uniform(gb, imin(sbh - sby,
                                                              max_tile_height_sb));
            hdr->tiling.row_start_sb[hdr->tiling.rows] = sby;
            sby += tile_h;
        }
        hdr->tiling.log2_rows = tile_log2(1, hdr->tiling.rows);
    }
    hdr->tiling.col_start_sb[hdr->tiling.cols] = sbw;
    hdr->tiling.row_start_sb[hdr->tiling.rows] = sbh;
    if (hdr->tiling.log2_cols || hdr->tiling.log2_rows) {
        hdr->tiling.update = dav1d_get_bits(gb, hdr->tiling.log2_cols +
                                                hdr->tiling.log2_rows);
        hdr->tiling.n_bytes = dav1d_get_bits(gb, 2) + 1;
    } else {
        hdr->tiling.n_bytes = hdr->tiling.update = 0;
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-tiling: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // quant data
    hdr->quant.yac = dav1d_get_bits(gb, 8);
    hdr->quant.ydc_delta = dav1d_get_bits(gb, 1) ? dav1d_get_sbits(gb, 6) : 0;
    if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) {
        hdr->quant.udc_delta = dav1d_get_bits(gb, 1) ? dav1d_get_sbits(gb, 6) : 0;
        hdr->quant.uac_delta = dav1d_get_bits(gb, 1) ? dav1d_get_sbits(gb, 6) : 0;
        if (seqhdr->separate_uv_delta_q) {
            hdr->quant.vdc_delta = dav1d_get_bits(gb, 1) ? dav1d_get_sbits(gb, 6) : 0;
            hdr->quant.vac_delta = dav1d_get_bits(gb, 1) ? dav1d_get_sbits(gb, 6) : 0;
        } else {
            hdr->quant.vdc_delta = hdr->quant.udc_delta;
            hdr->quant.vac_delta = hdr->quant.uac_delta;
        }
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-quant: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->quant.qm = dav1d_get_bits(gb, 1);
    if (hdr->quant.qm) {
        hdr->quant.qm_y = dav1d_get_bits(gb, 4);
        hdr->quant.qm_u = dav1d_get_bits(gb, 4);
        hdr->quant.qm_v =
            seqhdr->separate_uv_delta_q ? (int)dav1d_get_bits(gb, 4) :
                                          hdr->quant.qm_u;
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-qm: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // segmentation data
    hdr->segmentation.enabled = dav1d_get_bits(gb, 1);
    if (hdr->segmentation.enabled) {
        if (hdr->primary_ref_frame == PRIMARY_REF_NONE) {
            hdr->segmentation.update_map = 1;
            hdr->segmentation.temporal = 0;
            hdr->segmentation.update_data = 1;
        } else {
            hdr->segmentation.update_map = dav1d_get_bits(gb, 1);
            hdr->segmentation.temporal =
                hdr->segmentation.update_map ? dav1d_get_bits(gb, 1) : 0;
            hdr->segmentation.update_data = dav1d_get_bits(gb, 1);
        }

        if (hdr->segmentation.update_data) {
            hdr->segmentation.seg_data.preskip = 0;
            hdr->segmentation.seg_data.last_active_segid = -1;
            for (int i = 0; i < NUM_SEGMENTS; i++) {
                Av1SegmentationData *const seg =
                    &hdr->segmentation.seg_data.d[i];
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_q = dav1d_get_sbits(gb, 8);
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_q = 0;
                }
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_y_v = dav1d_get_sbits(gb, 6);
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_y_v = 0;
                }
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_y_h = dav1d_get_sbits(gb, 6);
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_y_h = 0;
                }
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_u = dav1d_get_sbits(gb, 6);
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_u = 0;
                }
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_v = dav1d_get_sbits(gb, 6);
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_v = 0;
                }
                if (dav1d_get_bits(gb, 1)) {
                    seg->ref = dav1d_get_bits(gb, 3);
                    hdr->segmentation.seg_data.last_active_segid = i;
                    hdr->segmentation.seg_data.preskip = 1;
                } else {
                    seg->ref = -1;
                }
                if ((seg->skip = dav1d_get_bits(gb, 1))) {
                    hdr->segmentation.seg_data.last_active_segid = i;
                    hdr->segmentation.seg_data.preskip = 1;
                }
                if ((seg->globalmv = dav1d_get_bits(gb, 1))) {
                    hdr->segmentation.seg_data.last_active_segid = i;
                    hdr->segmentation.seg_data.preskip = 1;
                }
            }
        } else if (hdr->primary_ref_frame == PRIMARY_REF_NONE) {
            memset(&hdr->segmentation.seg_data, 0, sizeof(Av1SegmentationDataSet));
        } else {
            const int pri_ref = hdr->refidx[hdr->primary_ref_frame];
            hdr->segmentation.seg_data = c->refs[pri_ref].seg_data;
        }
    } else if (hdr->primary_ref_frame == PRIMARY_REF_NONE) {
        memset(&hdr->segmentation.seg_data, 0, sizeof(Av1SegmentationDataSet));
    } else {
        const int pri_ref = hdr->refidx[hdr->primary_ref_frame];
        hdr->segmentation.seg_data = c->refs[pri_ref].seg_data;
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-segmentation: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // delta q
    hdr->delta.q.present = hdr->quant.yac ? dav1d_get_bits(gb, 1) : 0;
    hdr->delta.q.res_log2 = hdr->delta.q.present ? dav1d_get_bits(gb, 2) : 0;
    hdr->delta.lf.present = hdr->delta.q.present && !hdr->allow_intrabc &&
                            dav1d_get_bits(gb, 1);
    hdr->delta.lf.res_log2 = hdr->delta.lf.present ? dav1d_get_bits(gb, 2) : 0;
    hdr->delta.lf.multi = hdr->delta.lf.present ? dav1d_get_bits(gb, 1) : 0;
#if DEBUG_FRAME_HDR
    printf("HDR: post-delta_q_lf_flags: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // derive lossless flags
    const int delta_lossless = !hdr->quant.ydc_delta && !hdr->quant.udc_delta &&
        !hdr->quant.uac_delta && !hdr->quant.vdc_delta && !hdr->quant.vac_delta;
    hdr->all_lossless = 1;
    for (int i = 0; i < NUM_SEGMENTS; i++) {
        hdr->segmentation.qidx[i] = hdr->segmentation.enabled ?
            iclip_u8(hdr->quant.yac + hdr->segmentation.seg_data.d[i].delta_q) :
            hdr->quant.yac;
        hdr->segmentation.lossless[i] =
            !hdr->segmentation.qidx[i] && delta_lossless;
        hdr->all_lossless &= hdr->segmentation.lossless[i];
    }

    // loopfilter
    if (hdr->all_lossless || hdr->allow_intrabc) {
        hdr->loopfilter.level_y[0] = hdr->loopfilter.level_y[1] = 0;
        hdr->loopfilter.level_u = hdr->loopfilter.level_v = 0;
        hdr->loopfilter.sharpness = 0;
        hdr->loopfilter.mode_ref_delta_enabled = 1;
        hdr->loopfilter.mode_ref_delta_update = 1;
        hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas;
    } else {
        hdr->loopfilter.level_y[0] = dav1d_get_bits(gb, 6);
        hdr->loopfilter.level_y[1] = dav1d_get_bits(gb, 6);
        if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 &&
            (hdr->loopfilter.level_y[0] || hdr->loopfilter.level_y[1]))
        {
            hdr->loopfilter.level_u = dav1d_get_bits(gb, 6);
            hdr->loopfilter.level_v = dav1d_get_bits(gb, 6);
        }
        hdr->loopfilter.sharpness = dav1d_get_bits(gb, 3);

        if (hdr->primary_ref_frame == PRIMARY_REF_NONE) {
            hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas;
        } else {
            const int ref = hdr->refidx[hdr->primary_ref_frame];
            hdr->loopfilter.mode_ref_deltas = c->refs[ref].lf_mode_ref_deltas;
        }
        hdr->loopfilter.mode_ref_delta_enabled = dav1d_get_bits(gb, 1);
        if (hdr->loopfilter.mode_ref_delta_enabled) {
            hdr->loopfilter.mode_ref_delta_update = dav1d_get_bits(gb, 1);
            if (hdr->loopfilter.mode_ref_delta_update) {
                for (int i = 0; i < 8; i++)
                    if (dav1d_get_bits(gb, 1))
                        hdr->loopfilter.mode_ref_deltas.ref_delta[i] =
                            dav1d_get_sbits(gb, 6);
                for (int i = 0; i < 2; i++)
                    if (dav1d_get_bits(gb, 1))
                        hdr->loopfilter.mode_ref_deltas.mode_delta[i] =
                            dav1d_get_sbits(gb, 6);
            }
        }
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-lpf: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // cdef
    if (!hdr->all_lossless && seqhdr->cdef && !hdr->allow_intrabc) {
        hdr->cdef.damping = dav1d_get_bits(gb, 2) + 3;
        hdr->cdef.n_bits = dav1d_get_bits(gb, 2);
        for (int i = 0; i < (1 << hdr->cdef.n_bits); i++) {
            hdr->cdef.y_strength[i] = dav1d_get_bits(gb, 6);
            if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400)
                hdr->cdef.uv_strength[i] = dav1d_get_bits(gb, 6);
        }
    } else {
        hdr->cdef.n_bits = 0;
        hdr->cdef.y_strength[0] = 0;
        hdr->cdef.uv_strength[0] = 0;
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-cdef: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // restoration
    if (!hdr->all_lossless && seqhdr->restoration && !hdr->allow_intrabc) {
        hdr->restoration.type[0] = dav1d_get_bits(gb, 2);
        if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) {
            hdr->restoration.type[1] = dav1d_get_bits(gb, 2);
            hdr->restoration.type[2] = dav1d_get_bits(gb, 2);
        }

        if (hdr->restoration.type[0] || hdr->restoration.type[1] ||
            hdr->restoration.type[2])
        {
            // Log2 of the restoration unit size.
            hdr->restoration.unit_size[0] = 6 + seqhdr->sb128;
            if (dav1d_get_bits(gb, 1)) {
                hdr->restoration.unit_size[0]++;
                if (!seqhdr->sb128)
                    hdr->restoration.unit_size[0] += dav1d_get_bits(gb, 1);
            }
            hdr->restoration.unit_size[1] = hdr->restoration.unit_size[0];
            if ((hdr->restoration.type[1] || hdr->restoration.type[2]) &&
                seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420)
            {
                hdr->restoration.unit_size[1] -= dav1d_get_bits(gb, 1);
            }
        } else {
            hdr->restoration.unit_size[0] = 8;
        }
    } else {
        hdr->restoration.type[0] = RESTORATION_NONE;
        hdr->restoration.type[1] = RESTORATION_NONE;
        hdr->restoration.type[2] = RESTORATION_NONE;
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-restoration: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    hdr->txfm_mode = hdr->all_lossless ? TX_4X4_ONLY :
                     dav1d_get_bits(gb, 1) ? TX_SWITCHABLE : TX_LARGEST;
#if DEBUG_FRAME_HDR
    printf("HDR: post-txfmmode: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->switchable_comp_refs = hdr->frame_type & 1 ? dav1d_get_bits(gb, 1) : 0;
#if DEBUG_FRAME_HDR
    printf("HDR: post-refmode: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->skip_mode_allowed = 0;
    if (hdr->switchable_comp_refs && hdr->frame_type & 1) {
        const unsigned poc = hdr->frame_offset;
        unsigned off_before[2] = { 0xFFFFFFFF, 0xFFFFFFFF };
        int off_after = -1;
        int off_before_idx[2], off_after_idx;
        for (int i = 0; i < 7; i++) {
            const unsigned refpoc = c->refs[hdr->refidx[i]].p.p.poc;

            const int diff = get_poc_diff(seqhdr->order_hint_n_bits, refpoc, poc);
            if (diff > 0) {
                if (off_after == -1 || get_poc_diff(seqhdr->order_hint_n_bits,
                                                    off_after, refpoc) > 0)
                {
                    off_after = refpoc;
                    off_after_idx = i;
                }
            } else if (diff < 0) {
                if (off_before[0] == 0xFFFFFFFFU ||
                    get_poc_diff(seqhdr->order_hint_n_bits,
                                 refpoc, off_before[0]) > 0)
                {
                    off_before[1] = off_before[0];
                    off_before[0] = refpoc;
                    off_before_idx[1] = off_before_idx[0];
                    off_before_idx[0] = i;
                } else if (refpoc != off_before[0] &&
                           (off_before[1] == 0xFFFFFFFFU ||
                            get_poc_diff(seqhdr->order_hint_n_bits,
                                         refpoc, off_before[1]) > 0))
                {
                    off_before[1] = refpoc;
                    off_before_idx[1] = i;
                }
            }
        }

        if (off_before[0] != 0xFFFFFFFFU && off_after != -1) {
            hdr->skip_mode_refs[0] = off_before_idx[0];
            hdr->skip_mode_refs[1] = off_after_idx;
            hdr->skip_mode_allowed = 1;
        } else if (off_before[0] != 0xFFFFFFFFU &&
                   off_before[1] != 0xFFFFFFFFU)
        {
            hdr->skip_mode_refs[0] = off_before_idx[0];
            hdr->skip_mode_refs[1] = off_before_idx[1];
            hdr->skip_mode_allowed = 1;
        }
    }
    hdr->skip_mode_enabled = hdr->skip_mode_allowed ? dav1d_get_bits(gb, 1) : 0;
#if DEBUG_FRAME_HDR
    printf("HDR: post-extskip: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->warp_motion = !hdr->error_resilient_mode && hdr->frame_type & 1 &&
        seqhdr->warped_motion && dav1d_get_bits(gb, 1);
#if DEBUG_FRAME_HDR
    printf("HDR: post-warpmotionbit: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
    hdr->reduced_txtp_set = dav1d_get_bits(gb, 1);
#if DEBUG_FRAME_HDR
    printf("HDR: post-reducedtxtpset: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    for (int i = 0; i < 7; i++)
        hdr->gmv[i] = dav1d_default_wm_params;

    if (hdr->frame_type & 1) {
        for (int i = 0; i < 7; i++) {
            hdr->gmv[i].type = !dav1d_get_bits(gb, 1) ? WM_TYPE_IDENTITY :
                                dav1d_get_bits(gb, 1) ? WM_TYPE_ROT_ZOOM :
                                dav1d_get_bits(gb, 1) ? WM_TYPE_TRANSLATION :
                                                  WM_TYPE_AFFINE;

            if (hdr->gmv[i].type == WM_TYPE_IDENTITY) continue;

            const WarpedMotionParams *const ref_gmv =
                hdr->primary_ref_frame == PRIMARY_REF_NONE ? &dav1d_default_wm_params :
                &c->refs[hdr->refidx[hdr->primary_ref_frame]].gmv[i];
            int32_t *const mat = hdr->gmv[i].matrix;
            const int32_t *const ref_mat = ref_gmv->matrix;
            int bits, shift;

            if (hdr->gmv[i].type >= WM_TYPE_ROT_ZOOM) {
                mat[2] = (1 << 16) + 2 *
                    dav1d_get_bits_subexp(gb, (ref_mat[2] - (1 << 16)) >> 1, 12);
                mat[3] = 2 * dav1d_get_bits_subexp(gb, ref_mat[3] >> 1, 12);

                bits = 12;
                shift = 10;
            } else {
                bits = 9 - !hdr->hp;
                shift = 13 + !hdr->hp;
            }

            if (hdr->gmv[i].type == WM_TYPE_AFFINE) {
                mat[4] = 2 * dav1d_get_bits_subexp(gb, ref_mat[4] >> 1, 12);
                mat[5] = (1 << 16) + 2 *
                    dav1d_get_bits_subexp(gb, (ref_mat[5] - (1 << 16)) >> 1, 12);
            } else {
                mat[4] = -mat[3];
                mat[5] = mat[2];
            }

            mat[0] = dav1d_get_bits_subexp(gb, ref_mat[0] >> shift, bits) * (1 << shift);
            mat[1] = dav1d_get_bits_subexp(gb, ref_mat[1] >> shift, bits) * (1 << shift);

            if (dav1d_get_shear_params(&hdr->gmv[i]))
                goto error;
        }
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-gmv: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    hdr->film_grain.present = seqhdr->film_grain_present &&
                              (hdr->show_frame || hdr->showable_frame) &&
                              dav1d_get_bits(gb, 1);
    if (hdr->film_grain.present) {
        hdr->film_grain.seed = dav1d_get_bits(gb, 16);
        hdr->film_grain.update = hdr->frame_type != DAV1D_FRAME_TYPE_INTER || dav1d_get_bits(gb, 1);
        if (!hdr->film_grain.update) {
            const int refidx = dav1d_get_bits(gb, 3);
            int i;
            for (i = 0; i < 7; i++)
                if (hdr->refidx[i] == refidx)
                    break;
            if (i == 7) goto error;
            hdr->film_grain.data = c->refs[refidx].film_grain;
        } else {
            Av1FilmGrainData *const fgd = &hdr->film_grain.data;

            fgd->num_y_points = dav1d_get_bits(gb, 4);
            if (fgd->num_y_points > 14) goto error;
            for (int i = 0; i < fgd->num_y_points; i++) {
                fgd->y_points[i][0] = dav1d_get_bits(gb, 8);
                if (i && fgd->y_points[i - 1][0] >= fgd->y_points[i][0])
                    goto error;
                fgd->y_points[i][1] = dav1d_get_bits(gb, 8);
            }

            fgd->chroma_scaling_from_luma =
                seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 && dav1d_get_bits(gb, 1);
            if (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I400 ||
                fgd->chroma_scaling_from_luma ||
                (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420 && !fgd->num_y_points))
            {
                fgd->num_uv_points[0] = fgd->num_uv_points[1] = 0;
            } else for (int pl = 0; pl < 2; pl++) {
                fgd->num_uv_points[pl] = dav1d_get_bits(gb, 4);
                if (fgd->num_uv_points[pl] > 10) goto error;
                for (int i = 0; i < fgd->num_uv_points[pl]; i++) {
                    fgd->uv_points[pl][i][0] = dav1d_get_bits(gb, 8);
                    if (i && fgd->uv_points[pl][i - 1][0] >= fgd->uv_points[pl][i][0])
                        goto error;
                    fgd->uv_points[pl][i][1] = dav1d_get_bits(gb, 8);
                }
            }

            if (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420 &&
                !!fgd->num_uv_points[0] != !!fgd->num_uv_points[1])
            {
                goto error;
            }

            fgd->scaling_shift = dav1d_get_bits(gb, 2) + 8;
            fgd->ar_coeff_lag = dav1d_get_bits(gb, 2);
            const int num_y_pos = 2 * fgd->ar_coeff_lag * (fgd->ar_coeff_lag + 1);
            if (fgd->num_y_points)
                for (int i = 0; i < num_y_pos; i++)
                    fgd->ar_coeffs_y[i] = dav1d_get_bits(gb, 8) - 128;
            for (int pl = 0; pl < 2; pl++)
                if (fgd->num_uv_points[pl] || fgd->chroma_scaling_from_luma) {
                    const int num_uv_pos = num_y_pos + !!fgd->num_y_points;
                    for (int i = 0; i < num_uv_pos; i++)
                        fgd->ar_coeffs_uv[pl][i] = dav1d_get_bits(gb, 8) - 128;
                }
            fgd->ar_coeff_shift = dav1d_get_bits(gb, 2) + 6;
            fgd->grain_scale_shift = dav1d_get_bits(gb, 2);
            for (int pl = 0; pl < 2; pl++)
                if (fgd->num_uv_points[pl]) {
                    fgd->uv_mult[pl] = dav1d_get_bits(gb, 8);
                    fgd->uv_luma_mult[pl] = dav1d_get_bits(gb, 8);
                    fgd->uv_offset[pl] = dav1d_get_bits(gb, 9);
                }
            fgd->overlap_flag = dav1d_get_bits(gb, 1);
            fgd->clip_to_restricted_range = dav1d_get_bits(gb, 1);
        }
    } else {
        memset(&hdr->film_grain.data, 0, sizeof(hdr->film_grain));
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-filmgrain: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

end:

    if (have_trailing_bit)
        dav1d_get_bits(gb, 1); // dummy bit

    return dav1d_flush_get_bits(gb) - init_ptr;

error:
    fprintf(stderr, "Error parsing frame header\n");
    return -EINVAL;
}

static int parse_tile_hdr(Dav1dContext *const c, GetBits *const gb) {
    const uint8_t *const init_ptr = gb->ptr;

    int have_tile_pos = 0;
    const int n_bits = c->frame_hdr.tiling.log2_cols +
                       c->frame_hdr.tiling.log2_rows;
    if (n_bits)
        have_tile_pos = dav1d_get_bits(gb, 1);

    if (have_tile_pos) {
        c->tile[c->n_tile_data].start = dav1d_get_bits(gb, n_bits);
        c->tile[c->n_tile_data].end = dav1d_get_bits(gb, n_bits);
    } else {
        c->tile[c->n_tile_data].start = 0;
        c->tile[c->n_tile_data].end = (1 << n_bits) - 1;
    }

    return dav1d_flush_get_bits(gb) - init_ptr;
}

int dav1d_parse_obus(Dav1dContext *const c, Dav1dData *const in) {
    GetBits gb;
    int res;

    dav1d_init_get_bits(&gb, in->data, in->sz);

    // obu header
    dav1d_get_bits(&gb, 1); // obu_forbidden_bit
    const enum ObuType type = dav1d_get_bits(&gb, 4);
    const int has_extension = dav1d_get_bits(&gb, 1);
    const int has_length_field = dav1d_get_bits(&gb, 1);
    if (!has_length_field) goto error;
    dav1d_get_bits(&gb, 1); // reserved
    if (has_extension) {
        dav1d_get_bits(&gb, 3); // temporal_layer_id
        dav1d_get_bits(&gb, 2); // enhancement_layer_id
        dav1d_get_bits(&gb, 3); // reserved
    }

    // obu length field
    int len = 0, more, i = 0;
    do {
        more = dav1d_get_bits(&gb, 1);
        len |= dav1d_get_bits(&gb, 7) << (i * 7);
        if (more && ++i == 8) goto error;
    } while (more);
    if (gb.error) goto error;

    int off = dav1d_flush_get_bits(&gb) - in->data;
    const int init_off = off;
    if (len > (int)in->sz - off) goto error;

    switch (type) {
    case OBU_SEQ_HDR:
        if ((res = parse_seq_hdr(c, &gb)) < 0)
            return res;
        if (res != len) goto error;
        c->have_seq_hdr = 1;
        c->have_frame_hdr = 0;
        break;
    case OBU_FRAME:
    case OBU_FRAME_HDR:
        if (!c->have_seq_hdr) goto error;
        if ((res = parse_frame_hdr(c, &gb, type == OBU_FRAME_HDR)) < 0)
            return res;
        c->have_frame_hdr = 1;
        for (int n = 0; n < c->n_tile_data; n++)
            dav1d_data_unref(&c->tile[n].data);
        c->n_tile_data = 0;
        c->tile_mask = 0;
        if (type == OBU_FRAME_HDR) break;
        off += res;
        // fall-through
    case OBU_TILE_GRP:
        if (!c->have_frame_hdr) goto error;
        if (c->n_tile_data >= 256) goto error;
        if ((res = parse_tile_hdr(c, &gb)) < 0)
            return res;
        off += res;
        if (off > len + init_off)
            goto error;
        dav1d_ref_inc(in->ref);
        c->tile[c->n_tile_data].data.ref = in->ref;
        c->tile[c->n_tile_data].data.data = in->data + off;
        c->tile[c->n_tile_data].data.sz = len + init_off - off;
        if (c->tile[c->n_tile_data].start > c->tile[c->n_tile_data].end) {
            for (int i = 0; i <= c->n_tile_data; i++)
                dav1d_data_unref(&c->tile[i].data);
            c->n_tile_data = 0;
            c->tile_mask = 0;
            goto error;
        }
#define mask(a) ((1 << (a)) - 1)
        const unsigned tile_mask = mask(c->tile[c->n_tile_data].end + 1) -
                                   mask(c->tile[c->n_tile_data].start);
#undef mask
        if (tile_mask & c->tile_mask) { // tile overlap
            for (int i = 0; i <= c->n_tile_data; i++)
                dav1d_data_unref(&c->tile[i].data);
            c->n_tile_data = 0;
            c->tile_mask = 0;
            goto error;
        }
        c->tile_mask |= tile_mask;
        c->n_tile_data++;
        break;
    case OBU_PADDING:
    case OBU_TD:
    case OBU_METADATA:
        // ignore OBUs we don't care about
        break;
    default:
        fprintf(stderr, "Unknown OBU type %d of size %d\n", type, len);
        return -EINVAL;
    }

    const int n_tiles = 1 << (c->frame_hdr.tiling.log2_cols +
                              c->frame_hdr.tiling.log2_rows);
    if (c->have_seq_hdr && c->have_frame_hdr &&
        c->tile_mask == (1U << n_tiles) - 1)
    {
        if (!c->n_tile_data)
            return -EINVAL;
        if ((res = dav1d_submit_frame(c)) < 0)
            return res;
        assert(!c->n_tile_data);
        c->have_frame_hdr = 0;
        c->tile_mask = 0;
    } else if (c->have_seq_hdr && c->have_frame_hdr &&
               c->frame_hdr.show_existing_frame)
    {
        if (c->n_fc == 1) {
            dav1d_picture_ref(&c->out,
                              &c->refs[c->frame_hdr.existing_frame_idx].p.p);
        } else {
            // need to append this to the frame output queue
            const unsigned next = c->frame_thread.next++;
            if (c->frame_thread.next == c->n_fc)
                c->frame_thread.next = 0;

            Dav1dFrameContext *const f = &c->fc[next];
            pthread_mutex_lock(&f->frame_thread.td.lock);
            while (f->n_tile_data > 0)
                pthread_cond_wait(&f->frame_thread.td.cond,
                                  &f->frame_thread.td.lock);
            Dav1dThreadPicture *const out_delayed =
                &c->frame_thread.out_delayed[next];
            if (out_delayed->p.data[0]) {
                if (out_delayed->visible && !out_delayed->flushed)
                    dav1d_picture_ref(&c->out, &out_delayed->p);
                dav1d_thread_picture_unref(out_delayed);
            }
            dav1d_thread_picture_ref(out_delayed,
                                     &c->refs[c->frame_hdr.existing_frame_idx].p);
            out_delayed->visible = 1;
            out_delayed->flushed = 0;
            pthread_mutex_unlock(&f->frame_thread.td.lock);
        }
        c->have_frame_hdr = 0;
        if (c->refs[c->frame_hdr.existing_frame_idx].p.p.p.type == DAV1D_FRAME_TYPE_KEY) {
            const int r = c->frame_hdr.existing_frame_idx;
            for (int i = 0; i < 8; i++) {
                if (i == c->frame_hdr.existing_frame_idx) continue;

                if (c->refs[i].p.p.data[0])
                    dav1d_thread_picture_unref(&c->refs[i].p);
                dav1d_thread_picture_ref(&c->refs[i].p, &c->refs[r].p);

                if (c->cdf[i].cdf) dav1d_cdf_thread_unref(&c->cdf[i]);
                dav1d_init_states(&c->cdf[i], c->refs[r].qidx);

                c->refs[i].lf_mode_ref_deltas = c->refs[r].lf_mode_ref_deltas;
                c->refs[i].seg_data = c->refs[r].seg_data;
                for (int j = 0; j < 7; j++)
                    c->refs[i].gmv[j] = dav1d_default_wm_params;
                c->refs[i].film_grain = c->refs[r].film_grain;

                if (c->refs[i].segmap)
                    dav1d_ref_dec(c->refs[i].segmap);
                c->refs[i].segmap = c->refs[r].segmap;
                if (c->refs[r].segmap)
                    dav1d_ref_inc(c->refs[r].segmap);
                if (c->refs[i].refmvs)
                    dav1d_ref_dec(c->refs[i].refmvs);
                c->refs[i].refmvs = NULL;
                c->refs[i].qidx = c->refs[r].qidx;
            }
        }
    }

    return len + init_off;

error:
    fprintf(stderr, "Error parsing OBU data\n");
    return -EINVAL;
}