obu.c 51.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
 * 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"

46
47
48
static int parse_seq_hdr(Dav1dContext *const c, GetBits *const gb,
                         Av1SequenceHeader *const hdr)
{
49
50
#define DEBUG_SEQ_HDR 0

51
52
53
54
#if DEBUG_SEQ_HDR
    const unsigned init_bit_pos = dav1d_get_bits_pos(gb);
#endif

55
    hdr->profile = dav1d_get_bits(gb, 3);
56
    if (hdr->profile > 2) goto error;
57
58
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-profile: off=%ld\n",
59
           dav1d_get_bits_pos(gb) - init_bit_pos);
60
61
#endif

62
63
    hdr->still_picture = dav1d_get_bits(gb, 1);
    hdr->reduced_still_picture_header = dav1d_get_bits(gb, 1);
64
65
66
    if (hdr->reduced_still_picture_header && !hdr->still_picture) goto error;
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-stillpicture_flags: off=%ld\n",
67
           dav1d_get_bits_pos(gb) - init_bit_pos);
68
69
70
71
72
73
74
75
#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;
76
77
        hdr->operating_points[0].major_level = dav1d_get_bits(gb, 3);
        hdr->operating_points[0].minor_level = dav1d_get_bits(gb, 2);
78
79
80
81
        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 {
82
        hdr->timing_info_present = dav1d_get_bits(gb, 1);
83
        if (hdr->timing_info_present) {
84
85
86
            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);
87
            if (hdr->equal_picture_interval)
88
                hdr->num_ticks_per_picture = dav1d_get_vlc(gb) + 1;
89

90
            hdr->decoder_model_info_present = dav1d_get_bits(gb, 1);
91
            if (hdr->decoder_model_info_present) {
92
93
94
95
                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;
96
97
98
99
100
101
            }
        } else {
            hdr->decoder_model_info_present = 0;
        }
#if DEBUG_SEQ_HDR
        printf("SEQHDR: post-timinginfo: off=%ld\n",
102
               dav1d_get_bits_pos(gb) - init_bit_pos);
103
104
#endif

105
106
        hdr->display_model_info_present = dav1d_get_bits(gb, 1);
        hdr->num_operating_points = dav1d_get_bits(gb, 5) + 1;
107
        for (int i = 0; i < hdr->num_operating_points; i++) {
108
109
            struct Av1SequenceHeaderOperatingPoint *const op =
                &hdr->operating_points[i];
110
111
112
113
            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;
114
            op->decoder_model_param_present =
115
                hdr->decoder_model_info_present && dav1d_get_bits(gb, 1);
116
117
            if (op->decoder_model_param_present) {
                op->decoder_buffer_delay =
118
                    dav1d_get_bits(gb, hdr->encoder_decoder_buffer_delay_length);
119
                op->encoder_buffer_delay =
120
121
                    dav1d_get_bits(gb, hdr->encoder_decoder_buffer_delay_length);
                op->low_delay_mode = dav1d_get_bits(gb, 1);
122
123
            }
            op->display_model_param_present =
124
                hdr->display_model_info_present && dav1d_get_bits(gb, 1);
125
            if (op->display_model_param_present) {
126
                op->initial_display_delay = dav1d_get_bits(gb, 4) + 1;
127
128
129
130
            }
        }
#if DEBUG_SEQ_HDR
        printf("SEQHDR: post-operating-points: off=%ld\n",
131
               dav1d_get_bits_pos(gb) - init_bit_pos);
132
133
134
#endif
    }

135
136
137
138
    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;
139
140
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-size: off=%ld\n",
141
           dav1d_get_bits_pos(gb) - init_bit_pos);
142
143
#endif
    hdr->frame_id_numbers_present =
144
        hdr->reduced_still_picture_header ? 0 : dav1d_get_bits(gb, 1);
145
    if (hdr->frame_id_numbers_present) {
146
147
        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;
148
149
150
    }
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-frame-id-numbers-present: off=%ld\n",
151
           dav1d_get_bits_pos(gb) - init_bit_pos);
152
153
#endif

154
155
156
    hdr->sb128 = dav1d_get_bits(gb, 1);
    hdr->filter_intra = dav1d_get_bits(gb, 1);
    hdr->intra_edge_filter = dav1d_get_bits(gb, 1);
157
158
159
160
161
162
163
164
165
166
167
168
    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 {
169
170
171
172
173
        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);
