GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/cbs_av1.c Lines: 332 571 58.1 %
Date: 2019-11-22 03:34:36 Branches: 143 344 41.6 %

Line Branch Exec Source
1
/*
2
 * This file is part of FFmpeg.
3
 *
4
 * FFmpeg is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * FFmpeg is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with FFmpeg; if not, write to the Free Software
16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 */
18
19
#include "libavutil/avassert.h"
20
#include "libavutil/pixfmt.h"
21
22
#include "cbs.h"
23
#include "cbs_internal.h"
24
#include "cbs_av1.h"
25
#include "internal.h"
26
27
28
static int cbs_av1_read_uvlc(CodedBitstreamContext *ctx, GetBitContext *gbc,
29
                             const char *name, uint32_t *write_to,
30
                             uint32_t range_min, uint32_t range_max)
31
{
32
    uint32_t zeroes, bits_value, value;
33
    int position;
34
35
    if (ctx->trace_enable)
36
        position = get_bits_count(gbc);
37
38
    zeroes = 0;
39
    while (1) {
40
        if (get_bits_left(gbc) < 1) {
41
            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid uvlc code at "
42
                   "%s: bitstream ended.\n", name);
43
            return AVERROR_INVALIDDATA;
44
        }
45
46
        if (get_bits1(gbc))
47
            break;
48
        ++zeroes;
49
    }
50
51
    if (zeroes >= 32) {
52
        value = MAX_UINT_BITS(32);
53
    } else {
54
        if (get_bits_left(gbc) < zeroes) {
55
            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid uvlc code at "
56
                   "%s: bitstream ended.\n", name);
57
            return AVERROR_INVALIDDATA;
58
        }
59
60
        bits_value = get_bits_long(gbc, zeroes);
61
        value = bits_value + (UINT32_C(1) << zeroes) - 1;
62
    }
63
64
    if (ctx->trace_enable) {
65
        char bits[65];
66
        int i, j, k;
67
68
        if (zeroes >= 32) {
69
            while (zeroes > 32) {
70
                k = FFMIN(zeroes - 32, 32);
71
                for (i = 0; i < k; i++)
72
                    bits[i] = '0';
73
                bits[i] = 0;
74
                ff_cbs_trace_syntax_element(ctx, position, name,
75
                                            NULL, bits, 0);
76
                zeroes -= k;
77
                position += k;
78
            }
79
        }
80
81
        for (i = 0; i < zeroes; i++)
82
            bits[i] = '0';
83
        bits[i++] = '1';
84
85
        if (zeroes < 32) {
86
            for (j = 0; j < zeroes; j++)
87
                bits[i++] = (bits_value >> (zeroes - j - 1) & 1) ? '1' : '0';
88
        }
89
90
        bits[i] = 0;
91
        ff_cbs_trace_syntax_element(ctx, position, name,
92
                                    NULL, bits, value);
93
    }
94
95
    if (value < range_min || value > range_max) {
96
        av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
97
               "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
98
               name, value, range_min, range_max);
99
        return AVERROR_INVALIDDATA;
100
    }
101
102
    *write_to = value;
103
    return 0;
104
}
105
106
static int cbs_av1_write_uvlc(CodedBitstreamContext *ctx, PutBitContext *pbc,
107
                              const char *name, uint32_t value,
108
                              uint32_t range_min, uint32_t range_max)
109
{
110
    uint32_t v;
111
    int position, zeroes;
112
113
    if (value < range_min || value > range_max) {
114
        av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
115
               "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
116
               name, value, range_min, range_max);
117
        return AVERROR_INVALIDDATA;
118
    }
119
120
    if (ctx->trace_enable)
121
        position = put_bits_count(pbc);
122
123
    if (value == 0) {
124
        zeroes = 0;
125
        put_bits(pbc, 1, 1);
126
    } else {
127
        zeroes = av_log2(value + 1);
128
        v = value - (1 << zeroes) + 1;
129
        put_bits(pbc, zeroes + 1, 1);
130
        put_bits(pbc, zeroes, v);
131
    }
132
133
    if (ctx->trace_enable) {
134
        char bits[65];
135
        int i, j;
136
        i = 0;
137
        for (j = 0; j < zeroes; j++)
138
            bits[i++] = '0';
139
        bits[i++] = '1';
140
        for (j = 0; j < zeroes; j++)
141
            bits[i++] = (v >> (zeroes - j - 1) & 1) ? '1' : '0';
142
        bits[i++] = 0;
143
        ff_cbs_trace_syntax_element(ctx, position, name, NULL,
144
                                    bits, value);
145
    }
146
147
    return 0;
148
}
149
150
4188
static int cbs_av1_read_leb128(CodedBitstreamContext *ctx, GetBitContext *gbc,
151
                               const char *name, uint64_t *write_to)
152
{
153
    uint64_t value;
154
    int position, err, i;
155
156
4188
    if (ctx->trace_enable)
157
        position = get_bits_count(gbc);
158
159
4188
    value = 0;
160
5814
    for (i = 0; i < 8; i++) {
161
5814
        int subscript[2] = { 1, i };
162
        uint32_t byte;
163
5814
        err = ff_cbs_read_unsigned(ctx, gbc, 8, "leb128_byte[i]", subscript,
164
                                   &byte, 0x00, 0xff);
165
5814
        if (err < 0)
166
            return err;
167
168
5814
        value |= (uint64_t)(byte & 0x7f) << (i * 7);
169
5814
        if (!(byte & 0x80))
170
4188
            break;
171
    }
172
173
4188
    if (ctx->trace_enable)
174
        ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);
175
176
4188
    *write_to = value;
177
4188
    return 0;
