GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/av1dec.c Lines: 165 506 32.6 %
Date: 2020-09-25 14:59:26 Branches: 68 273 24.9 %

Line Branch Exec Source
1
/*
2
 * AV1 video decoder
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
#include "libavutil/pixdesc.h"
22
#include "avcodec.h"
23
#include "av1dec.h"
24
#include "bytestream.h"
25
#include "hwconfig.h"
26
#include "internal.h"
27
#include "profiles.h"
28
29
static void setup_past_independence(AV1Frame *f)
30
{
31
    f->loop_filter_delta_enabled = 1;
32
33
    f->loop_filter_ref_deltas[AV1_REF_FRAME_INTRA] = 1;
34
    f->loop_filter_ref_deltas[AV1_REF_FRAME_LAST] = 0;
35
    f->loop_filter_ref_deltas[AV1_REF_FRAME_LAST2] = 0;
36
    f->loop_filter_ref_deltas[AV1_REF_FRAME_LAST3] = 0;
37
    f->loop_filter_ref_deltas[AV1_REF_FRAME_GOLDEN] = -1;
38
    f->loop_filter_ref_deltas[AV1_REF_FRAME_BWDREF] = 0;
39
    f->loop_filter_ref_deltas[AV1_REF_FRAME_ALTREF2] = -1;
40
    f->loop_filter_ref_deltas[AV1_REF_FRAME_ALTREF] = -1;
41
42
    f->loop_filter_mode_deltas[0] = 0;
43
    f->loop_filter_mode_deltas[1] = 0;
44
}
45
46
static void load_previous_and_update(AV1DecContext *s)
47
{
48
    uint8_t primary_frame, prev_frame;
49
50
    primary_frame = s->raw_frame_header->primary_ref_frame;
51
    prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];
52
    memcpy(s->cur_frame.loop_filter_ref_deltas,
53
           s->ref[prev_frame].loop_filter_ref_deltas,
54
           AV1_NUM_REF_FRAMES * sizeof(int8_t));
55
    memcpy(s->cur_frame.loop_filter_mode_deltas,
56
           s->ref[prev_frame].loop_filter_mode_deltas,
57
           2 * sizeof(int8_t));
58
59
    if (s->raw_frame_header->loop_filter_delta_update) {
60
        for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
61
            if (s->raw_frame_header->update_ref_delta[i])
62
                s->cur_frame.loop_filter_ref_deltas[i] =
63
                    s->raw_frame_header->loop_filter_ref_deltas[i];
64
        }
65
66
        for (int i = 0; i < 2; i++) {
67
            if (s->raw_frame_header->update_mode_delta[i])
68
                s->cur_frame.loop_filter_mode_deltas[i] =
69
                    s->raw_frame_header->loop_filter_mode_deltas[i];
70
        }
71
    }
72
73
    s->cur_frame.loop_filter_delta_enabled =
74
        s->raw_frame_header->loop_filter_delta_enabled;
75
}
76
77
static uint32_t inverse_recenter(int r, uint32_t v)
78
{
79
    if (v > 2 * r)
80
        return v;
81
    else if (v & 1)
82
        return r - ((v + 1) >> 1);
83
    else
84
        return r + (v >> 1);
85
}
86
87
static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp,
88
                                                int mx, int r)
89
{
90
    if ((r << 1) <= mx) {
91
        return inverse_recenter(r, sub_exp);
92
    } else {
93
        return mx - 1 - inverse_recenter(mx - 1 - r, sub_exp);
94
    }
95
}
96
97
static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low,
98
                                             int high, int r)
99
{
100
    int32_t x = decode_unsigned_subexp_with_ref(sub_exp, high - low, r - low);
101
    return x + low;
102
}
103
104
static void read_global_param(AV1DecContext *s, int type, int ref, int idx)
105
{
106
    uint8_t primary_frame, prev_frame;
107
    uint32_t abs_bits, prec_bits, round, prec_diff, sub, mx;
108
    int32_t r;
109
110
    primary_frame = s->raw_frame_header->primary_ref_frame;
111
    prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];
112
    abs_bits = AV1_GM_ABS_ALPHA_BITS;
113
    prec_bits = AV1_GM_ALPHA_PREC_BITS;
114
115
    if (idx < 2) {
116
        if (type == AV1_WARP_MODEL_TRANSLATION) {
117
            abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS -
118
                !s->raw_frame_header->allow_high_precision_mv;
119
            prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS -
120
                !s->raw_frame_header->allow_high_precision_mv;
121
        } else {
122
            abs_bits = AV1_GM_ABS_TRANS_BITS;
123
            prec_bits = AV1_GM_TRANS_PREC_BITS;
124
        }
125
    }
126
    round = (idx % 3) == 2 ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;
127
    prec_diff = AV1_WARPEDMODEL_PREC_BITS - prec_bits;
128
    sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;
129
    mx = 1 << abs_bits;
130
    r = (s->ref[prev_frame].gm_params[ref][idx] >> prec_diff) - sub;
131
132
    s->cur_frame.gm_params[ref][idx] =
133
        (decode_signed_subexp_with_ref(s->raw_frame_header->gm_params[ref][idx],
134
                                       -mx, mx + 1, r) << prec_diff) + round;
135
}
136
137
/**
138
* update gm type/params, since cbs already implemented part of this funcation,
139
* so we don't need to full implement spec.
140
*/
141
static void global_motion_params(AV1DecContext *s)
142
{
143
    const AV1RawFrameHeader *header = s->raw_frame_header;
144
    int type, ref;
145
146
    for (ref = AV1_REF_FRAME_LAST; ref <= AV1_REF_FRAME_ALTREF; ref++) {
147
        s->cur_frame.gm_type[ref] = AV1_WARP_MODEL_IDENTITY;
148
        for (int i = 0; i < 6; i++)
149
            s->cur_frame.gm_params[ref][i] = (i % 3 == 2) ?
150
                                             1 << AV1_WARPEDMODEL_PREC_BITS : 0;
151
    }
152
    if (header->frame_type == AV1_FRAME_KEY ||
153
        header->frame_type == AV1_FRAME_INTRA_ONLY)
154
        return;
155
156
    for (ref = AV1_REF_FRAME_LAST; ref <= AV1_REF_FRAME_ALTREF; ref++) {
157
        if (header->is_global[ref]) {
158
            if (header->is_rot_zoom[ref]) {
159
                type = AV1_WARP_MODEL_ROTZOOM;
160
            } else {
161
                type = header->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
162
                                                   : AV1_WARP_MODEL_AFFINE;
163
            }
164
        } else {
165
            type = AV1_WARP_MODEL_IDENTITY;
166
        }
167
        s->cur_frame.gm_type[ref] = type;
168
169
        if (type >= AV1_WARP_MODEL_ROTZOOM) {
170
            read_global_param(s, type, ref, 2);
171
            read_global_param(s, type, ref, 3);
172
            if (type == AV1_WARP_MODEL_AFFINE) {
173
                read_global_param(s, type, ref, 4);
174
                read_global_param(s, type, ref, 5);
175
            } else {
176
                s->cur_frame.gm_params[ref][4] = -s->cur_frame.gm_params[ref][3];
177
                s->cur_frame.gm_params[ref][5] = s->cur_frame.gm_params[ref][2];
178
            }
179
        }
180
        if (type >= AV1_WARP_MODEL_TRANSLATION) {
181
            read_global_param(s, type, ref, 0);
182
            read_global_param(s, type, ref, 1);
183
        }
184
    }
185
}
186
187
static int init_tile_data(AV1DecContext *s)
188
189
{
190
    int cur_tile_num =
191
        s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;
192
    if (s->tile_num < cur_tile_num) {
193
        int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,
194
                                    sizeof(TileGroupInfo));
195
        if (ret < 0) {
196
            s->tile_num = 0;
197
            return ret;
198
        }
199
    }