174
        if (hdr->order_hint) {
175
176
            hdr->jnt_comp = dav1d_get_bits(gb, 1);
            hdr->ref_frame_mvs = dav1d_get_bits(gb, 1);
177
178
179
180
181
        } else {
            hdr->jnt_comp = 0;
            hdr->ref_frame_mvs = 0;
            hdr->order_hint_n_bits = 0;
        }
182
        hdr->screen_content_tools = dav1d_get_bits(gb, 1) ? ADAPTIVE : dav1d_get_bits(gb, 1);
183
184
    #if DEBUG_SEQ_HDR
        printf("SEQHDR: post-screentools: off=%ld\n",
185
               dav1d_get_bits_pos(gb) - init_bit_pos);
186
187
    #endif
        hdr->force_integer_mv = hdr->screen_content_tools ?
188
                                dav1d_get_bits(gb, 1) ? ADAPTIVE : dav1d_get_bits(gb, 1) : 2;
189
        if (hdr->order_hint)
190
            hdr->order_hint_n_bits = dav1d_get_bits(gb, 3) + 1;
191
    }
192
193
194
    hdr->super_res = dav1d_get_bits(gb, 1);
    hdr->cdef = dav1d_get_bits(gb, 1);
    hdr->restoration = dav1d_get_bits(gb, 1);
195
196
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-featurebits: off=%ld\n",
197
           dav1d_get_bits_pos(gb) - init_bit_pos);
198
199
#endif

200
    const int hbd = dav1d_get_bits(gb, 1);
skal's avatar
skal committed
201
    hdr->bpc = hdr->profile == 2 && hbd ? 10U + 2 * dav1d_get_bits(gb, 1) : 8U + 2 * hbd;
202
    hdr->hbd = hdr->bpc > 8;
203
204
    const int monochrome = hdr->profile != 1 ? dav1d_get_bits(gb, 1) : 0;
    hdr->color_description_present = dav1d_get_bits(gb, 1);
205
    if (hdr->color_description_present) {
206
207
208
        hdr->pri = dav1d_get_bits(gb, 8);
        hdr->trc = dav1d_get_bits(gb, 8);
        hdr->mtrx = dav1d_get_bits(gb, 8);
209
210
211
212
213
214
    } else {
        hdr->pri = DAV1D_COLOR_PRI_UNKNOWN;
        hdr->trc = DAV1D_TRC_UNKNOWN;
        hdr->mtrx = DAV1D_MC_UNKNOWN;
    }
    if (monochrome) {
215
        hdr->color_range = dav1d_get_bits(gb, 1);
216
217
218
219
220
221
222
223
224
225
226
227
        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 {
228
        hdr->color_range = dav1d_get_bits(gb, 1);
229
230
231
232
233
        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) {
234
235
236
237
                hdr->layout = dav1d_get_bits(gb, 1) ?
                              dav1d_get_bits(gb, 1) ? DAV1D_PIXEL_LAYOUT_I420 :
                                                      DAV1D_PIXEL_LAYOUT_I422 :
                                                      DAV1D_PIXEL_LAYOUT_I444;
238
239
240
241
242
            } else
                hdr->layout = DAV1D_PIXEL_LAYOUT_I422;
            break;
        }
        if (hdr->layout == DAV1D_PIXEL_LAYOUT_I420)
243
244
            hdr->chr = dav1d_get_bits(gb, 2);
        hdr->separate_uv_delta_q = dav1d_get_bits(gb, 1);
245
246
247
    }
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-colorinfo: off=%ld\n",
248
           dav1d_get_bits_pos(gb) - init_bit_pos);
249
250
#endif

251
    hdr->film_grain_present = dav1d_get_bits(gb, 1);
252
253
#if DEBUG_SEQ_HDR
    printf("SEQHDR: post-filmgrain: off=%ld\n",
254
           dav1d_get_bits_pos(gb) - init_bit_pos);
255
256
#endif

257
    dav1d_get_bits(gb, 1); // dummy bit
258

259
260
261
262
263
    // We needn't bother flushing the OBU here: we'll check we didn't
    // overrun in the caller and will then discard gb, so there's no
    // point in setting its position properly.

    return 0;