178
}
179
180
1416
static int cbs_av1_write_leb128(CodedBitstreamContext *ctx, PutBitContext *pbc,
181
                                const char *name, uint64_t value)
182
{
183
    int position, err, len, i;
184
    uint8_t byte;
185
186
1416
    len = (av_log2(value) + 7) / 7;
187
188
1416
    if (ctx->trace_enable)
189
        position = put_bits_count(pbc);
190
191
3374
    for (i = 0; i < len; i++) {
192
1958
        int subscript[2] = { 1, i };
193
194
1958
        byte = value >> (7 * i) & 0x7f;
195
1958
        if (i < len - 1)
196
542
            byte |= 0x80;
197
198
1958
        err = ff_cbs_write_unsigned(ctx, pbc, 8, "leb128_byte[i]", subscript,
199
                                    byte, 0x00, 0xff);
200
1958
        if (err < 0)
201
            return err;
202
    }
203
204
1416
    if (ctx->trace_enable)
205
        ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);
206
207
1416
    return 0;
208
}
209
210
390
static int cbs_av1_read_ns(CodedBitstreamContext *ctx, GetBitContext *gbc,
211
                           uint32_t n, const char *name,
212
                           const int *subscripts, uint32_t *write_to)
213
{
214
    uint32_t m, v, extra_bit, value;
215
    int position, w;
216
217
390
    av_assert0(n > 0);
218
219
390
    if (ctx->trace_enable)
220
        position = get_bits_count(gbc);
221
222
390
    w = av_log2(n) + 1;
223
390
    m = (1 << w) - n;
224
225
390
    if (get_bits_left(gbc) < w) {
226
        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid non-symmetric value at "
227
               "%s: bitstream ended.\n", name);
228
        return AVERROR_INVALIDDATA;
229
    }
230
231
390
    if (w - 1 > 0)
232
390
        v = get_bits(gbc, w - 1);
233
    else
234
        v = 0;
235
236
390
    if (v < m) {
237
312
        value = v;
238
    } else {
239
78
        extra_bit = get_bits1(gbc);
240
78
        value = (v << 1) - m + extra_bit;
241
    }
242
243
390
    if (ctx->trace_enable) {
244
        char bits[33];
245
        int i;
246
        for (i = 0; i < w - 1; i++)
247
            bits[i] = (v >> i & 1) ? '1' : '0';
248
        if (v >= m)
249
            bits[i++] = extra_bit ? '1' : '0';
250
        bits[i] = 0;
251
252
        ff_cbs_trace_syntax_element(ctx, position,
253
                                    name, subscripts, bits, value);
254
    }
255
256
390
    *write_to = value;
257
390
    return 0;
258
}
259
260
260
static int cbs_av1_write_ns(CodedBitstreamContext *ctx, PutBitContext *pbc,
261
                            uint32_t n, const char *name,
262
                            const int *subscripts, uint32_t value)
263
{
264
    uint32_t w, m, v, extra_bit;
265
    int position;
266
267
260
    if (value > n) {
268
        av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
269
               "%"PRIu32", but must be in [0,%"PRIu32"].\n",
270
               name, value, n);
271
        return AVERROR_INVALIDDATA;
272
    }
273
274
260
    if (ctx->trace_enable)
275
        position = put_bits_count(pbc);
276
277
260
    w = av_log2(n) + 1;
278
260
    m = (1 << w) - n;
279
280
260
    if (put_bits_left(pbc) < w)
281
        return AVERROR(ENOSPC);
282
283
260
    if (value < m) {
284
208
        v = value;
285
208
        put_bits(pbc, w - 1, v);
286
    } else {
287
52
        v = m + ((value - m) >> 1);
288
52
        extra_bit = (value - m) & 1;
289
52
        put_bits(pbc, w - 1, v);
290
52
        put_bits(pbc, 1, extra_bit);
291
    }
292
293
260
    if (ctx->trace_enable) {
294
        char bits[33];
295
        int i;
296
        for (i = 0; i < w - 1; i++)
297
            bits[i] = (v >> i & 1) ? '1' : '0';
298
        if (value >= m)
299
            bits[i++] = extra_bit ? '1' : '0';
300
        bits[i] = 0;
301
302
        ff_cbs_trace_syntax_element(ctx, position,
303
                                    name, subscripts, bits, value);
304
    }
305
306
260
    return 0;
307
}
308
309
2862
static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc,
310
                                  uint32_t range_min, uint32_t range_max,
311
                                  const char *name, uint32_t *write_to)
312
{
313
    uint32_t value;
314
    int position, i;
315
    char bits[33];
316
317

2862
    av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
318
2862
    if (ctx->trace_enable)
319
        position = get_bits_count(gbc);
320
321
4434
    for (i = 0, value = range_min; value < range_max;) {
322
3924
        if (get_bits_left(gbc) < 1) {
323
            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
324
                   "%s: bitstream ended.\n", name);
325
            return AVERROR_INVALIDDATA;
326
        }
327
3924
        if (get_bits1(gbc)) {
328
1572
            bits[i++] = '1';
329
1572
            ++value;
330
        } else {
331
2352
            bits[i++] = '0';
332
2352
            break;
333
        }
334
    }
335
336
2862
    if (ctx->trace_enable) {
337
        bits[i] = 0;
338
        ff_cbs_trace_syntax_element(ctx, position,
339
                                    name, NULL, bits, value);
340
    }
341
342
2862
    *write_to = value;
343
2862
    return 0;
344
}
345
346
1908
static int cbs_av1_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc,
347
                                   uint32_t range_min, uint32_t range_max,
348
                                   const char *name, uint32_t value)
