git.sesse.net Git - ffmpeg/blob - libavcodec/cbs_av1.c

   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     zeroes = av_log2(value + 1);
 124     v = value - (1U << zeroes) + 1;
 125     put_bits(pbc, zeroes, 0);
 126     put_bits(pbc, 1, 1);
 127     put_bits(pbc, zeroes, v);
 128
 129     if (ctx->trace_enable) {
 130         char bits[65];
 131         int i, j;
 132         i = 0;
 133         for (j = 0; j < zeroes; j++)
 134             bits[i++] = '0';
 135         bits[i++] = '1';
 136         for (j = 0; j < zeroes; j++)
 137             bits[i++] = (v >> (zeroes - j - 1) & 1) ? '1' : '0';
 138         bits[i++] = 0;
 139         ff_cbs_trace_syntax_element(ctx, position, name, NULL,
 140                                     bits, value);
 141     }
 142
 143     return 0;
 144 }
 145
 146 static int cbs_av1_read_leb128(CodedBitstreamContext *ctx, GetBitContext *gbc,
 147                                const char *name, uint64_t *write_to)
 148 {
 149     uint64_t value;
 150     int position, err, i;
 151
 152     if (ctx->trace_enable)
 153         position = get_bits_count(gbc);
 154
 155     value = 0;
 156     for (i = 0; i < 8; i++) {
 157         int subscript[2] = { 1, i };
 158         uint32_t byte;
 159         err = ff_cbs_read_unsigned(ctx, gbc, 8, "leb128_byte[i]", subscript,
 160                                    &byte, 0x00, 0xff);
 161         if (err < 0)
 162             return err;
 163
 164         value |= (uint64_t)(byte & 0x7f) << (i * 7);
 165         if (!(byte & 0x80))
 166             break;
 167     }
 168
 169     if (value > UINT32_MAX)
 170         return AVERROR_INVALIDDATA;
 171
 172     if (ctx->trace_enable)
 173         ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);
 174
 175     *write_to = value;
 176     return 0;
 177 }
 178
 179 static int cbs_av1_write_leb128(CodedBitstreamContext *ctx, PutBitContext *pbc,
 180                                 const char *name, uint64_t value)
 181 {
 182     int position, err, len, i;
 183     uint8_t byte;
 184
 185     len = (av_log2(value) + 7) / 7;
 186
 187     if (ctx->trace_enable)
 188         position = put_bits_count(pbc);
 189
 190     for (i = 0; i < len; i++) {
 191         int subscript[2] = { 1, i };
 192
 193         byte = value >> (7 * i) & 0x7f;
 194         if (i < len - 1)
 195             byte |= 0x80;
 196
 197         err = ff_cbs_write_unsigned(ctx, pbc, 8, "leb128_byte[i]", subscript,
 198                                     byte, 0x00, 0xff);
 199         if (err < 0)
 200             return err;
 201     }
 202
 203     if (ctx->trace_enable)
 204         ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);
 205
 206     return 0;
 207 }
 208
 209 static int cbs_av1_read_ns(CodedBitstreamContext *ctx, GetBitContext *gbc,
 210                            uint32_t n, const char *name,
 211                            const int *subscripts, uint32_t *write_to)
 212 {
 213     uint32_t m, v, extra_bit, value;
 214     int position, w;
 215
 216     av_assert0(n > 0);
 217
 218     if (ctx->trace_enable)
 219         position = get_bits_count(gbc);
 220
 221     w = av_log2(n) + 1;
 222     m = (1 << w) - n;
 223
 224     if (get_bits_left(gbc) < w) {
 225         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid non-symmetric value at "
 226                "%s: bitstream ended.\n", name);
 227         return AVERROR_INVALIDDATA;
 228     }
 229
 230     if (w - 1 > 0)
 231         v = get_bits(gbc, w - 1);
 232     else
 233         v = 0;
 234
 235     if (v < m) {
 236         value = v;
 237     } else {
 238         extra_bit = get_bits1(gbc);
 239         value = (v << 1) - m + extra_bit;
 240     }
 241
 242     if (ctx->trace_enable) {
 243         char bits[33];
 244         int i;
 245         for (i = 0; i < w - 1; i++)
 246             bits[i] = (v >> i & 1) ? '1' : '0';
 247         if (v >= m)
 248             bits[i++] = extra_bit ? '1' : '0';
 249         bits[i] = 0;
 250
 251         ff_cbs_trace_syntax_element(ctx, position,
 252                                     name, subscripts, bits, value);
 253     }
 254
 255     *write_to = value;
 256     return 0;
 257 }
 258
 259 static int cbs_av1_write_ns(CodedBitstreamContext *ctx, PutBitContext *pbc,
 260                             uint32_t n, const char *name,
 261                             const int *subscripts, uint32_t value)
 262 {
 263     uint32_t w, m, v, extra_bit;
 264     int position;
 265
 266     if (value > n) {
 267         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 268                "%"PRIu32", but must be in [0,%"PRIu32"].\n",
 269                name, value, n);
 270         return AVERROR_INVALIDDATA;
 271     }
 272
 273     if (ctx->trace_enable)
 274         position = put_bits_count(pbc);
 275
 276     w = av_log2(n) + 1;
 277     m = (1 << w) - n;
 278
 279     if (put_bits_left(pbc) < w)
 280         return AVERROR(ENOSPC);
 281
 282     if (value < m) {
 283         v = value;
 284         put_bits(pbc, w - 1, v);
 285     } else {
 286         v = m + ((value - m) >> 1);
 287         extra_bit = (value - m) & 1;
 288         put_bits(pbc, w - 1, v);
 289         put_bits(pbc, 1, extra_bit);
 290     }
 291
 292     if (ctx->trace_enable) {
 293         char bits[33];
 294         int i;
 295         for (i = 0; i < w - 1; i++)
 296             bits[i] = (v >> i & 1) ? '1' : '0';
 297         if (value >= m)
 298             bits[i++] = extra_bit ? '1' : '0';
 299         bits[i] = 0;
 300
 301         ff_cbs_trace_syntax_element(ctx, position,
 302                                     name, subscripts, bits, value);
 303     }
 304
 305     return 0;
 306 }
 307
 308 static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc,
 309                                   uint32_t range_min, uint32_t range_max,
 310                                   const char *name, uint32_t *write_to)
 311 {
 312     uint32_t value;
 313     int position, i;
 314     char bits[33];
 315
 316     av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
 317     if (ctx->trace_enable)
 318         position = get_bits_count(gbc);
 319
 320     for (i = 0, value = range_min; value < range_max;) {
 321         if (get_bits_left(gbc) < 1) {
 322             av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
 323                    "%s: bitstream ended.\n", name);
 324             return AVERROR_INVALIDDATA;
 325         }
 326         if (get_bits1(gbc)) {
 327             bits[i++] = '1';
 328             ++value;
 329         } else {
 330             bits[i++] = '0';
 331             break;
 332         }
 333     }
 334
 335     if (ctx->trace_enable) {
 336         bits[i] = 0;
 337         ff_cbs_trace_syntax_element(ctx, position,
 338                                     name, NULL, bits, value);
 339     }
 340
 341     *write_to = value;
 342     return 0;
 343 }
 344
 345 static int cbs_av1_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc,
 346                                    uint32_t range_min, uint32_t range_max,
 347                                    const char *name, uint32_t value)
 348 {
 349     int len;
 350
 351     av_assert0(range_min <= range_max && range_max - range_min < 32);
 352     if (value < range_min || value > range_max) {
 353         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 354                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
 355                name, value, range_min, range_max);
 356         return AVERROR_INVALIDDATA;
 357     }
 358
 359     if (value == range_max)
 360         len = range_max - range_min;
 361     else
 362         len = value - range_min + 1;
 363     if (put_bits_left(pbc) < len)
 364         return AVERROR(ENOSPC);
 365
 366     if (ctx->trace_enable) {
 367         char bits[33];
 368         int i;
 369         for (i = 0; i < len; i++) {
 370             if (range_min + i == value)
 371                 bits[i] = '0';
 372             else
 373                 bits[i] = '1';
 374         }
 375         bits[i] = 0;
 376         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
 377                                     name, NULL, bits, value);
 378     }
 379
 380     if (len > 0)
 381         put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
 382
 383     return 0;
 384 }
 385
 386 static int cbs_av1_read_subexp(CodedBitstreamContext *ctx, GetBitContext *gbc,
 387                                uint32_t range_max, const char *name,
 388                                const int *subscripts, uint32_t *write_to)
 389 {
 390     uint32_t value;
 391     int position, err;
 392     uint32_t max_len, len, range_offset, range_bits;
 393
 394     if (ctx->trace_enable)
 395         position = get_bits_count(gbc);
 396
 397     av_assert0(range_max > 0);
 398     max_len = av_log2(range_max - 1) - 3;
 399
 400     err = cbs_av1_read_increment(ctx, gbc, 0, max_len,
 401                                  "subexp_more_bits", &len);
 402     if (err < 0)
 403         return err;
 404
 405     if (len) {
 406         range_bits   = 2 + len;
 407         range_offset = 1 << range_bits;
 408     } else {
 409         range_bits   = 3;
 410         range_offset = 0;
 411     }
 412
 413     if (len < max_len) {
 414         err = ff_cbs_read_unsigned(ctx, gbc, range_bits,
 415                                    "subexp_bits", NULL, &value,
 416                                    0, MAX_UINT_BITS(range_bits));
 417         if (err < 0)
 418             return err;
 419
 420     } else {
 421         err = cbs_av1_read_ns(ctx, gbc, range_max - range_offset,
 422                               "subexp_final_bits", NULL, &value);
 423         if (err < 0)
 424             return err;
 425     }
 426     value += range_offset;
 427
 428     if (ctx->trace_enable)
 429         ff_cbs_trace_syntax_element(ctx, position,
 430                                     name, subscripts, "", value);
 431
 432     *write_to = value;
 433     return err;
 434 }
 435
 436 static int cbs_av1_write_subexp(CodedBitstreamContext *ctx, PutBitContext *pbc,
 437                                 uint32_t range_max, const char *name,
 438                                 const int *subscripts, uint32_t value)
 439 {
 440     int position, err;
 441     uint32_t max_len, len, range_offset, range_bits;
 442
 443     if (value > range_max) {
 444         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 445                "%"PRIu32", but must be in [0,%"PRIu32"].\n",
 446                name, value, range_max);
 447         return AVERROR_INVALIDDATA;
 448     }
 449
 450     if (ctx->trace_enable)
 451         position = put_bits_count(pbc);
 452
 453     av_assert0(range_max > 0);
 454     max_len = av_log2(range_max - 1) - 3;
 455
 456     if (value < 8) {
 457         range_bits   = 3;
 458         range_offset = 0;
 459         len = 0;
 460     } else {
 461         range_bits = av_log2(value);
 462         len = range_bits - 2;
 463         if (len > max_len) {
 464             // The top bin is combined with the one below it.
 465             av_assert0(len == max_len + 1);
 466             --range_bits;
 467             len = max_len;
 468         }
 469         range_offset = 1 << range_bits;
 470     }
 471
 472     err = cbs_av1_write_increment(ctx, pbc, 0, max_len,
 473                                   "subexp_more_bits", len);
 474     if (err < 0)
 475         return err;
 476
 477     if (len < max_len) {
 478         err = ff_cbs_write_unsigned(ctx, pbc, range_bits,
 479                                     "subexp_bits", NULL,
 480                                     value - range_offset,
 481                                     0, MAX_UINT_BITS(range_bits));
 482         if (err < 0)
 483             return err;
 484
 485     } else {
 486         err = cbs_av1_write_ns(ctx, pbc, range_max - range_offset,
 487                                "subexp_final_bits", NULL,
 488                                value - range_offset);
 489         if (err < 0)
 490             return err;
 491     }
 492
 493     if (ctx->trace_enable)
 494         ff_cbs_trace_syntax_element(ctx, position,
 495                                     name, subscripts, "", value);
 496
 497     return err;
 498 }
 499
 500
 501 static int cbs_av1_tile_log2(int blksize, int target)
 502 {
 503     int k;
 504     for (k = 0; (blksize << k) < target; k++);
 505     return k;
 506 }
 507
 508 static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq,
 509                                      unsigned int a, unsigned int b)
 510 {
 511     unsigned int diff, m;
 512     if (!seq->enable_order_hint)
 513         return 0;
 514     diff = a - b;
 515     m = 1 << seq->order_hint_bits_minus_1;
 516     diff = (diff & (m - 1)) - (diff & m);
 517     return diff;
 518 }
 519
 520 static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)
 521 {
 522     GetBitContext tmp = *gbc;
 523     size_t size = 0;
 524     for (int i = 0; get_bits_left(&tmp) >= 8; i++) {
 525         if (get_bits(&tmp, 8))
 526             size = i;
 527     }
 528     return size;
 529 }
 530
 531
 532 #define HEADER(name) do { \
 533         ff_cbs_trace_header(ctx, name); \
 534     } while (0)
 535
 536 #define CHECK(call) do { \
 537         err = (call); \
 538         if (err < 0) \
 539             return err; \
 540     } while (0)
 541
 542 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
 543 #define FUNC_AV1(rw, name) FUNC_NAME(rw, av1, name)
 544 #define FUNC(name) FUNC_AV1(READWRITE, name)
 545
 546 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
 547
 548 #define fb(width, name) \
 549         xf(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )
 550 #define fc(width, name, range_min, range_max) \
 551         xf(width, name, current->name, range_min, range_max, 0, )
 552 #define flag(name) fb(1, name)
 553 #define su(width, name) \
 554         xsu(width, name, current->name, 0, )
 555
 556 #define fbs(width, name, subs, ...) \
 557         xf(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
 558 #define fcs(width, name, range_min, range_max, subs, ...) \
 559         xf(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
 560 #define flags(name, subs, ...) \
 561         xf(1, name, current->name, 0, 1, subs, __VA_ARGS__)
 562 #define sus(width, name, subs, ...) \
 563         xsu(width, name, current->name, subs, __VA_ARGS__)
 564
 565 #define fixed(width, name, value) do { \
 566         av_unused uint32_t fixed_value = value; \
 567         xf(width, name, fixed_value, value, value, 0, ); \
 568     } while (0)
 569
 570
 571 #define READ
 572 #define READWRITE read
 573 #define RWContext GetBitContext
 574
 575 #define xf(width, name, var, range_min, range_max, subs, ...) do { \
 576         uint32_t value; \
 577         CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
 578                                    SUBSCRIPTS(subs, __VA_ARGS__), \
 579                                    &value, range_min, range_max)); \
 580         var = value; \
 581     } while (0)
 582
 583 #define xsu(width, name, var, subs, ...) do { \
 584         int32_t value; \
 585         CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
 586                                  SUBSCRIPTS(subs, __VA_ARGS__), &value, \
 587                                  MIN_INT_BITS(width), \
 588                                  MAX_INT_BITS(width))); \
 589         var = value; \
 590     } while (0)
 591
 592 #define uvlc(name, range_min, range_max) do { \
 593         uint32_t value; \
 594         CHECK(cbs_av1_read_uvlc(ctx, rw, #name, \
 595                                 &value, range_min, range_max)); \
 596         current->name = value; \
 597     } while (0)
 598
 599 #define ns(max_value, name, subs, ...) do { \
 600         uint32_t value; \
 601         CHECK(cbs_av1_read_ns(ctx, rw, max_value, #name, \
 602                               SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
 603         current->name = value; \
 604     } while (0)
 605
 606 #define increment(name, min, max) do { \
 607         uint32_t value; \
 608         CHECK(cbs_av1_read_increment(ctx, rw, min, max, #name, &value)); \
 609         current->name = value; \
 610     } while (0)
 611
 612 #define subexp(name, max, subs, ...) do { \
 613         uint32_t value; \
 614         CHECK(cbs_av1_read_subexp(ctx, rw, max, #name, \
 615                                   SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
 616         current->name = value; \
 617     } while (0)
 618
 619 #define delta_q(name) do { \
 620         uint8_t delta_coded; \
 621         int8_t delta_q; \
 622         xf(1, name.delta_coded, delta_coded, 0, 1, 0, ); \
 623         if (delta_coded) \
 624             xsu(1 + 6, name.delta_q, delta_q, 0, ); \
 625         else \
 626             delta_q = 0; \
 627         current->name = delta_q; \
 628     } while (0)
 629
 630 #define leb128(name) do { \
 631         uint64_t value; \
 632         CHECK(cbs_av1_read_leb128(ctx, rw, #name, &value)); \
 633         current->name = value; \
 634     } while (0)
 635
 636 #define infer(name, value) do { \
 637         current->name = value; \
 638     } while (0)
 639
 640 #define byte_alignment(rw) (get_bits_count(rw) % 8)
 641
 642 #include "cbs_av1_syntax_template.c"
 643
 644 #undef READ
 645 #undef READWRITE
 646 #undef RWContext
 647 #undef xf
 648 #undef xsu
 649 #undef uvlc
 650 #undef ns
 651 #undef increment
 652 #undef subexp
 653 #undef delta_q
 654 #undef leb128
 655 #undef infer
 656 #undef byte_alignment
 657
 658
 659 #define WRITE
 660 #define READWRITE write
 661 #define RWContext PutBitContext
 662
 663 #define xf(width, name, var, range_min, range_max, subs, ...) do { \
 664         CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
 665                                     SUBSCRIPTS(subs, __VA_ARGS__), \
 666                                     var, range_min, range_max)); \
 667     } while (0)
 668
 669 #define xsu(width, name, var, subs, ...) do { \
 670         CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
 671                                   SUBSCRIPTS(subs, __VA_ARGS__), var, \
 672                                   MIN_INT_BITS(width), \
 673                                   MAX_INT_BITS(width))); \
 674     } while (0)
 675
 676 #define uvlc(name, range_min, range_max) do { \
 677         CHECK(cbs_av1_write_uvlc(ctx, rw, #name, current->name, \
 678                                  range_min, range_max)); \
 679     } while (0)
 680
 681 #define ns(max_value, name, subs, ...) do { \
 682         CHECK(cbs_av1_write_ns(ctx, rw, max_value, #name, \
 683                                SUBSCRIPTS(subs, __VA_ARGS__), \
 684                                current->name)); \
 685     } while (0)
 686
 687 #define increment(name, min, max) do { \
 688         CHECK(cbs_av1_write_increment(ctx, rw, min, max, #name, \
 689                                       current->name)); \
 690     } while (0)
 691
 692 #define subexp(name, max, subs, ...) do { \
 693         CHECK(cbs_av1_write_subexp(ctx, rw, max, #name, \
 694                                    SUBSCRIPTS(subs, __VA_ARGS__), \
 695                                    current->name)); \
 696     } while (0)
 697
 698 #define delta_q(name) do { \
 699         xf(1, name.delta_coded, current->name != 0, 0, 1, 0, ); \
 700         if (current->name) \
 701             xsu(1 + 6, name.delta_q, current->name, 0, ); \
 702     } while (0)
 703
 704 #define leb128(name) do { \
 705         CHECK(cbs_av1_write_leb128(ctx, rw, #name, current->name)); \
 706     } while (0)
 707
 708 #define infer(name, value) do { \
 709         if (current->name != (value)) { \
 710             av_log(ctx->log_ctx, AV_LOG_ERROR, \
 711                    "%s does not match inferred value: " \
 712                    "%"PRId64", but should be %"PRId64".\n", \
 713                    #name, (int64_t)current->name, (int64_t)(value)); \
 714             return AVERROR_INVALIDDATA; \
 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 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     trace = ctx->trace_enable;
 749     ctx->trace_enable = 0;
 750
 751     data = frag->data;
 752     size = frag->data_size;
 753
 754     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     while (size > 0) {
 762         AV1RawOBUHeader header;
 763         uint64_t obu_size;
 764
 765         init_get_bits(&gbc, data, 8 * size);
 766
 767         err = cbs_av1_read_obu_header(ctx, &gbc, &header);
 768         if (err < 0)
 769             goto fail;
 770
 771         if (header.obu_has_size_field) {
 772             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             err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
 779             if (err < 0)
 780                 goto fail;
 781         } else
 782             obu_size = size - 1 - header.obu_extension_flag;
 783
 784         pos = get_bits_count(&gbc);
 785         av_assert0(pos % 8 == 0 && pos / 8 <= size);
 786
 787         obu_length = pos / 8 + obu_size;
 788
 789         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         err = ff_cbs_insert_unit_data(frag, -1, header.obu_type,
 798                                       data, obu_length, frag->data_ref);
 799         if (err < 0)
 800             goto fail;
 801
 802         data += obu_length;
 803         size -= obu_length;
 804     }
 805
 806     err = 0;
 807 fail:
 808     ctx->trace_enable = trace;
 809     return err;
 810 }
 811
 812 static void cbs_av1_free_tile_data(AV1RawTileData *td)
 813 {
 814     av_buffer_unref(&td->data_ref);
 815 }
 816
 817 static void cbs_av1_free_padding(AV1RawPadding *pd)
 818 {
 819     av_buffer_unref(&pd->payload_ref);
 820 }
 821
 822 static void cbs_av1_free_metadata(AV1RawMetadata *md)
 823 {
 824     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 }
 830
 831 static void cbs_av1_free_obu(void *opaque, uint8_t *content)
 832 {
 833     AV1RawOBU *obu = (AV1RawOBU*)content;
 834
 835     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     case AV1_OBU_FRAME:
 840         cbs_av1_free_tile_data(&obu->obu.frame.tile_group.tile_data);
 841         break;
 842     case AV1_OBU_TILE_LIST:
 843         cbs_av1_free_tile_data(&obu->obu.tile_list.tile_data);
 844         break;
 845     case AV1_OBU_METADATA:
 846         cbs_av1_free_metadata(&obu->obu.metadata);
 847         break;
 848     case AV1_OBU_PADDING:
 849         cbs_av1_free_padding(&obu->obu.padding);
 850         break;
 851     }
 852
 853     av_freep(&obu);
 854 }
 855
 856 static int cbs_av1_ref_tile_data(CodedBitstreamContext *ctx,
 857                                  CodedBitstreamUnit *unit,
 858                                  GetBitContext *gbc,
 859                                  AV1RawTileData *td)
 860 {
 861     int pos;
 862
 863     pos = get_bits_count(gbc);
 864     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     av_assert0(pos % 8 == 0);
 871
 872     td->data_ref = av_buffer_ref(unit->data_ref);
 873     if (!td->data_ref)
 874         return AVERROR(ENOMEM);
 875
 876     td->data      = unit->data      + pos / 8;
 877     td->data_size = unit->data_size - pos / 8;
 878
 879     return 0;
 880 }
 881
 882 static int cbs_av1_read_unit(CodedBitstreamContext *ctx,
 883                              CodedBitstreamUnit *unit)
 884 {
 885     CodedBitstreamAV1Context *priv = ctx->priv_data;
 886     AV1RawOBU *obu;
 887     GetBitContext gbc;
 888     int err, start_pos, end_pos;
 889
 890     err = ff_cbs_alloc_unit_content(unit, sizeof(*obu),
 891                                     &cbs_av1_free_obu);
 892     if (err < 0)
 893         return err;
 894     obu = unit->content;
 895
 896     err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
 897     if (err < 0)
 898         return err;
 899
 900     err = cbs_av1_read_obu_header(ctx, &gbc, &obu->header);
 901     if (err < 0)
 902         return err;
 903     av_assert0(obu->header.obu_type == unit->type);
 904
 905     if (obu->header.obu_has_size_field) {
 906         uint64_t obu_size;
 907         err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
 908         if (err < 0)
 909             return err;
 910         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     start_pos = get_bits_count(&gbc);
 921
 922     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         priv->temporal_id = 0;
 939         priv->spatial_id  = 0;
 940     }
 941
 942     switch (obu->header.obu_type) {
 943     case AV1_OBU_SEQUENCE_HEADER:
 944         {
 945             err = cbs_av1_read_sequence_header_obu(ctx, &gbc,
 946                                                    &obu->obu.sequence_header);
 947             if (err < 0)
 948                 return err;
 949
 950             av_buffer_unref(&priv->sequence_header_ref);
 951             priv->sequence_header = NULL;
 952
 953             priv->sequence_header_ref = av_buffer_ref(unit->content_ref);
 954             if (!priv->sequence_header_ref)
 955                 return AVERROR(ENOMEM);
 956             priv->sequence_header = &obu->obu.sequence_header;
 957         }
 958         break;
 959     case AV1_OBU_TEMPORAL_DELIMITER:
 960         {
 961             err = cbs_av1_read_temporal_delimiter_obu(ctx, &gbc);
 962             if (err < 0)
 963                 return err;
 964         }
 965         break;
 966     case AV1_OBU_FRAME_HEADER:
 967     case AV1_OBU_REDUNDANT_FRAME_HEADER:
 968         {
 969             err = cbs_av1_read_frame_header_obu(ctx, &gbc,
 970                                                 &obu->obu.frame_header,
 971                                                 obu->header.obu_type ==
 972                                                 AV1_OBU_REDUNDANT_FRAME_HEADER,
 973                                                 unit->data_ref);
 974             if (err < 0)
 975                 return err;
 976         }
 977         break;
 978     case AV1_OBU_TILE_GROUP:
 979         {
 980             err = cbs_av1_read_tile_group_obu(ctx, &gbc,
 981                                               &obu->obu.tile_group);
 982             if (err < 0)
 983                 return err;
 984
 985             err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
 986                                         &obu->obu.tile_group.tile_data);
 987             if (err < 0)
 988                 return err;
 989         }
 990         break;
 991     case AV1_OBU_FRAME:
 992         {
 993             err = cbs_av1_read_frame_obu(ctx, &gbc, &obu->obu.frame,
 994                                          unit->data_ref);
 995             if (err < 0)
 996                 return err;
 997
 998             err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
 999                                         &obu->obu.frame.tile_group.tile_data);
1000             if (err < 0)
1001                 return err;
1002         }
1003         break;
1004     case AV1_OBU_TILE_LIST:
1005         {
1006             err = cbs_av1_read_tile_list_obu(ctx, &gbc,
1007                                              &obu->obu.tile_list);
1008             if (err < 0)
1009                 return err;
1010
1011             err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
1012                                         &obu->obu.tile_list.tile_data);
1013             if (err < 0)
1014                 return err;
1015         }
1016         break;
1017     case AV1_OBU_METADATA:
1018         {
1019             err = cbs_av1_read_metadata_obu(ctx, &gbc, &obu->obu.metadata);
1020             if (err < 0)
1021                 return err;
1022         }
1023         break;
1024     case AV1_OBU_PADDING:
1025         {
1026             err = cbs_av1_read_padding_obu(ctx, &gbc, &obu->obu.padding);
1027             if (err < 0)
1028                 return err;
1029         }
1030         break;
1031     default:
1032         return AVERROR(ENOSYS);
1033     }
1034
1035     end_pos = get_bits_count(&gbc);
1036     av_assert0(end_pos <= unit->data_size * 8);
1037
1038     if (obu->obu_size > 0 &&
1039         obu->header.obu_type != AV1_OBU_TILE_GROUP &&
1040         obu->header.obu_type != AV1_OBU_TILE_LIST &&
1041         obu->header.obu_type != AV1_OBU_FRAME) {
1042         int nb_bits = obu->obu_size * 8 + start_pos - end_pos;
1043
1044         if (nb_bits <= 0)
1045             return AVERROR_INVALIDDATA;
1046
1047         err = cbs_av1_read_trailing_bits(ctx, &gbc, nb_bits);
1048         if (err < 0)
1049             return err;
1050     }
1051
1052     return 0;
1053 }
1054
1055 static int cbs_av1_write_obu(CodedBitstreamContext *ctx,
1056                              CodedBitstreamUnit *unit,
1057                              PutBitContext *pbc)
1058 {
1059     CodedBitstreamAV1Context *priv = ctx->priv_data;
1060     AV1RawOBU *obu = unit->content;
1061     PutBitContext pbc_tmp;
1062     AV1RawTileData *td;
1063     size_t header_size;
1064     int err, start_pos, end_pos, data_pos;
1065
1066     // OBUs in the normal bitstream format must contain a size field
1067     // in every OBU (in annex B it is optional, but we don't support
1068     // writing that).
1069     obu->header.obu_has_size_field = 1;
1070
1071     err = cbs_av1_write_obu_header(ctx, pbc, &obu->header);
1072     if (err < 0)
1073         return err;
1074
1075     if (obu->header.obu_has_size_field) {
1076         pbc_tmp = *pbc;
1077         // Add space for the size field to fill later.
1078         put_bits32(pbc, 0);
1079         put_bits32(pbc, 0);
1080     }
1081
1082     td = NULL;
1083     start_pos = put_bits_count(pbc);
1084
1085     switch (obu->header.obu_type) {
1086     case AV1_OBU_SEQUENCE_HEADER:
1087         {
1088             err = cbs_av1_write_sequence_header_obu(ctx, pbc,
1089                                                     &obu->obu.sequence_header);
1090             if (err < 0)
1091                 return err;
1092
1093             av_buffer_unref(&priv->sequence_header_ref);
1094             priv->sequence_header = NULL;
1095
1096             priv->sequence_header_ref = av_buffer_ref(unit->content_ref);
1097             if (!priv->sequence_header_ref)
1098                 return AVERROR(ENOMEM);
1099             priv->sequence_header = &obu->obu.sequence_header;
1100         }
1101         break;
1102     case AV1_OBU_TEMPORAL_DELIMITER:
1103         {
1104             err = cbs_av1_write_temporal_delimiter_obu(ctx, pbc);
1105             if (err < 0)
1106                 return err;
1107         }
1108         break;
1109     case AV1_OBU_FRAME_HEADER:
1110     case AV1_OBU_REDUNDANT_FRAME_HEADER:
1111         {
1112             err = cbs_av1_write_frame_header_obu(ctx, pbc,
1113                                                  &obu->obu.frame_header,
1114                                                  obu->header.obu_type ==
1115                                                  AV1_OBU_REDUNDANT_FRAME_HEADER,
1116                                                  NULL);
1117             if (err < 0)
1118                 return err;
1119         }
1120         break;
1121     case AV1_OBU_TILE_GROUP:
1122         {
1123             err = cbs_av1_write_tile_group_obu(ctx, pbc,
1124                                                &obu->obu.tile_group);
1125             if (err < 0)
1126                 return err;
1127
1128             td = &obu->obu.tile_group.tile_data;
1129         }
1130         break;
1131     case AV1_OBU_FRAME:
1132         {
1133             err = cbs_av1_write_frame_obu(ctx, pbc, &obu->obu.frame, NULL);
1134             if (err < 0)
1135                 return err;
1136
1137             td = &obu->obu.frame.tile_group.tile_data;
1138         }
1139         break;
1140     case AV1_OBU_TILE_LIST:
1141         {
1142             err = cbs_av1_write_tile_list_obu(ctx, pbc, &obu->obu.tile_list);
1143             if (err < 0)
1144                 return err;
1145
1146             td = &obu->obu.tile_list.tile_data;
1147         }
1148         break;
1149     case AV1_OBU_METADATA:
1150         {
1151             err = cbs_av1_write_metadata_obu(ctx, pbc, &obu->obu.metadata);
1152             if (err < 0)
1153                 return err;
1154         }
1155         break;
1156     case AV1_OBU_PADDING:
1157         {
1158             err = cbs_av1_write_padding_obu(ctx, pbc, &obu->obu.padding);
1159             if (err < 0)
1160                 return err;
1161         }
1162         break;
1163     default:
1164         return AVERROR(ENOSYS);
1165     }
1166
1167     end_pos = put_bits_count(pbc);
1168     header_size = (end_pos - start_pos + 7) / 8;
1169     if (td) {
1170         obu->obu_size = header_size + td->data_size;
1171     } else if (header_size > 0) {
1172         // Add trailing bits and recalculate.
1173         err = cbs_av1_write_trailing_bits(ctx, pbc, 8 - end_pos % 8);
1174         if (err < 0)
1175             return err;
1176         end_pos = put_bits_count(pbc);
1177         obu->obu_size = header_size = (end_pos - start_pos + 7) / 8;
1178     } else {
1179         // Empty OBU.
1180         obu->obu_size = 0;
1181     }
1182
1183     end_pos = put_bits_count(pbc);
1184     // Must now be byte-aligned.
1185     av_assert0(end_pos % 8 == 0);
1186     flush_put_bits(pbc);
1187     start_pos /= 8;
1188     end_pos   /= 8;
1189
1190     *pbc = pbc_tmp;
1191     err = cbs_av1_write_leb128(ctx, pbc, "obu_size", obu->obu_size);
1192     if (err < 0)
1193         return err;
1194
1195     data_pos = put_bits_count(pbc) / 8;
1196     flush_put_bits(pbc);
1197     av_assert0(data_pos <= start_pos);
1198
1199     if (8 * obu->obu_size > put_bits_left(pbc))
1200         return AVERROR(ENOSPC);
1201
1202     if (obu->obu_size > 0) {
1203         memmove(pbc->buf + data_pos,
1204                 pbc->buf + start_pos, header_size);
1205         skip_put_bytes(pbc, header_size);
1206
1207         if (td) {
1208             memcpy(pbc->buf + data_pos + header_size,
1209                    td->data, td->data_size);
1210             skip_put_bytes(pbc, td->data_size);
1211         }
1212     }
1213
1214     // OBU data must be byte-aligned.
1215     av_assert0(put_bits_count(pbc) % 8 == 0);
1216
1217     return 0;
1218 }
1219
1220 static int cbs_av1_assemble_fragment(CodedBitstreamContext *ctx,
1221                                      CodedBitstreamFragment *frag)
1222 {
1223     size_t size, pos;
1224     int i;
1225
1226     size = 0;
1227     for (i = 0; i < frag->nb_units; i++)
1228         size += frag->units[i].data_size;
1229
1230     frag->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
1231     if (!frag->data_ref)
1232         return AVERROR(ENOMEM);
1233     frag->data = frag->data_ref->data;
1234     memset(frag->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1235
1236     pos = 0;
1237     for (i = 0; i < frag->nb_units; i++) {
1238         memcpy(frag->data + pos, frag->units[i].data,
1239                frag->units[i].data_size);
1240         pos += frag->units[i].data_size;
1241     }
1242     av_assert0(pos == size);
1243     frag->data_size = size;
1244
1245     return 0;
1246 }
1247
1248 static void cbs_av1_close(CodedBitstreamContext *ctx)
1249 {
1250     CodedBitstreamAV1Context *priv = ctx->priv_data;
1251
1252     av_buffer_unref(&priv->sequence_header_ref);
1253     av_buffer_unref(&priv->frame_header_ref);
1254 }
1255
1256 const CodedBitstreamType ff_cbs_type_av1 = {
1257     .codec_id          = AV_CODEC_ID_AV1,
1258
1259     .priv_data_size    = sizeof(CodedBitstreamAV1Context),
1260
1261     .split_fragment    = &cbs_av1_split_fragment,
1262     .read_unit         = &cbs_av1_read_unit,
1263     .write_unit        = &cbs_av1_write_obu,
1264     .assemble_fragment = &cbs_av1_assemble_fragment,
1265
1266     .close             = &cbs_av1_close,
1267 };