200
    s->tile_num = cur_tile_num;
201
202
    return 0;
203
}
204
205
static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)
206
{
207
    AV1DecContext *s = avctx->priv_data;
208
    GetByteContext gb;
209
    uint16_t tile_num, tile_row, tile_col;
210
    uint32_t size = 0, size_bytes = 0;
211
212
    bytestream2_init(&gb, tile_group->tile_data.data,
213
                     tile_group->tile_data.data_size);
214
    s->tg_start = tile_group->tg_start;
215
    s->tg_end = tile_group->tg_end;
216
217
    for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {
218
        tile_row = tile_num / s->raw_frame_header->tile_cols;
219
        tile_col = tile_num % s->raw_frame_header->tile_cols;
220
221
        if (tile_num == tile_group->tg_end) {
222
            s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);
223
            s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
224
            s->tile_group_info[tile_num].tile_row = tile_row;
225
            s->tile_group_info[tile_num].tile_column = tile_col;
226
            return 0;
227
        }
228
        size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;
229
        if (bytestream2_get_bytes_left(&gb) < size_bytes)
230
            return AVERROR_INVALIDDATA;
231
        size = 0;
232
        for (int i = 0; i < size_bytes; i++)
233
            size |= bytestream2_get_byteu(&gb) << 8 * i;
234
        if (bytestream2_get_bytes_left(&gb) <= size)
235
            return AVERROR_INVALIDDATA;
236
        size++;
237
238
        s->tile_group_info[tile_num].tile_size = size;
239
        s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);