349
{
350
    int len;
351
352

1908
    av_assert0(range_min <= range_max && range_max - range_min < 32);
353

1908
    if (value < range_min || value > range_max) {
354
        av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
355
               "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
356
               name, value, range_min, range_max);
357
        return AVERROR_INVALIDDATA;
358
    }
359
360
1908
    if (value == range_max)
361
340
        len = range_max - range_min;
362
    else
363
1568
        len = value - range_min + 1;
364
1908
    if (put_bits_left(pbc) < len)
365
        return AVERROR(ENOSPC);
366
367
1908
    if (ctx->trace_enable) {
368
        char bits[33];
369
        int i;
370
        for (i = 0; i < len; i++) {
371
            if (range_min + i == value)
372
                bits[i] = '0';
373
            else
374
                bits[i] = '1';
375
        }
376
        bits[i] = 0;
377
        ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
378
                                    name, NULL, bits, value);
379
    }
380
381
1908
    if (len > 0)
382
1908
        put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
383
384
1908
    return 0;
385
}
386
387
180
static int cbs_av1_read_subexp(CodedBitstreamContext *ctx, GetBitContext *gbc,
388
                               uint32_t range_max, const char *name,
389
                               const int *subscripts, uint32_t *write_to)
390
{
391
    uint32_t value;
392
    int position, err;
393
    uint32_t max_len, len, range_offset, range_bits;
394
395
180
    if (ctx->trace_enable)
396
        position = get_bits_count(gbc);
397
398
180
    av_assert0(range_max > 0);
399
180
    max_len = av_log2(range_max - 1) - 3;
400
401
180
    err = cbs_av1_read_increment(ctx, gbc, 0, max_len,
402
                                 "subexp_more_bits", &len);
403
180
    if (err < 0)
404
        return err;
405
406
180
    if (len) {
407
165
        range_bits   = 2 + len;
408
165
        range_offset = 1 << range_bits;
409
    } else {
410
15
        range_bits   = 3;
411
15
        range_offset = 0;
412
    }
413
414
180
    if (len < max_len) {
415
180
        err = ff_cbs_read_unsigned(ctx, gbc, range_bits,
416
                                   "subexp_bits", NULL, &value,
417
180
                                   0, MAX_UINT_BITS(range_bits));
418
180
        if (err < 0)
419
            return err;
420
421
    } else {
422
        err = cbs_av1_read_ns(ctx, gbc, range_max - range_offset,
423
                              "subexp_final_bits", NULL, &value);
424
        if (err < 0)
425
            return err;
426
    }
427
180
    value += range_offset;
428
429
180
    if (ctx->trace_enable)
430
        ff_cbs_trace_syntax_element(ctx, position,
431
                                    name, subscripts, "", value);
432
433
180
    *write_to = value;
434
180
    return err;
435
}
436
437
120
static int cbs_av1_write_subexp(CodedBitstreamContext *ctx, PutBitContext *pbc,
438
                                uint32_t range_max, const char *name,
439
                                const int *subscripts, uint32_t value)
440
{
441
    int position, err;
442
    uint32_t max_len, len, range_offset, range_bits;
443
444
120
    if (value > range_max) {
445
        av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
446
               "%"PRIu32", but must be in [0,%"PRIu32"].\n",
447
               name, value, range_max);
448
        return AVERROR_INVALIDDATA;
449
    }
450
451
120
    if (ctx->trace_enable)
452
        position = put_bits_count(pbc);
453
454
120
    av_assert0(range_max > 0);
455
120
    max_len = av_log2(range_max - 1) - 3;
456
457
120
    if (value < 8) {
458
10
        range_bits   = 3;
459
10
        range_offset = 0;
460
10
        len = 0;
461
    } else {
462
110
        range_bits = av_log2(value);
463
110
        len = range_bits - 2;
464
110
        if (len > max_len) {
465
            // The top bin is combined with the one below it.
466
            av_assert0(len == max_len + 1);
467
            --range_bits;
468
            len = max_len;
469
        }
470
110
        range_offset = 1 << range_bits;
471
    }
472
473
120
    err = cbs_av1_write_increment(ctx, pbc, 0, max_len,
474
                                  "subexp_more_bits", len);
475
120
    if (err < 0)
476
        return err;
477
478
120
    if (len < max_len) {
479
120
        err = ff_cbs_write_unsigned(ctx, pbc, range_bits,
480
                                    "subexp_bits", NULL,
481
                                    value - range_offset,
482
120
                                    0, MAX_UINT_BITS(range_bits));
483
120
        if (err < 0)
484
            return err;
485
486
    } else {
487
        err = cbs_av1_write_ns(ctx, pbc, range_max - range_offset,
488
                               "subexp_final_bits", NULL,
489
                               value - range_offset);
490
        if (err < 0)
491
            return err;
492
    }
493
494
120
    if (ctx->trace_enable)
495
        ff_cbs_trace_syntax_element(ctx, position,
496
                                    name, subscripts, "", value);
497
498
120
    return err;
499
}
500
501
502
6885
static int cbs_av1_tile_log2(int blksize, int target)
503
{
504
    int k;
505
14225
    for (k = 0; (blksize << k) < target; k++);
506
6885
    return k;
507
}
508
509
13136
static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq,
510
                                     unsigned int a, unsigned int b)
511
{
512
    unsigned int diff, m;
513
13136
    if (!seq->enable_order_hint)
514
        return 0;
515
13136
    diff = a - b;
516
13136
    m = 1 << seq->order_hint_bits_minus_1;
517
13136
    diff = (diff & (m - 1)) - (diff & m);
518
13136
    return diff;
519
}
520
521
static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)
522
{
523
    GetBitContext tmp = *gbc;
524
    size_t size = 0;
525
    for (int i = 0; get_bits_left(&tmp) >= 8; i++) {
526
        if (get_bits(&tmp, 8))
527
            size = i;
528
    }
529
    return size;
530
}
531
532
533
#define HEADER(name) do { \
534
        ff_cbs_trace_header(ctx, name); \
