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