264
265
266
267
268
269
270
271
272
273
274
275
276
277

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++) {
278
            if (dav1d_get_bits(gb, 1)) {
279
280
281
282
283
284
285
286
287
288
289
290
291
                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) {
292
293
        hdr->width = dav1d_get_bits(gb, seqhdr->width_n_bits) + 1;
        hdr->height = dav1d_get_bits(gb, seqhdr->height_n_bits) + 1;
294
295
296
297
    } else {
        hdr->width = seqhdr->max_width;
        hdr->height = seqhdr->max_height;
    }
298
    hdr->super_res = seqhdr->super_res && dav1d_get_bits(gb, 1);
299
    if (hdr->super_res) return -1; // FIXME
300
    hdr->have_render_size = dav1d_get_bits(gb, 1);
301
    if (hdr->have_render_size) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
302
303
        hdr->render_width = dav1d_get_bits(gb, 16) + 1;
        hdr->render_height = dav1d_get_bits(gb, 16) + 1;
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
    } 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 },
};

322
323
324
325
static int parse_frame_hdr(Dav1dContext *const c, GetBits *const gb) {
#define DEBUG_FRAME_HDR 0

#if DEBUG_FRAME_HDR
326
    const uint8_t *const init_ptr = gb->ptr;
327
#endif
328
329
330
331
332
    const Av1SequenceHeader *const seqhdr = &c->seq_hdr;
    Av1FrameHeader *const hdr = &c->frame_hdr;
    int res;

    hdr->show_existing_frame =
333
        !seqhdr->reduced_still_picture_header && dav1d_get_bits(gb, 1);
334
335
336
337
338
#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) {
339
        hdr->existing_frame_idx = dav1d_get_bits(gb, 3);
340
341
        if (seqhdr->decoder_model_info_present && !seqhdr->equal_picture_interval)
            hdr->frame_presentation_delay = dav1d_get_bits(gb, seqhdr->frame_presentation_delay_length);
342
        if (seqhdr->frame_id_numbers_present)
343
            hdr->frame_id = dav1d_get_bits(gb, seqhdr->frame_id_n_bits);
344
        return 0;
345
346
    }

347
348
    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);
349
350
351
352
    if (hdr->show_frame) {
        if (seqhdr->decoder_model_info_present && !seqhdr->equal_picture_interval)
            hdr->frame_presentation_delay = dav1d_get_bits(gb, seqhdr->frame_presentation_delay_length);
    } else
353
        hdr->showable_frame = dav1d_get_bits(gb, 1);
354
    hdr->error_resilient_mode =
355
356
        (hdr->frame_type == DAV1D_FRAME_TYPE_KEY && hdr->show_frame) ||
        hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ||
357
        seqhdr->reduced_still_picture_header || dav1d_get_bits(gb, 1);
358
359
360
361
#if DEBUG_FRAME_HDR
    printf("HDR: post-frametype_bits: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
362
    hdr->disable_cdf_update = dav1d_get_bits(gb, 1);
363
    hdr->allow_screen_content_tools = seqhdr->screen_content_tools == ADAPTIVE ?
364
                                 dav1d_get_bits(gb, 1) : seqhdr->screen_content_tools;
365
366
    if (hdr->allow_screen_content_tools)
        hdr->force_integer_mv = seqhdr->force_integer_mv == ADAPTIVE ?
367
                                dav1d_get_bits(gb, 1) : seqhdr->force_integer_mv;
368
369
370
371
372
    else
        hdr->force_integer_mv = 0;

    if (!(hdr->frame_type & 1))
        hdr->force_integer_mv = 1;
373
374

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

    hdr->frame_size_override = seqhdr->reduced_still_picture_header ? 0 :
378
                               hdr->frame_type == DAV1D_FRAME_TYPE_SWITCH ? 1 : dav1d_get_bits(gb, 1);
379
380
381
382
383
#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 ?
384
                        dav1d_get_bits(gb, seqhdr->order_hint_n_bits) : 0;
385
    hdr->primary_ref_frame = !hdr->error_resilient_mode && hdr->frame_type & 1 ?
386
                             dav1d_get_bits(gb, 3) : PRIMARY_REF_NONE;
387

388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
    if (seqhdr->decoder_model_info_present) {
        hdr->buffer_removal_time_present = dav1d_get_bits(gb, 1);
        if (hdr->buffer_removal_time_present) {
            for (int i = 0; i < c->seq_hdr.num_operating_points; i++) {
                const struct Av1SequenceHeaderOperatingPoint *const seqop = &seqhdr->operating_points[i];
                struct Av1FrameHeaderOperatingPoint *const op = &hdr->operating_points[i];
                if (seqop->decoder_model_param_present) {
                    int in_temporal_layer = (seqop->idc >>  0 /* FIXME: temporal_id */ ) & 1;
                    int in_spatial_layer  = (seqop->idc >> (0 /* FIXME: spatial_id */ + 8)) & 1;
                    if (!seqop->idc || in_temporal_layer || in_spatial_layer)
                        op->buffer_removal_time = dav1d_get_bits(gb, seqhdr->buffer_removal_delay_length);
                }
            }
        }
    }

James Almer's avatar
James Almer committed
404
405
406
407
408
    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);