535
    } while (0)
536
537
#define CHECK(call) do { \
538
        err = (call); \
539
        if (err < 0) \
540
            return err; \
541
    } while (0)
542
543
#define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
544
#define FUNC_AV1(rw, name) FUNC_NAME(rw, av1, name)
545
#define FUNC(name) FUNC_AV1(READWRITE, name)
546
547
#define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
548
549
#define fb(width, name) \
550
        xf(width, name, current->name, 0, MAX_UINT_BITS(width), 0)
551
#define fc(width, name, range_min, range_max) \
552
        xf(width, name, current->name, range_min, range_max, 0)
553
#define flag(name) fb(1, name)
554
#define su(width, name) \
555
        xsu(width, name, current->name, 0)
556
557
#define fbs(width, name, subs, ...) \
558
        xf(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
559
#define fcs(width, name, range_min, range_max, subs, ...) \
560
        xf(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
561
#define flags(name, subs, ...) \
562
        xf(1, name, current->name, 0, 1, subs, __VA_ARGS__)
563
#define sus(width, name, subs, ...) \
564
        xsu(width, name, current->name, subs, __VA_ARGS__)
565
566
#define fixed(width, name, value) do { \
567
        av_unused uint32_t fixed_value = value; \
568
        xf(width, name, fixed_value, value, value, 0); \
569
    } while (0)
570
571
572
#define READ
573
#define READWRITE read
574
#define RWContext GetBitContext
575
576
#define xf(width, name, var, range_min, range_max, subs, ...) do { \
577
        uint32_t value; \
578
        CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
579
                                   SUBSCRIPTS(subs, __VA_ARGS__), \
580
                                   &value, range_min, range_max)); \
581
        var = value; \
582
    } while (0)
583
584
#define xsu(width, name, var, subs, ...) do { \
585
        int32_t value; \
586
        CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
587
                                 SUBSCRIPTS(subs, __VA_ARGS__), &value, \
588
                                 MIN_INT_BITS(width), \
589
                                 MAX_INT_BITS(width))); \
590
        var = value; \
591
    } while (0)
592
593
#define uvlc(name, range_min, range_max) do { \
594
        uint32_t value; \
595
        CHECK(cbs_av1_read_uvlc(ctx, rw, #name, \
596
                                &value, range_min, range_max)); \
597
        current->name = value; \
598
    } while (0)
599
600
#define ns(max_value, name, subs, ...) do { \
601
        uint32_t value; \
602
        CHECK(cbs_av1_read_ns(ctx, rw, max_value, #name, \
603
                              SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
604
        current->name = value; \
605
    } while (0)
606
607
#define increment(name, min, max) do { \
608
        uint32_t value; \
609
        CHECK(cbs_av1_read_increment(ctx, rw, min, max, #name, &value)); \
610
        current->name = value; \
611
    } while (0)
612
613
#define subexp(name, max, subs, ...) do { \
614
        uint32_t value; \
615
        CHECK(cbs_av1_read_subexp(ctx, rw, max, #name, \
616
                                  SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
617
        current->name = value; \
618
    } while (0)
619
620
#define delta_q(name) do { \
621
        uint8_t delta_coded; \
622
        int8_t delta_q; \
623
        xf(1, name.delta_coded, delta_coded, 0, 1, 0); \
624
        if (delta_coded) \
625
            xsu(1 + 6, name.delta_q, delta_q, 0); \
626
        else \
627
            delta_q = 0; \
628
        current->name = delta_q; \
629
    } while (0)
630
631
#define leb128(name) do { \
632
        uint64_t value; \
633
        CHECK(cbs_av1_read_leb128(ctx, rw, #name, &value)); \
634
        current->name = value; \
635
    } while (0)
636
637
#define infer(name, value) do { \
638
        current->name = value; \
639
    } while (0)
640
641
#define byte_alignment(rw) (get_bits_count(rw) % 8)
642
643
#include "cbs_av1_syntax_template.c"
644
645
#undef READ
646
#undef READWRITE
647
#undef RWContext
648
#undef xf
649
#undef xsu
650
#undef uvlc
651
#undef ns
652
#undef increment
653
#undef subexp
654
#undef delta_q
655
#undef leb128
656
#undef infer
657
#undef byte_alignment
658
659
660
#define WRITE
661
#define READWRITE write
662
#define RWContext PutBitContext
663
664
#define xf(width, name, var, range_min, range_max, subs, ...) do { \
665
        CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
666
                                    SUBSCRIPTS(subs, __VA_ARGS__), \
667
                                    var, range_min, range_max)); \
668
    } while (0)
669
670
#define xsu(width, name, var, subs, ...) do { \
671
        CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
672
                                  SUBSCRIPTS(subs, __VA_ARGS__), var, \
673
                                  MIN_INT_BITS(width), \
674
                                  MAX_INT_BITS(width))); \
675
    } while (0)
676
677
#define uvlc(name, range_min, range_max) do { \
678
        CHECK(cbs_av1_write_uvlc(ctx, rw, #name, current->name, \
679
                                 range_min, range_max)); \
680
    } while (0)
681
682
#define ns(max_value, name, subs, ...) do { \
683
        CHECK(cbs_av1_write_ns(ctx, rw, max_value, #name, \
684
                               SUBSCRIPTS(subs, __VA_ARGS__), \
685
                               current->name)); \
686
    } while (0)