240
        s->tile_group_info[tile_num].tile_row = tile_row;
241
        s->tile_group_info[tile_num].tile_column = tile_col;
242
243
        bytestream2_skipu(&gb, size);
244
    }
245
246
    return 0;
247
248
}
249
250
21
static int get_pixel_format(AVCodecContext *avctx)
251
{
252
21
    AV1DecContext *s = avctx->priv_data;
253
21
    const AV1RawSequenceHeader *seq = s->raw_seq;
254
    uint8_t bit_depth;
255
    int ret;
256
21
    enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
257
#define HWACCEL_MAX (0)
258
21
    enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
259
260

21
    if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
261
        bit_depth = seq->color_config.twelve_bit ? 12 : 10;
262
21
    else if (seq->seq_profile <= 2)
263
21
        bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
264
    else {
265
        av_log(avctx, AV_LOG_ERROR,
266
               "Unknown AV1 profile %d.\n", seq->seq_profile);
267
        return -1;
268
    }
269
270
21
    if (!seq->color_config.mono_chrome) {
271
        // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1
272
21
        if (seq->color_config.subsampling_x == 0 &&
273
            seq->color_config.subsampling_y == 0) {
274
            if (bit_depth == 8)
275
                pix_fmt = AV_PIX_FMT_YUV444P;
276
            else if (bit_depth == 10)
277
                pix_fmt = AV_PIX_FMT_YUV444P10;
278
            else if (bit_depth == 12)
279
                pix_fmt = AV_PIX_FMT_YUV444P12;
280
            else
281
                av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
282
21
        } else if (seq->color_config.subsampling_x == 1 &&
283
21
                   seq->color_config.subsampling_y == 0) {
284
            if (bit_depth == 8)
285
                pix_fmt = AV_PIX_FMT_YUV422P;
286
            else if (bit_depth == 10)
287
                pix_fmt = AV_PIX_FMT_YUV422P10;
288
            else if (bit_depth == 12)
289
                pix_fmt = AV_PIX_FMT_YUV422P12;
290
            else
291
                av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
292
21
        } else if (seq->color_config.subsampling_x == 1 &&
293
21
                   seq->color_config.subsampling_y == 1) {
294
21
            if (bit_depth == 8)
295
20
                pix_fmt = AV_PIX_FMT_YUV420P;
296
1
            else if (bit_depth == 10)
297
1
                pix_fmt = AV_PIX_FMT_YUV420P10;
298
            else if (bit_depth == 12)
299
                pix_fmt = AV_PIX_FMT_YUV420P12;
300
            else
301
                av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
302
        }
303
    } else {
304
        if (seq->color_config.subsampling_x == 1 &&
305
            seq->color_config.subsampling_y == 1)
306
            pix_fmt = AV_PIX_FMT_YUV440P;
307
        else
308
            av_log(avctx, AV_LOG_WARNING, "Unknown AV1 pixel format.\n");
309
    }
310
311
21
    av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",
312
           av_get_pix_fmt_name(pix_fmt));