409
410
411
        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);
412
413
        if ((res = read_frame_size(c, gb, 0)) < 0) goto error;
        hdr->allow_intrabc = hdr->allow_screen_content_tools &&
414
                             /* FIXME: no superres scaling && */ dav1d_get_bits(gb, 1);
415
416
        hdr->use_ref_frame_mvs = 0;
    } else {
James Almer's avatar
James Almer committed
417
418
419
420
421
422
423
424
425
426
427
428
429
        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);
430
        }
James Almer's avatar
James Almer committed
431
432
433
434
435
436
437
438
439
440
        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);
441
442
443
444
445
446
447
    }
#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 &&
448
                           !hdr->disable_cdf_update && !dav1d_get_bits(gb, 1);
449
450
451
452
453
454
#if DEBUG_FRAME_HDR
    printf("HDR: post-refresh_context: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // tile data
455
    hdr->tiling.uniform = dav1d_get_bits(gb, 1);
456
457
458
459
    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;
460
    int max_tile_width_sb = 4096 >> sbsz_log2;
461
462
    int max_tile_area_sb = 4096 * 2304 >> (2 * sbsz_log2);
    hdr->tiling.min_log2_cols = tile_log2(max_tile_width_sb, sbw);
463
464
    hdr->tiling.max_log2_cols = tile_log2(1, imin(sbw, MAX_TILE_COLS));
    hdr->tiling.max_log2_rows = tile_log2(1, imin(sbh, MAX_TILE_ROWS));
465
466
467
468
    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;
469
             hdr->tiling.log2_cols < hdr->tiling.max_log2_cols && dav1d_get_bits(gb, 1);
470
471
472
473
474
475
476
477
478
             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);

        for (hdr->tiling.log2_rows = hdr->tiling.min_log2_rows;
479
             hdr->tiling.log2_rows < hdr->tiling.max_log2_rows && dav1d_get_bits(gb, 1);
480
481
482
483
484
485
486
487
             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;
488
        for (int sbx = 0; sbx < sbw && hdr->tiling.cols < MAX_TILE_COLS; hdr->tiling.cols++) {
Luc Trudeau's avatar
Luc Trudeau committed
489
490
491
492
            const int tile_width_sb = imin(sbw - sbx, max_tile_width_sb);
            const int tile_w = (tile_width_sb > 1) ?
                                   1 + dav1d_get_uniform(gb, tile_width_sb) :
                                   1;
493
494
495
496
497
498
            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;
499
        int max_tile_height_sb = imax(max_tile_area_sb / widest_tile, 1);
500
501

        hdr->tiling.rows = 0;
502
        for (int sby = 0; sby < sbh && hdr->tiling.rows < MAX_TILE_ROWS; hdr->tiling.rows++) {
Luc Trudeau's avatar
Luc Trudeau committed
503
504
505
506
            const int tile_height_sb = imin(sbh - sby, max_tile_height_sb);
            const int tile_h = (tile_height_sb > 1) ?
                                   1 + dav1d_get_uniform(gb, tile_height_sb) :
                                   1;
507
508
509
510
511
512
513
514
            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) {
515
516
        hdr->tiling.update = dav1d_get_bits(gb, hdr->tiling.log2_cols +
                                                hdr->tiling.log2_rows);
517
518
        if (hdr->tiling.update >= hdr->tiling.cols * hdr->tiling.rows)
            goto error;
519
        hdr->tiling.n_bytes = dav1d_get_bits(gb, 2) + 1;
520
521
522
523
524
525
526
527
528
    } 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
529
530
    hdr->quant.yac = dav1d_get_bits(gb, 8);
    hdr->quant.ydc_delta = dav1d_get_bits(gb, 1) ? dav1d_get_sbits(gb, 6) : 0;
531
    if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) {
532
533
534
535
        // If the sequence header says that delta_q might be different
        // for U, V, we must check whether it actually is for this
        // frame.
        int diff_uv_delta = seqhdr->separate_uv_delta_q ? dav1d_get_bits(gb, 1) : 0;
536
537
        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;
538
        if (diff_uv_delta) {
539
540
            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;
541
542
543
544
545
546
547
548
549
        } 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
550
    hdr->quant.qm = dav1d_get_bits(gb, 1);
551
    if (hdr->quant.qm) {
552
553
        hdr->quant.qm_y = dav1d_get_bits(gb, 4);
        hdr->quant.qm_u = dav1d_get_bits(gb, 4);
skal's avatar
skal committed
554
555
556
        hdr->quant.qm_v =
            seqhdr->separate_uv_delta_q ? (int)dav1d_get_bits(gb, 4) :
                                          hdr->quant.qm_u;
557
558
559
560
561
562
563
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-qm: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // segmentation data
564
    hdr->segmentation.enabled = dav1d_get_bits(gb, 1);
565
566
567
568
569
570
    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 {
571
            hdr->segmentation.update_map = dav1d_get_bits(gb, 1);
572
            hdr->segmentation.temporal =
573
574
                hdr->segmentation.update_map ? dav1d_get_bits(gb, 1) : 0;
            hdr->segmentation.update_data = dav1d_get_bits(gb, 1);
575
576
577
578
579
580
581
582
        }

        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];
583
584
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_q = dav1d_get_sbits(gb, 8);
585
586
587
588
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_q = 0;
                }
589
590
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_y_v = dav1d_get_sbits(gb, 6);
591
592
593
594
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_y_v = 0;
                }