687
688
#define increment(name, min, max) do { \
689
        CHECK(cbs_av1_write_increment(ctx, rw, min, max, #name, \
690
                                      current->name)); \
691
    } while (0)
692
693
#define subexp(name, max, subs, ...) do { \
694
        CHECK(cbs_av1_write_subexp(ctx, rw, max, #name, \
695
                                   SUBSCRIPTS(subs, __VA_ARGS__), \
696
                                   current->name)); \
697
    } while (0)
698
699
#define delta_q(name) do { \
700
        xf(1, name.delta_coded, current->name != 0, 0, 1, 0); \
701
        if (current->name) \
702
            xsu(1 + 6, name.delta_q, current->name, 0); \
703
    } while (0)
704
705
#define leb128(name) do { \
706
        CHECK(cbs_av1_write_leb128(ctx, rw, #name, current->name)); \
707
    } while (0)
708
709
#define infer(name, value) do { \
710
        if (current->name != (value)) { \
711
            av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
712
                   "%s does not match inferred value: " \
713
                   "%"PRId64", but should be %"PRId64".\n", \
714
                   #name, (int64_t)current->name, (int64_t)(value)); \
715
        } \
716
    } while (0)
717
718
#define byte_alignment(rw) (put_bits_count(rw) % 8)
719
720
#include "cbs_av1_syntax_template.c"
721
722
#undef WRITE
723
#undef READWRITE
724
#undef RWContext
725
#undef xf
726
#undef xsu
727
#undef uvlc
728
#undef ns
729
#undef increment
730
#undef subexp
731
#undef delta_q
732
#undef leb128
733
#undef infer
734
#undef byte_alignment
735
736
737
785
static int cbs_av1_split_fragment(CodedBitstreamContext *ctx,
738
                                  CodedBitstreamFragment *frag,
739
                                  int header)
740
{
741
    GetBitContext gbc;
742
    uint8_t *data;
743
    size_t size;
744
    uint64_t obu_length;
745
    int pos, err, trace;
746
747
    // Don't include this parsing in trace output.
748
785
    trace = ctx->trace_enable;
749
785
    ctx->trace_enable = 0;
750
751
785
    data = frag->data;
752
785
    size = frag->data_size;
753
754
785
    if (INT_MAX / 8 < size) {
755
        av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid fragment: "
756
               "too large (%"SIZE_SPECIFIER" bytes).\n", size);
757
        err = AVERROR_INVALIDDATA;
758
        goto fail;
759
    }
760
761
2873
    while (size > 0) {
762
        AV1RawOBUHeader header;
763
        uint64_t obu_size;
764
765
2088
        init_get_bits(&gbc, data, 8 * size);
766
767
2088
        err = cbs_av1_read_obu_header(ctx, &gbc, &header);
768
2088
        if (err < 0)
769
            goto fail;
770
771
2088
        if (header.obu_has_size_field) {
772
2088
            if (get_bits_left(&gbc) < 8) {
773
                av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU: fragment "
774
                       "too short (%"SIZE_SPECIFIER" bytes).\n", size);
775
                err = AVERROR_INVALIDDATA;
776
                goto fail;
777
            }
778
2088
            err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
779
2088
            if (err < 0)
780
                goto fail;
781
        } else
782
            obu_size = size - 1 - header.obu_extension_flag;
783
784
2088
        pos = get_bits_count(&gbc);
785

2088
        av_assert0(pos % 8 == 0 && pos / 8 <= size);
786
787
2088
        obu_length = pos / 8 + obu_size;
788
789
2088
        if (size < obu_length) {
790
            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "
791
                   "%"PRIu64", but only %"SIZE_SPECIFIER" bytes remaining in fragment.\n",
792
                   obu_length, size);
793
            err = AVERROR_INVALIDDATA;
794
            goto fail;
795
        }
796
797
2088
        err = ff_cbs_insert_unit_data(ctx, frag, -1, header.obu_type,
798
                                      data, obu_length, frag->data_ref);
799
2088
        if (err < 0)
800
            goto fail;
801
802
2088
        data += obu_length;
803
2088
        size -= obu_length;
804
    }
805
806
785
    err = 0;
807
785
fail:
808
785
    ctx->trace_enable = trace;
809
785
    return err;
810
}
811
812
795
static void cbs_av1_free_tile_data(AV1RawTileData *td)
813
{
814
795
    av_buffer_unref(&td->data_ref);
815
795
}
816
817
static void cbs_av1_free_padding(AV1RawPadding *pd)
818
{
819
    av_buffer_unref(&pd->payload_ref);
820
}
821
822
24
static void cbs_av1_free_metadata(AV1RawMetadata *md)
823
{
824
24
    switch (md->metadata_type) {
825
    case AV1_METADATA_TYPE_ITUT_T35:
826
        av_buffer_unref(&md->metadata.itut_t35.payload_ref);
827
        break;
828
    }
829
24
}
830
831
2076
static void cbs_av1_free_obu(void *opaque, uint8_t *content)
832
{
833
2076
    AV1RawOBU *obu = (AV1RawOBU*)content;
834
835

2076
    switch (obu->header.obu_type) {
836
    case AV1_OBU_TILE_GROUP:
837
        cbs_av1_free_tile_data(&obu->obu.tile_group.tile_data);
838
        break;
839
795
    case AV1_OBU_FRAME:
840
795
        cbs_av1_free_tile_data(&obu->obu.frame.tile_group.tile_data);
841
795
        break;
842
    case AV1_OBU_TILE_LIST:
843
        cbs_av1_free_tile_data(&obu->obu.tile_list.tile_data);
844
        break;
845
24
    case AV1_OBU_METADATA:
846
24
        cbs_av1_free_metadata(&obu->obu.metadata);
847
24
        break;
848
    case AV1_OBU_PADDING:
849
        cbs_av1_free_padding(&obu->obu.padding);
850
        break;
851
    }
852
853
2076
    av_freep(&obu);
854
2076
}
855
856
795
static int cbs_av1_ref_tile_data(CodedBitstreamContext *ctx,
857
                                 CodedBitstreamUnit *unit,
858
                                 GetBitContext *gbc,
859
                                 AV1RawTileData *td)