313
314
21
    if (pix_fmt == AV_PIX_FMT_NONE)
315
        return -1;
316
21
    s->pix_fmt = pix_fmt;
317
318
21
    *fmtp++ = s->pix_fmt;
319
21
    *fmtp = AV_PIX_FMT_NONE;
320
321
21
    ret = ff_thread_get_format(avctx, pix_fmts);
322
21
    if (ret < 0)
323
        return ret;
324
325
    /**
326
     * check if the HW accel is inited correctly. If not, return un-implemented.
327
     * Since now the av1 decoder doesn't support native decode, if it will be
328
     * implemented in the future, need remove this check.
329
     */
330
21
    if (!avctx->hwaccel) {
331
21
        av_log(avctx, AV_LOG_ERROR, "Your platform doesn't suppport"
332
               " hardware accelerated AV1 decoding.\n");
333
21
        return AVERROR(ENOSYS);
334
    }
335
336
    avctx->pix_fmt = ret;
337
338
    return 0;
339
}
340
341
189
static void av1_frame_unref(AVCodecContext *avctx, AV1Frame *f)
342
{
343
189
    ff_thread_release_buffer(avctx, &f->tf);
344
189
    av_buffer_unref(&f->hwaccel_priv_buf);
345
189
    f->hwaccel_picture_private = NULL;
346
189
}
347
348
51
static int av1_frame_ref(AVCodecContext *avctx, AV1Frame *dst, const AV1Frame *src)
349
{
350
    int ret;
351
352
51
    ret = ff_thread_ref_frame(&dst->tf, &src->tf);
353
51
    if (ret < 0)
354
51
        return ret;
355
356
    if (src->hwaccel_picture_private) {
357
        dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
358
        if (!dst->hwaccel_priv_buf)
359
            goto fail;
360
        dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
361
    }
362
363
    dst->loop_filter_delta_enabled = src->loop_filter_delta_enabled;
364
    memcpy(dst->loop_filter_ref_deltas,
365
           src->loop_filter_ref_deltas,
366
           AV1_NUM_REF_FRAMES * sizeof(int8_t));
367
    memcpy(dst->loop_filter_mode_deltas,
368
           src->loop_filter_mode_deltas,
369
           2 * sizeof(int8_t));
370
    memcpy(dst->gm_type,
371
           src->gm_type,
372
           AV1_NUM_REF_FRAMES * sizeof(uint8_t));
373
    memcpy(dst->gm_params,
374
           src->gm_params,
375
           AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));
376
377
    return 0;
378
379
fail:
380
    av1_frame_unref(avctx, dst);
381
    return AVERROR(ENOMEM);
382
}
383
384
21
static av_cold int av1_decode_free(AVCodecContext *avctx)
385
{
386
21
    AV1DecContext *s = avctx->priv_data;
387
388
189
    for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
389
168
        av1_frame_unref(avctx, &s->ref[i]);
390
168
        av_frame_free(&s->ref[i].tf.f);
391
    }
392
21
    av1_frame_unref(avctx, &s->cur_frame);
393
21
    av_frame_free(&s->cur_frame.tf.f);
394
395
21
    av_buffer_unref(&s->seq_ref);
396
21
    av_buffer_unref(&s->header_ref);
397
21
    av_freep(&s->tile_group_info);
398
399
21
    ff_cbs_fragment_free(&s->current_obu);
400
21
    ff_cbs_close(&s->cbc);
401
402
21
    return 0;
403
}
404
405
104
static int set_context_with_sequence(AVCodecContext *avctx,
406
                                     const AV1RawSequenceHeader *seq)