595
596
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_y_h = dav1d_get_sbits(gb, 6);
597
598
599
600
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_y_h = 0;
                }
601
602
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_u = dav1d_get_sbits(gb, 6);
603
604
605
606
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_u = 0;
                }
607
608
                if (dav1d_get_bits(gb, 1)) {
                    seg->delta_lf_v = dav1d_get_sbits(gb, 6);
609
610
611
612
                    hdr->segmentation.seg_data.last_active_segid = i;
                } else {
                    seg->delta_lf_v = 0;
                }
613
614
                if (dav1d_get_bits(gb, 1)) {
                    seg->ref = dav1d_get_bits(gb, 3);
615
616
617
618
619
                    hdr->segmentation.seg_data.last_active_segid = i;
                    hdr->segmentation.seg_data.preskip = 1;
                } else {
                    seg->ref = -1;
                }
620
                if ((seg->skip = dav1d_get_bits(gb, 1))) {
621
622
623
                    hdr->segmentation.seg_data.last_active_segid = i;
                    hdr->segmentation.seg_data.preskip = 1;
                }
624
                if ((seg->globalmv = dav1d_get_bits(gb, 1))) {
625
626
627
628
629
                    hdr->segmentation.seg_data.last_active_segid = i;
                    hdr->segmentation.seg_data.preskip = 1;
                }
            }
        } else {
630
631
632
            // segmentation.update_data was false so we should copy
            // segmentation data from the reference frame.
            assert(hdr->primary_ref_frame != PRIMARY_REF_NONE);
633
634
635
            const int pri_ref = hdr->refidx[hdr->primary_ref_frame];
            hdr->segmentation.seg_data = c->refs[pri_ref].seg_data;
        }
636
    } else {
Luc Trudeau's avatar
Luc Trudeau committed
637
        memset(&hdr->segmentation.seg_data, 0, sizeof(Av1SegmentationDataSet));
638
639
        for (int i = 0; i < NUM_SEGMENTS; i++)
            hdr->segmentation.seg_data.d[i].ref = -1;
640
641
642
643
644
645
646
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-segmentation: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

    // delta q
647
648
    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;
649
    hdr->delta.lf.present = hdr->delta.q.present && !hdr->allow_intrabc &&
650
651
652
                            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;
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
#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 {
680
681
        hdr->loopfilter.level_y[0] = dav1d_get_bits(gb, 6);
        hdr->loopfilter.level_y[1] = dav1d_get_bits(gb, 6);
682
683
684
        if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 &&
            (hdr->loopfilter.level_y[0] || hdr->loopfilter.level_y[1]))
        {
685
686
            hdr->loopfilter.level_u = dav1d_get_bits(gb, 6);
            hdr->loopfilter.level_v = dav1d_get_bits(gb, 6);
687
        }
688
        hdr->loopfilter.sharpness = dav1d_get_bits(gb, 3);