860
{
861
    int pos;
862
863
795
    pos = get_bits_count(gbc);
864
795
    if (pos >= 8 * unit->data_size) {
865
        av_log(ctx->log_ctx, AV_LOG_ERROR, "Bitstream ended before "
866
               "any data in tile group (%d bits read).\n", pos);
867
        return AVERROR_INVALIDDATA;
868
    }
869
    // Must be byte-aligned at this point.
870
795
    av_assert0(pos % 8 == 0);
871
872
795
    td->data_ref = av_buffer_ref(unit->data_ref);
873
795
    if (!td->data_ref)
874
        return AVERROR(ENOMEM);
875
876
795
    td->data      = unit->data      + pos / 8;
877
795
    td->data_size = unit->data_size - pos / 8;
878
879
795
    return 0;
880
}
881
882
2076
static int cbs_av1_read_unit(CodedBitstreamContext *ctx,
883
                             CodedBitstreamUnit *unit)
884
{
885
2076
    CodedBitstreamAV1Context *priv = ctx->priv_data;
886
    AV1RawOBU *obu;
887
    GetBitContext gbc;
888
    int err, start_pos, end_pos;
889
890
2076
    err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*obu),
891
                                    &cbs_av1_free_obu);
892
2076
    if (err < 0)
893
        return err;
894
2076
    obu = unit->content;
895
896
2076
    err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
897
2076
    if (err < 0)
898
        return err;
899
900
2076
    err = cbs_av1_read_obu_header(ctx, &gbc, &obu->header);
901
2076
    if (err < 0)
902
        return err;
903
2076
    av_assert0(obu->header.obu_type == unit->type);
904
905
2076
    if (obu->header.obu_has_size_field) {
906
        uint64_t obu_size;
907
2076
        err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
908
2076
        if (err < 0)
909
            return err;
910
2076
        obu->obu_size = obu_size;
911
    } else {
912
        if (unit->data_size < 1 + obu->header.obu_extension_flag) {
913
            av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "
914
                   "unit too short (%"SIZE_SPECIFIER").\n", unit->data_size);
915
            return AVERROR_INVALIDDATA;
916
        }
917
        obu->obu_size = unit->data_size - 1 - obu->header.obu_extension_flag;
918
    }
919
920
2076
    start_pos = get_bits_count(&gbc);
921
922
2076
    if (obu->header.obu_extension_flag) {
923
        priv->temporal_id = obu->header.temporal_id;
924
        priv->spatial_id  = obu->header.spatial_id;
925
926
        if (obu->header.obu_type != AV1_OBU_SEQUENCE_HEADER &&
927
            obu->header.obu_type != AV1_OBU_TEMPORAL_DELIMITER &&
928
            priv->operating_point_idc) {
929
            int in_temporal_layer =
930
                (priv->operating_point_idc >>  priv->temporal_id    ) & 1;
931
            int in_spatial_layer  =
932
                (priv->operating_point_idc >> (priv->spatial_id + 8)) & 1;
933
            if (!in_temporal_layer || !in_spatial_layer) {
934
                // Decoding will drop this OBU at this operating point.
935
            }
936
        }
937
    } else {
938
2076
        priv->temporal_id = 0;
939
2076
        priv->spatial_id  = 0;
940
    }
941
942
2076
    priv->ref = (AV1ReferenceFrameState *)&priv->read_ref;
943
944


2076
    switch (obu->header.obu_type) {
945
396
    case AV1_OBU_SEQUENCE_HEADER:
946
        {
947
396
            err = cbs_av1_read_sequence_header_obu(ctx, &gbc,
948
                                                   &obu->obu.sequence_header);
949
396
            if (err < 0)
950
                return err;
951
952
396
            av_buffer_unref(&priv->sequence_header_ref);
953
396
            priv->sequence_header = NULL;
954
955
396
            priv->sequence_header_ref = av_buffer_ref(unit->content_ref);
956
396
            if (!priv->sequence_header_ref)
957
                return AVERROR(ENOMEM);
958
396
            priv->sequence_header = &obu->obu.sequence_header;
959
        }
960
396
        break;
961
741
    case AV1_OBU_TEMPORAL_DELIMITER:
962
        {
963
741
            err = cbs_av1_read_temporal_delimiter_obu(ctx, &gbc);
964
741
            if (err < 0)
965
                return err;
966
        }
967
741
        break;
968
120
    case AV1_OBU_FRAME_HEADER:
969
    case AV1_OBU_REDUNDANT_FRAME_HEADER:
970
        {
971
120
            err = cbs_av1_read_frame_header_obu(ctx, &gbc,
972
                                                &obu->obu.frame_header,
973
120
                                                obu->header.obu_type ==
974
                                                AV1_OBU_REDUNDANT_FRAME_HEADER,
975
                                                unit->data_ref);
976
120
            if (err < 0)
977
                return err;
978
        }
979
120
        break;
980
    case AV1_OBU_TILE_GROUP:
981
        {
982
            err = cbs_av1_read_tile_group_obu(ctx, &gbc,
983
                                              &obu->obu.tile_group);
984
            if (err < 0)
985
                return err;
986
987
            err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
988
                                        &obu->obu.tile_group.tile_data);
989
            if (err < 0)
990
                return err;
991
        }