407
{
408
104
    avctx->profile = seq->seq_profile;
409
104
    avctx->level = seq->seq_level_idx[0];
410
411
104
    avctx->color_range =
412
104
        seq->color_config.color_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
413
104
    avctx->color_primaries = seq->color_config.color_primaries;
414
104
    avctx->colorspace = seq->color_config.color_primaries;
415
104
    avctx->color_trc = seq->color_config.transfer_characteristics;
416
417
104
    switch (seq->color_config.chroma_sample_position) {
418
    case AV1_CSP_VERTICAL:
419
        avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
420
        break;
421
    case AV1_CSP_COLOCATED:
422
        avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
423
        break;
424
    }
425
426
104
    if (seq->timing_info.num_units_in_display_tick &&
427
65
        seq->timing_info.time_scale) {
428
65
        av_reduce(&avctx->framerate.den, &avctx->framerate.num,
429
65
                  seq->timing_info.num_units_in_display_tick,
430
65
                  seq->timing_info.time_scale,
431
                  INT_MAX);
432
65
        if (seq->timing_info.equal_picture_interval)
433
            avctx->ticks_per_frame = seq->timing_info.num_ticks_per_picture_minus_1 + 1;
434
    }
435
436
104
    return 0;
437
}
438
439
258
static int update_context_with_frame_header(AVCodecContext *avctx,
440
                                            const AV1RawFrameHeader *header)
441
{
442
    AVRational aspect_ratio;
443
258
    int width = header->frame_width_minus_1 + 1;
444
258
    int height = header->frame_height_minus_1 + 1;
445
258
    int r_width = header->render_width_minus_1 + 1;
446
258
    int r_height = header->render_height_minus_1 + 1;
447
    int ret;
448
449

258
    if (avctx->width != width || avctx->height != height) {
450
6
        ret = ff_set_dimensions(avctx, width, height);
451
6
        if (ret < 0)
452
            return ret;
453
    }
454
455
258
    av_reduce(&aspect_ratio.num, &aspect_ratio.den,
456
258
              (int64_t)height * r_width,
457
258
              (int64_t)width * r_height,
458
              INT_MAX);
459
460
258
    if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {
461
21
        ret = ff_set_sar(avctx, aspect_ratio);
462
21
        if (ret < 0)
463
            return ret;
464
    }
465
466
258
    return 0;
467
}
468
469
21
static av_cold int av1_decode_init(AVCodecContext *avctx)
470
{
471
21
    AV1DecContext *s = avctx->priv_data;
472
    AV1RawSequenceHeader *seq;
473
    int ret;
474
475
21
    s->avctx = avctx;
476
21
    s->pix_fmt = AV_PIX_FMT_NONE;
477
478
189
    for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++) {
479
168
        s->ref[i].tf.f = av_frame_alloc();
480
168
        if (!s->ref[i].tf.f) {
481
            av_log(avctx, AV_LOG_ERROR,
482
                   "Failed to allocate reference frame buffer %d.\n", i);
483
            return AVERROR(ENOMEM);
484
        }
485
    }
486
487
21
    s->cur_frame.tf.f = av_frame_alloc();
488
21
    if (!s->cur_frame.tf.f) {
489
        av_log(avctx, AV_LOG_ERROR,
490
               "Failed to allocate current frame buffer.\n");
491
        return AVERROR(ENOMEM);
492
    }
493
494
21
    ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);
495
21
    if (ret < 0)
496
        return ret;
497
498

21
    if (avctx->extradata && avctx->extradata_size) {
499
2
        ret = ff_cbs_read(s->cbc, &s->current_obu, avctx->extradata,
500
2
                          avctx->extradata_size);
501
2
        if (ret < 0) {
502
            av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");
503
            return ret;
504
        }
505
506
2
        seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;
507
2
        if (!seq) {
508
            av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");
509
            goto end;
510
        }
511
512
2
        ret = set_context_with_sequence(avctx, seq);
513
2
        if (ret < 0) {
514
            av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");
515
            goto end;
516
        }
517
518
2
        end:
519
2
        ff_cbs_fragment_reset(&s->current_obu);
520
    }
521
522
21
    return ret;