689
690
691
692
693
694
695

        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;
        }
696
        hdr->loopfilter.mode_ref_delta_enabled = dav1d_get_bits(gb, 1);
697
        if (hdr->loopfilter.mode_ref_delta_enabled) {
698
            hdr->loopfilter.mode_ref_delta_update = dav1d_get_bits(gb, 1);
699
700
            if (hdr->loopfilter.mode_ref_delta_update) {
                for (int i = 0; i < 8; i++)
701
                    if (dav1d_get_bits(gb, 1))
702
                        hdr->loopfilter.mode_ref_deltas.ref_delta[i] =
703
                            dav1d_get_sbits(gb, 6);
704
                for (int i = 0; i < 2; i++)
705
                    if (dav1d_get_bits(gb, 1))
706
                        hdr->loopfilter.mode_ref_deltas.mode_delta[i] =
707
                            dav1d_get_sbits(gb, 6);
708
709
710
711
712
713
714
715
716
717
            }
        }
    }
#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) {
718
719
        hdr->cdef.damping = dav1d_get_bits(gb, 2) + 3;
        hdr->cdef.n_bits = dav1d_get_bits(gb, 2);
720
        for (int i = 0; i < (1 << hdr->cdef.n_bits); i++) {
721
            hdr->cdef.y_strength[i] = dav1d_get_bits(gb, 6);
722
            if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400)
723
                hdr->cdef.uv_strength[i] = dav1d_get_bits(gb, 6);
724
725
726
727
728
729
730
731
732
733
734
735
736
        }
    } 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) {
737
        hdr->restoration.type[0] = dav1d_get_bits(gb, 2);
738
        if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) {
739
740
            hdr->restoration.type[1] = dav1d_get_bits(gb, 2);
            hdr->restoration.type[2] = dav1d_get_bits(gb, 2);
741
742
743
        } else {
            hdr->restoration.type[1] =
            hdr->restoration.type[2] = RESTORATION_NONE;
744
745
746
747
748
749
750
        }

        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;
751
            if (dav1d_get_bits(gb, 1)) {
752
753
                hdr->restoration.unit_size[0]++;
                if (!seqhdr->sb128)
754
                    hdr->restoration.unit_size[0] += dav1d_get_bits(gb, 1);
755
756
757
758
759
            }
            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)
            {
760
                hdr->restoration.unit_size[1] -= dav1d_get_bits(gb, 1);
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
            }
        } 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 :
776
                     dav1d_get_bits(gb, 1) ? TX_SWITCHABLE : TX_LARGEST;
777
778
779
780
#if DEBUG_FRAME_HDR
    printf("HDR: post-txfmmode: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
781
    hdr->switchable_comp_refs = hdr->frame_type & 1 ? dav1d_get_bits(gb, 1) : 0;
782
783
784
785
786
#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;
787
    if (hdr->switchable_comp_refs && hdr->frame_type & 1 && seqhdr->order_hint) {
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
        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) {
824
825
            hdr->skip_mode_refs[0] = imin(off_before_idx[0], off_after_idx);
            hdr->skip_mode_refs[1] = imax(off_before_idx[0], off_after_idx);
826
827
828
829
            hdr->skip_mode_allowed = 1;
        } else if (off_before[0] != 0xFFFFFFFFU &&
                   off_before[1] != 0xFFFFFFFFU)
        {
830
831
            hdr->skip_mode_refs[0] = imin(off_before_idx[0], off_before_idx[1]);
            hdr->skip_mode_refs[1] = imax(off_before_idx[0], off_before_idx[1]);
832
833
834
            hdr->skip_mode_allowed = 1;
        }
    }
835
    hdr->skip_mode_enabled = hdr->skip_mode_allowed ? dav1d_get_bits(gb, 1) : 0;
836
837
838
839
840
#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 &&
841
        seqhdr->warped_motion && dav1d_get_bits(gb, 1);