992
        break;
993
795
    case AV1_OBU_FRAME:
994
        {
995
795
            err = cbs_av1_read_frame_obu(ctx, &gbc, &obu->obu.frame,
996
                                         unit->data_ref);
997
795
            if (err < 0)
998
                return err;
999
1000
795
            err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
1001
                                        &obu->obu.frame.tile_group.tile_data);
1002
795
            if (err < 0)
1003
                return err;
1004
        }
1005
795
        break;
1006
    case AV1_OBU_TILE_LIST:
1007
        {
1008
            err = cbs_av1_read_tile_list_obu(ctx, &gbc,
1009
                                             &obu->obu.tile_list);
1010
            if (err < 0)
1011
                return err;
1012
1013
            err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
1014
                                        &obu->obu.tile_list.tile_data);
1015
            if (err < 0)
1016
                return err;
1017
        }
1018
        break;
1019
24
    case AV1_OBU_METADATA:
1020
        {
1021
24
            err = cbs_av1_read_metadata_obu(ctx, &gbc, &obu->obu.metadata);
1022
24
            if (err < 0)
1023
                return err;
1024
        }
1025
24
        break;
1026
    case AV1_OBU_PADDING:
1027
        {
1028
            err = cbs_av1_read_padding_obu(ctx, &gbc, &obu->obu.padding);
1029
            if (err < 0)
1030
                return err;
1031
        }
1032
        break;
1033
    default:
1034
        return AVERROR(ENOSYS);
1035
    }
1036
1037
2076
    end_pos = get_bits_count(&gbc);
1038
2076
    av_assert0(end_pos <= unit->data_size * 8);
1039
1040
2076
    if (obu->obu_size > 0 &&
1041
1335
        obu->header.obu_type != AV1_OBU_TILE_GROUP &&
1042
1335
        obu->header.obu_type != AV1_OBU_FRAME) {
1043
540
        int nb_bits = obu->obu_size * 8 + start_pos - end_pos;
1044
1045
540
        if (nb_bits <= 0)
1046
            return AVERROR_INVALIDDATA;
1047
1048
540
        err = cbs_av1_read_trailing_bits(ctx, &gbc, nb_bits);
1049
540
        if (err < 0)
1050
            return err;
1051
    }
1052
1053
2076
    return 0;
1054
}
1055
1056
1392
static int cbs_av1_write_obu(CodedBitstreamContext *ctx,
1057
                             CodedBitstreamUnit *unit,
1058
                             PutBitContext *pbc)