523
}
524
525
258
static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)
526
{
527
258
    AV1DecContext *s = avctx->priv_data;
528
258
    AV1RawFrameHeader *header= s->raw_frame_header;
529
    AVFrame *frame;
530
    int ret;
531
532
258
    ret = update_context_with_frame_header(avctx, header);
533
258
    if (ret < 0) {
534
        av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");
535
        return ret;
536
    }
537
538
258
    if ((ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
539
258
        return ret;
540
541
    frame = f->tf.f;
542
    frame->key_frame = header->frame_type == AV1_FRAME_KEY;
543
544
    switch (header->frame_type) {
545
    case AV1_FRAME_KEY:
546
    case AV1_FRAME_INTRA_ONLY:
547
        frame->pict_type = AV_PICTURE_TYPE_I;
548
        break;
549
    case AV1_FRAME_INTER:
550
        frame->pict_type = AV_PICTURE_TYPE_P;
551
        break;
552
    case AV1_FRAME_SWITCH:
553
        frame->pict_type = AV_PICTURE_TYPE_SP;
554
        break;
555
    }
556
557
    if (avctx->hwaccel) {
558
        const AVHWAccel *hwaccel = avctx->hwaccel;
559
        if (hwaccel->frame_priv_data_size) {
560
            f->hwaccel_priv_buf =
561
                av_buffer_allocz(hwaccel->frame_priv_data_size);
562
            if (!f->hwaccel_priv_buf)
563
                goto fail;
564
            f->hwaccel_picture_private = f->hwaccel_priv_buf->data;
565
        }
566
    }
567
    return 0;
568
569
fail:
570
    av1_frame_unref(avctx, f);
571
    return AVERROR(ENOMEM);
572
}
573
574
static int set_output_frame(AVCodecContext *avctx, AVFrame *frame,
575
                            const AVPacket *pkt, int *got_frame)
576
{
577
    AV1DecContext *s = avctx->priv_data;
578
    const AVFrame *srcframe = s->cur_frame.tf.f;
579
    int ret;
580
581
    ret = av_frame_ref(frame, srcframe);
582
    if (ret < 0)
583
        return ret;
584
585
    frame->pts = pkt->pts;
586
    frame->pkt_dts = pkt->dts;
587
    frame->pkt_size = pkt->size;
588
589
    *got_frame = 1;
590
591
    return 0;
592
}
593
594
static int update_reference_list(AVCodecContext *avctx)
595
{
596
    AV1DecContext *s = avctx->priv_data;
597
    const AV1RawFrameHeader *header = s->raw_frame_header;
598
    int ret;
599
600
    for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
601
        if (header->refresh_frame_flags & (1 << i)) {
602
            if (s->ref[i].tf.f->buf[0])
603
                av1_frame_unref(avctx, &s->ref[i]);
604
            if ((ret = av1_frame_ref(avctx, &s->ref[i], &s->cur_frame)) < 0) {
605
                av_log(avctx, AV_LOG_ERROR,
606
                       "Failed to update frame %d in reference list\n", i);
607
                return ret;
608
            }
609
        }
610
    }
611
    return 0;
612
}
613
614
258
static int get_current_frame(AVCodecContext *avctx)
615
{
616
258
    AV1DecContext *s = avctx->priv_data;
617
    int ret;
618
619
258
    if (s->cur_frame.tf.f->buf[0])
620
        av1_frame_unref(avctx, &s->cur_frame);
621
622
258
    ret = av1_frame_alloc(avctx, &s->cur_frame);
623
258
    if (ret < 0) {
624
258
        av_log(avctx, AV_LOG_ERROR,
625
               "Failed to allocate space for current frame.\n");
626
258
        return ret;
627
    }
628
629
    ret = init_tile_data(s);
630
    if (ret < 0) {
631
        av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");
632
        return ret;
633
    }
634
635
    if (s->raw_frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE)
636
        setup_past_independence(&s->cur_frame);
637
    else
638
        load_previous_and_update(s);
639
640
    global_motion_params(s);
641
642
    return ret;
643
}
644
645
330
static int av1_decode_frame(AVCodecContext *avctx, void *frame,
646
                            int *got_frame, AVPacket *pkt)
647
{
648
330
    AV1DecContext *s = avctx->priv_data;
649
330
    AV1RawTileGroup *raw_tile_group = NULL;
650
    int ret;
651
652
330
    ret = ff_cbs_read_packet(s->cbc, &s->current_obu, pkt);
653
330
    if (ret < 0) {
654
        av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");
655
        goto end;
656
    }
657
330
    av_log(avctx, AV_LOG_DEBUG, "Total obu for this frame:%d.\n",
658
           s->current_obu.nb_units);
659
660
737
    for (int i = 0; i < s->current_obu.nb_units; i++) {
661
737
        CodedBitstreamUnit *unit = &s->current_obu.units[i];
662
737
        AV1RawOBU *obu = unit->content;
663
737
        av_log(avctx, AV_LOG_DEBUG, "Obu idx:%d, obu type:%d.\n", i, unit->type);
664
665

737
        switch (unit->type) {
666
102
        case AV1_OBU_SEQUENCE_HEADER:
667
102
            av_buffer_unref(&s->seq_ref);
668
102
            s->seq_ref = av_buffer_ref(unit->content_ref);
669
102
            if (!s->seq_ref) {
670
                ret = AVERROR(ENOMEM);
671
                goto end;
672
            }
673
674
102
            s->raw_seq = &obu->obu.sequence_header;
675
676
102
            ret = set_context_with_sequence(avctx, s->raw_seq);
677
102
            if (ret < 0) {
678
                av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");
679
                goto end;
680
            }
681
682
102
            if (s->pix_fmt == AV_PIX_FMT_NONE) {
683
21
                ret = get_pixel_format(avctx);
684
21
                if (ret < 0) {
685
21
                    av_log(avctx, AV_LOG_ERROR,
686
                           "Failed to get pixel format.\n");
687
21
                    goto end;
688
                }
689
            }
690
691

81
            if (avctx->hwaccel && avctx->hwaccel->decode_params) {
692
                ret = avctx->hwaccel->decode_params(avctx, unit->type, unit->data,
693
                                                    unit->data_size);
694
                if (ret < 0) {
695
                    av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");
696
                    goto end;
697
                }
698
            }
699
81
            break;
700
        case AV1_OBU_REDUNDANT_FRAME_HEADER:
701
            if (s->raw_frame_header)
702
                break;
703
        // fall-through
704
        case AV1_OBU_FRAME:
705
        case AV1_OBU_FRAME_HEADER:
706
309
            if (!s->seq_ref) {
707
                av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");
708
                ret = AVERROR_INVALIDDATA;
709
                goto end;
710
            }
711
712
309
            av_buffer_unref(&s->header_ref);
713
309
            s->header_ref = av_buffer_ref(unit->content_ref);
714
309
            if (!s->header_ref) {
715
                ret = AVERROR(ENOMEM);
716
                goto end;
717
            }
718
719
309
            if (unit->type == AV1_OBU_FRAME)
720
237
                s->raw_frame_header = &obu->obu.frame.header;
721
            else
722
72
                s->raw_frame_header = &obu->obu.frame_header;
723
724
309
            if (s->raw_frame_header->show_existing_frame) {
725
51
                if (s->cur_frame.tf.f->buf[0])
726
                    av1_frame_unref(avctx, &s->cur_frame);
727
728
51
                ret = av1_frame_ref(avctx, &s->cur_frame,
729
51
                                    &s->ref[s->raw_frame_header->frame_to_show_map_idx]);
730
51
                if (ret < 0) {
731
51
                    av_log(avctx, AV_LOG_ERROR, "Failed to get reference frame.\n");
732
51
                    goto end;
733
                }
734
735
                ret = update_reference_list(avctx);
736
                if (ret < 0) {
737
                    av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
738
                    goto end;
739
                }
740
741
                ret = set_output_frame(avctx, frame, pkt, got_frame);
742
                if (ret < 0)
743
                    av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");
744
745
                s->raw_frame_header = NULL;
746
747
                goto end;
748
            }
749
750
258
            ret = get_current_frame(avctx);
751
258
            if (ret < 0) {
752
258
                av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");
753
258
                goto end;
754
            }
755
756
            if (avctx->hwaccel) {
757
                ret = avctx->hwaccel->start_frame(avctx, unit->data,
758
                                                  unit->data_size);
759
                if (ret < 0) {
760
                    av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");
761
                    goto end;
762
                }
763
            }
764
            if (unit->type != AV1_OBU_FRAME)
765
                break;
766
        // fall-through
767
        case AV1_OBU_TILE_GROUP:
768
            if (!s->raw_frame_header) {
769
                av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");
770
                ret = AVERROR_INVALIDDATA;
771
                goto end;
772
            }
773
774
            if (unit->type == AV1_OBU_FRAME)
775
                raw_tile_group = &obu->obu.frame.tile_group;
776
            else
777
                raw_tile_group = &obu->obu.tile_group;
778
779
            ret = get_tiles_info(avctx, raw_tile_group);
780
            if (ret < 0)
781
                goto end;
782
783
            if (avctx->hwaccel) {
784
                ret = avctx->hwaccel->decode_slice(avctx,
785
                                                   raw_tile_group->tile_data.data,
786
                                                   raw_tile_group->tile_data.data_size);
787
                if (ret < 0) {
788
                    av_log(avctx, AV_LOG_ERROR,
789
                           "HW accel decode slice fail.\n");
790
                    goto end;
791
                }
792
            }
793
            break;
794
326
        case AV1_OBU_TILE_LIST:
795
        case AV1_OBU_TEMPORAL_DELIMITER:
796
        case AV1_OBU_PADDING:
797
        case AV1_OBU_METADATA:
798
326
            break;
799
        default:
800
            av_log(avctx, AV_LOG_DEBUG,
801
                   "Unknown obu type: %d (%"SIZE_SPECIFIER" bits).\n",
802
                   unit->type, unit->data_size);
803
        }
804
805

407
        if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {
806
            if (avctx->hwaccel) {
807
                ret = avctx->hwaccel->end_frame(avctx);
808
                if (ret < 0) {
809
                    av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");
810
                    goto end;
811
                }
812
            }
813
814
            ret = update_reference_list(avctx);
815
            if (ret < 0) {
816
                av_log(avctx, AV_LOG_ERROR, "Failed to update reference list.\n");
817
                goto end;
818
            }
819
820
            if (s->raw_frame_header->show_frame) {
821
                ret = set_output_frame(avctx, frame, pkt, got_frame);
822
                if (ret < 0) {
823
                    av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");
824
                    goto end;
825
                }
826
            }
827
            raw_tile_group = NULL;
828
            s->raw_frame_header = NULL;
829
        }
830
    }
831
832
end:
833
330
    ff_cbs_fragment_reset(&s->current_obu);
834
330
    return ret;
835
}
836
837
static void av1_decode_flush(AVCodecContext *avctx)
838
{
839
    AV1DecContext *s = avctx->priv_data;
840
841
    for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)
842
        av1_frame_unref(avctx, &s->ref[i]);
843
844
    av1_frame_unref(avctx, &s->cur_frame);
845
    s->raw_frame_header = NULL;
846
    s->raw_seq = NULL;
847
}
848
849
AVCodec ff_av1_decoder = {
850
    .name                  = "av1",
851
    .long_name             = NULL_IF_CONFIG_SMALL("Alliance for Open Media AV1"),
852
    .type                  = AVMEDIA_TYPE_VIDEO,
853
    .id                    = AV_CODEC_ID_AV1,
854
    .priv_data_size        = sizeof(AV1DecContext),
855
    .init                  = av1_decode_init,
856
    .close                 = av1_decode_free,
857
    .decode                = av1_decode_frame,
858
    .capabilities          = AV_CODEC_CAP_DR1,
859
    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE |
860
                             FF_CODEC_CAP_INIT_CLEANUP |
861
                             FF_CODEC_CAP_SETS_PKT_DTS,
862
    .flush                 = av1_decode_flush,
863
    .profiles              = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
864
    .hw_configs            = (const AVCodecHWConfigInternal * []) {
865
        NULL
866
    },
867
};