842
843
844
845
#if DEBUG_FRAME_HDR
    printf("HDR: post-warpmotionbit: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif
846
    hdr->reduced_txtp_set = dav1d_get_bits(gb, 1);
847
848
849
850
851
852
#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++)
853
        hdr->gmv[i] = dav1d_default_wm_params;
854
855
856

    if (hdr->frame_type & 1) {
        for (int i = 0; i < 7; i++) {
857
858
859
            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 :
860
861
862
863
864
                                                  WM_TYPE_AFFINE;

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

            const WarpedMotionParams *const ref_gmv =
865
                hdr->primary_ref_frame == PRIMARY_REF_NONE ? &dav1d_default_wm_params :
866
867
868
869
870
871
872
                &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 *
873
874
                    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);
875
876
877
878
879
880
881
882
883

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

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

892
893
            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);
894

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

904
905
    hdr->film_grain.present = seqhdr->film_grain_present &&
                              (hdr->show_frame || hdr->showable_frame) &&
906
                              dav1d_get_bits(gb, 1);
907
    if (hdr->film_grain.present) {
908
909
        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);
910
        if (!hdr->film_grain.update) {
911
            const int refidx = dav1d_get_bits(gb, 3);
912
913
914
915
916
917
918
919
920
            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;

921
            fgd->num_y_points = dav1d_get_bits(gb, 4);
922
923
            if (fgd->num_y_points > 14) goto error;
            for (int i = 0; i < fgd->num_y_points; i++) {
924
                fgd->y_points[i][0] = dav1d_get_bits(gb, 8);
925
926
                if (i && fgd->y_points[i - 1][0] >= fgd->y_points[i][0])
                    goto error;
927
                fgd->y_points[i][1] = dav1d_get_bits(gb, 8);
928
929
930
            }

            fgd->chroma_scaling_from_luma =
931
                seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 && dav1d_get_bits(gb, 1);
932
933
934
935
936
937
            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++) {
938
                fgd->num_uv_points[pl] = dav1d_get_bits(gb, 4);
939
940
                if (fgd->num_uv_points[pl] > 10) goto error;
                for (int i = 0; i < fgd->num_uv_points[pl]; i++) {
941
                    fgd->uv_points[pl][i][0] = dav1d_get_bits(gb, 8);
942
943
                    if (i && fgd->uv_points[pl][i - 1][0] >= fgd->uv_points[pl][i][0])
                        goto error;
944
                    fgd->uv_points[pl][i][1] = dav1d_get_bits(gb, 8);
945
946
947
948
949
950
951
952
953
                }
            }

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

954
955
            fgd->scaling_shift = dav1d_get_bits(gb, 2) + 8;
            fgd->ar_coeff_lag = dav1d_get_bits(gb, 2);
956
957
958
            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++)
959
                    fgd->ar_coeffs_y[i] = dav1d_get_bits(gb, 8) - 128;
960
961
962
963
            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++)
964
                        fgd->ar_coeffs_uv[pl][i] = dav1d_get_bits(gb, 8) - 128;
965
                }
966
967
            fgd->ar_coeff_shift = dav1d_get_bits(gb, 2) + 6;
            fgd->grain_scale_shift = dav1d_get_bits(gb, 2);
968
969
            for (int pl = 0; pl < 2; pl++)
                if (fgd->num_uv_points[pl]) {
970
971
972
                    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);
973
                }
974
975
            fgd->overlap_flag = dav1d_get_bits(gb, 1);
            fgd->clip_to_restricted_range = dav1d_get_bits(gb, 1);
976
977
        }
    } else {
978
        memset(&hdr->film_grain.data, 0, sizeof(hdr->film_grain.data));
979
980
981
982
983
984
    }
#if DEBUG_FRAME_HDR
    printf("HDR: post-filmgrain: off=%ld\n",
           (gb->ptr - init_ptr) * 8 - gb->bits_left);
#endif

985
    return 0;
986
987
988
989
990
991

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

992
static void parse_tile_hdr(Dav1dContext *const c, GetBits *const gb) {
993
    int have_tile_pos = 0;
994
995
    const int n_tiles = c->frame_hdr.tiling.cols * c->frame_hdr.tiling.rows;
    if (n_tiles > 1)
996
        have_tile_pos = dav1d_get_bits(gb, 1);
997
998

    if (have_tile_pos) {
999
1000
        const int n_bits = c->frame_hdr.tiling.log2_cols +
                           c->frame_hdr.tiling.log2_rows;
1001
1002
        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);
1003
1004
    } else {
        c->tile[c->n_tile_data].start = 0;
1005
        c->tile[c->n_tile_data].end = n_tiles - 1;
1006
    }
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
}