1059
{
1060
1392
    CodedBitstreamAV1Context *priv = ctx->priv_data;
1061
1392
    AV1RawOBU *obu = unit->content;
1062
    PutBitContext pbc_tmp;
1063
    AV1RawTileData *td;
1064
    size_t header_size;
1065
    int err, start_pos, end_pos, data_pos;
1066
1067
    // OBUs in the normal bitstream format must contain a size field
1068
    // in every OBU (in annex B it is optional, but we don't support
1069
    // writing that).
1070
1392
    obu->header.obu_has_size_field = 1;
1071
1072
1392
    err = cbs_av1_write_obu_header(ctx, pbc, &obu->header);
1073
1392
    if (err < 0)
1074
        return err;
1075
1076
1392
    if (obu->header.obu_has_size_field) {
1077
1392
        pbc_tmp = *pbc;
1078
        // Add space for the size field to fill later.
1079
1392
        put_bits32(pbc, 0);
1080
1392
        put_bits32(pbc, 0);
1081
    }
1082
1083
1392
    td = NULL;
1084
1392
    start_pos = put_bits_count(pbc);
1085
1086
1392
    priv->ref = (AV1ReferenceFrameState *)&priv->write_ref;
1087
1088


1392
    switch (obu->header.obu_type) {
1089
264
    case AV1_OBU_SEQUENCE_HEADER:
1090
        {
1091
264
            err = cbs_av1_write_sequence_header_obu(ctx, pbc,
1092
                                                    &obu->obu.sequence_header);
1093
264
            if (err < 0)
1094
                return err;
1095
1096
264
            av_buffer_unref(&priv->sequence_header_ref);
1097
264
            priv->sequence_header = NULL;
1098
1099
264
            priv->sequence_header_ref = av_buffer_ref(unit->content_ref);
1100
264
            if (!priv->sequence_header_ref)
1101
                return AVERROR(ENOMEM);
1102
264
            priv->sequence_header = &obu->obu.sequence_header;
1103
        }
1104
264
        break;
1105
494
    case AV1_OBU_TEMPORAL_DELIMITER:
1106
        {
1107
494
            err = cbs_av1_write_temporal_delimiter_obu(ctx, pbc);
1108
494
            if (err < 0)
1109
                return err;
1110
        }
1111
494
        break;
1112
80
    case AV1_OBU_FRAME_HEADER:
1113
    case AV1_OBU_REDUNDANT_FRAME_HEADER:
1114
        {
1115
80
            err = cbs_av1_write_frame_header_obu(ctx, pbc,
1116
                                                 &obu->obu.frame_header,
1117
80
                                                 obu->header.obu_type ==
1118
                                                 AV1_OBU_REDUNDANT_FRAME_HEADER,
1119
                                                 NULL);
1120
80
            if (err < 0)
1121
                return err;
1122
        }
1123
80
        break;
1124
    case AV1_OBU_TILE_GROUP:
1125
        {
1126
            err = cbs_av1_write_tile_group_obu(ctx, pbc,
1127
                                               &obu->obu.tile_group);
1128
            if (err < 0)
1129
                return err;
1130
1131
            td = &obu->obu.tile_group.tile_data;
1132
        }
1133
        break;
1134
530
    case AV1_OBU_FRAME:
1135
        {
1136
530
            err = cbs_av1_write_frame_obu(ctx, pbc, &obu->obu.frame, NULL);
1137
530
            if (err < 0)
1138
                return err;
1139
1140
530
            td = &obu->obu.frame.tile_group.tile_data;
1141
        }
1142
530
        break;
1143
    case AV1_OBU_TILE_LIST:
1144
        {
1145
            err = cbs_av1_write_tile_list_obu(ctx, pbc, &obu->obu.tile_list);
1146
            if (err < 0)
1147
                return err;
1148
1149
            td = &obu->obu.tile_list.tile_data;
1150
        }
1151
        break;
1152
24
    case AV1_OBU_METADATA:
1153
        {
1154
24
            err = cbs_av1_write_metadata_obu(ctx, pbc, &obu->obu.metadata);
1155
24
            if (err < 0)
1156
                return err;
1157
        }
1158
24
        break;
1159
    case AV1_OBU_PADDING:
1160
        {
1161
            err = cbs_av1_write_padding_obu(ctx, pbc, &obu->obu.padding);
1162
            if (err < 0)
1163
                return err;
1164
        }
1165
        break;
1166
    default:
1167
        return AVERROR(ENOSYS);
1168
    }
1169
1170
1392
    end_pos = put_bits_count(pbc);
1171
1392
    header_size = (end_pos - start_pos + 7) / 8;
1172
1392
    if (td) {
1173
530
        obu->obu_size = header_size + td->data_size;
1174
862
    } else if (header_size > 0) {
1175
        // Add trailing bits and recalculate.
1176
368
        err = cbs_av1_write_trailing_bits(ctx, pbc, 8 - end_pos % 8);
1177
368
        if (err < 0)
1178
            return err;
1179
368
        end_pos = put_bits_count(pbc);
1180
368
        obu->obu_size = header_size = (end_pos - start_pos + 7) / 8;
1181
    } else {
1182
        // Empty OBU.
1183
494
        obu->obu_size = 0;
1184
    }
1185
1186
1392
    end_pos = put_bits_count(pbc);
1187
    // Must now be byte-aligned.
1188
1392
    av_assert0(end_pos % 8 == 0);
1189
1392
    flush_put_bits(pbc);
1190
1392
    start_pos /= 8;
1191
1392
    end_pos   /= 8;
1192
1193
1392
    *pbc = pbc_tmp;
1194
1392
    err = cbs_av1_write_leb128(ctx, pbc, "obu_size", obu->obu_size);
1195
1392
    if (err < 0)
1196
        return err;
1197
1198
1392
    data_pos = put_bits_count(pbc) / 8;
1199
1392
    flush_put_bits(pbc);
1200
1392
    av_assert0(data_pos <= start_pos);
1201
1202
1392
    if (8 * obu->obu_size > put_bits_left(pbc))
1203
        return AVERROR(ENOSPC);
1204
1205
1392
    if (obu->obu_size > 0) {
1206
898
        memmove(pbc->buf + data_pos,
1207
898
                pbc->buf + start_pos, header_size);
1208
898
        skip_put_bytes(pbc, header_size);
1209
1210
898
        if (td) {
1211
530
            memcpy(pbc->buf + data_pos + header_size,
1212
530
                   td->data, td->data_size);
1213
530
            skip_put_bytes(pbc, td->data_size);
1214
        }
1215
    }
1216
1217
    // OBU data must be byte-aligned.
1218
1392
    av_assert0(put_bits_count(pbc) % 8 == 0);
1219
1220
1392
    return 0;
1221
}
1222
1223
516
static int cbs_av1_assemble_fragment(CodedBitstreamContext *ctx,
1224
                                     CodedBitstreamFragment *frag)
1225
{
1226
    size_t size, pos;
1227
    int i;
1228
1229
516
    size = 0;
1230
1908
    for (i = 0; i < frag->nb_units; i++)
1231
1392
        size += frag->units[i].data_size;
1232
1233
516
    frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
1234
516
    if (!frag->data_ref)
1235
        return AVERROR(ENOMEM);
1236
516
    frag->data = frag->data_ref->data;
1237
516
    memset(frag->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1238
1239
516
    pos = 0;
1240
1908
    for (i = 0; i < frag->nb_units; i++) {
1241
1392
        memcpy(frag->data + pos, frag->units[i].data,
1242
1392
               frag->units[i].data_size);
1243
1392
        pos += frag->units[i].data_size;
1244
    }
1245
516
    av_assert0(pos == size);
1246
516
    frag->data_size = size;
1247
1248
516
    return 0;
1249
}
1250
1251
33
static void cbs_av1_close(CodedBitstreamContext *ctx)
1252
{
1253
33
    CodedBitstreamAV1Context *priv = ctx->priv_data;
1254
1255
33
    av_buffer_unref(&priv->sequence_header_ref);
1256
33
    av_buffer_unref(&priv->frame_header_ref);
1257
33
}
1258
1259
const CodedBitstreamType ff_cbs_type_av1 = {
1260
    .codec_id          = AV_CODEC_ID_AV1,
1261
1262
    .priv_data_size    = sizeof(CodedBitstreamAV1Context),
1263
1264
    .split_fragment    = &cbs_av1_split_fragment,
1265
    .read_unit         = &cbs_av1_read_unit,
1266
    .write_unit        = &cbs_av1_write_obu,
1267
    .assemble_fragment = &cbs_av1_assemble_fragment,
1268
1269
    .close             = &cbs_av1_close,
1270
};