// Check that we haven't read more than obu_len bytes from the buffer
// since init_bit_pos.
static int
check_for_overrun(GetBits *const gb, unsigned init_bit_pos, unsigned obu_len)
{
    // Make sure we haven't actually read past the end of the gb buffer
    if (gb->error) {
        fprintf(stderr, "Overrun in OBU bit buffer\n");
        return 1;
    }
1019

1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
    unsigned pos = dav1d_get_bits_pos(gb);

    // We assume that init_bit_pos was the bit position of the buffer
    // at some point in the past, so cannot be smaller than pos.
    assert (init_bit_pos <= pos);

    if (pos - init_bit_pos > 8 * obu_len) {
        fprintf(stderr, "Overrun in OBU bit buffer into next OBU\n");
        return 1;
    }

    return 0;
1032
1033
}

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

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

    // obu header
1041
1042
1043
1044
    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);
1045
    if (!has_length_field) goto error;
1046
    dav1d_get_bits(&gb, 1); // reserved
1047
    if (has_extension) {
1048
1049
1050
        dav1d_get_bits(&gb, 3); // temporal_layer_id
        dav1d_get_bits(&gb, 2); // enhancement_layer_id
        dav1d_get_bits(&gb, 3); // reserved
1051
1052
1053
    }

    // obu length field
1054
    unsigned len = 0, more, i = 0;
1055
    do {
1056
        more = dav1d_get_bits(&gb, 1);
1057
1058
1059
1060
1061
        unsigned bits = dav1d_get_bits(&gb, 7);
        if (i <= 3 || (i == 4 && bits < (1 << 4)))
            len |= bits << (i * 7);
        else if (bits)
            goto error;
1062
1063
1064
1065
        if (more && ++i == 8) goto error;
    } while (more);
    if (gb.error) goto error;

1066
1067
1068
1069
1070
1071
1072
    const unsigned init_bit_pos = dav1d_get_bits_pos(&gb);
    const unsigned init_byte_pos = init_bit_pos >> 3;
    const unsigned pkt_bytelen = init_byte_pos + len;

    // We must have read a whole number of bytes at this point (1 byte
    // for the header and whole bytes at a time when reading the
    // leb128 length field).
Rupert Swarbrick's avatar
Rupert Swarbrick committed
1073
    assert((init_bit_pos & 7) == 0);
1074
1075
1076
1077
1078
1079
1080
1081
1082

    // We also know that we haven't tried to read more than in->sz
    // bytes yet (otherwise the error flag would have been set by the
    // code in getbits.c)
    assert(in->sz >= init_byte_pos);

    // Make sure that there are enough bits left in the buffer for the
    // rest of the OBU.
    if (len > in->sz - init_byte_pos) goto error;
1083
1084

    switch (type) {
1085
1086
1087
    case OBU_SEQ_HDR: {
        Av1SequenceHeader hdr, *const hdr_ptr = c->have_seq_hdr ? &hdr : &c->seq_hdr;
        memset(hdr_ptr, 0, sizeof(*hdr_ptr));
1088
        c->have_frame_hdr = 0;
1089
        if ((res = parse_seq_hdr(c, &gb, hdr_ptr)) < 0)
1090
            return res;
1091
1092
        if (check_for_overrun(&gb, init_bit_pos, len))
            return -EINVAL;
1093
1094
1095
1096
        // If we have read a sequence header which is different from
        // the old one, this is a new video sequence and can't use any
        // previous state. Free that state.
        if (c->have_seq_hdr && memcmp(&hdr, &c->seq_hdr, sizeof(hdr))) {
1097
1098
1099
            for (int i = 0; i < 8; i++) {
                if (c->refs[i].p.p.data[0])
                    dav1d_thread_picture_unref(&c->refs[i].p);
1100
1101
                dav1d_ref_dec(&c->refs[i].segmap);
                dav1d_ref_dec(&c->refs[i].refmvs);
1102
1103
1104
                if (c->cdf[i].cdf)
                    dav1d_cdf_thread_unref(&c->cdf[i]);
            }
1105
            c->seq_hdr = hdr;
1106
        }
1107
1108
        c->have_seq_hdr = 1;
        break;
1109
    }
1110
1111
1112
    case OBU_REDUNDANT_FRAME_HDR:
        if (c->have_frame_hdr) break;
        // fall-through
1113
1114
    case OBU_FRAME:
    case OBU_FRAME_HDR:
1115
        c->have_frame_hdr = 0;
1116
        if (!c->have_seq_hdr) goto error;
1117
        if ((res = parse_frame_hdr(c, &gb)) < 0)
1118
1119
1120
1121
1122
            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;
1123
        c->n_tiles = 0;
1124
1125
1126
1127
1128
1129