git.sesse.net Git - ffmpeg/blob - libavcodec/cbs.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 <string.h>
  20
  21 #include "config.h"
  22
  23 #include "libavutil/avassert.h"
  24 #include "libavutil/buffer.h"
  25 #include "libavutil/common.h"
  26
  27 #include "cbs.h"
  28 #include "cbs_internal.h"
  29
  30
  31 static const CodedBitstreamType *cbs_type_table[] = {
  32 #if CONFIG_CBS_AV1
  33     &ff_cbs_type_av1,
  34 #endif
  35 #if CONFIG_CBS_H264
  36     &ff_cbs_type_h264,
  37 #endif
  38 #if CONFIG_CBS_H265
  39     &ff_cbs_type_h265,
  40 #endif
  41 #if CONFIG_CBS_JPEG
  42     &ff_cbs_type_jpeg,
  43 #endif
  44 #if CONFIG_CBS_MPEG2
  45     &ff_cbs_type_mpeg2,
  46 #endif
  47 #if CONFIG_CBS_VP9
  48     &ff_cbs_type_vp9,
  49 #endif
  50 };
  51
  52 const enum AVCodecID ff_cbs_all_codec_ids[] = {
  53 #if CONFIG_CBS_AV1
  54     AV_CODEC_ID_AV1,
  55 #endif
  56 #if CONFIG_CBS_H264
  57     AV_CODEC_ID_H264,
  58 #endif
  59 #if CONFIG_CBS_H265
  60     AV_CODEC_ID_H265,
  61 #endif
  62 #if CONFIG_CBS_JPEG
  63     AV_CODEC_ID_MJPEG,
  64 #endif
  65 #if CONFIG_CBS_MPEG2
  66     AV_CODEC_ID_MPEG2VIDEO,
  67 #endif
  68 #if CONFIG_CBS_VP9
  69     AV_CODEC_ID_VP9,
  70 #endif
  71     AV_CODEC_ID_NONE
  72 };
  73
  74 int ff_cbs_init(CodedBitstreamContext **ctx_ptr,
  75                 enum AVCodecID codec_id, void *log_ctx)
  76 {
  77     CodedBitstreamContext *ctx;
  78     const CodedBitstreamType *type;
  79     int i;
  80
  81     type = NULL;
  82     for (i = 0; i < FF_ARRAY_ELEMS(cbs_type_table); i++) {
  83         if (cbs_type_table[i]->codec_id == codec_id) {
  84             type = cbs_type_table[i];
  85             break;
  86         }
  87     }
  88     if (!type)
  89         return AVERROR(EINVAL);
  90
  91     ctx = av_mallocz(sizeof(*ctx));
  92     if (!ctx)
  93         return AVERROR(ENOMEM);
  94
  95     ctx->log_ctx = log_ctx;
  96     ctx->codec   = type;
  97
  98     ctx->priv_data = av_mallocz(ctx->codec->priv_data_size);
  99     if (!ctx->priv_data) {
 100         av_freep(&ctx);
 101         return AVERROR(ENOMEM);
 102     }
 103
 104     ctx->decompose_unit_types = NULL;
 105
 106     ctx->trace_enable = 0;
 107     ctx->trace_level  = AV_LOG_TRACE;
 108
 109     *ctx_ptr = ctx;
 110     return 0;
 111 }
 112
 113 void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
 114 {
 115     CodedBitstreamContext *ctx = *ctx_ptr;
 116
 117     if (!ctx)
 118         return;
 119
 120     if (ctx->codec && ctx->codec->close)
 121         ctx->codec->close(ctx);
 122
 123     av_freep(&ctx->priv_data);
 124     av_freep(ctx_ptr);
 125 }
 126
 127 static void cbs_unit_uninit(CodedBitstreamContext *ctx,
 128                             CodedBitstreamUnit *unit)
 129 {
 130     av_buffer_unref(&unit->content_ref);
 131     unit->content = NULL;
 132
 133     av_buffer_unref(&unit->data_ref);
 134     unit->data             = NULL;
 135     unit->data_size        = 0;
 136     unit->data_bit_padding = 0;
 137 }
 138
 139 void ff_cbs_fragment_reset(CodedBitstreamContext *ctx,
 140                            CodedBitstreamFragment *frag)
 141 {
 142     int i;
 143
 144     for (i = 0; i < frag->nb_units; i++)
 145         cbs_unit_uninit(ctx, &frag->units[i]);
 146     frag->nb_units = 0;
 147
 148     av_buffer_unref(&frag->data_ref);
 149     frag->data             = NULL;
 150     frag->data_size        = 0;
 151     frag->data_bit_padding = 0;
 152 }
 153
 154 void ff_cbs_fragment_free(CodedBitstreamContext *ctx,
 155                           CodedBitstreamFragment *frag)
 156 {
 157     ff_cbs_fragment_reset(ctx, frag);
 158
 159     av_freep(&frag->units);
 160     frag->nb_units_allocated = 0;
 161 }
 162
 163 static int cbs_read_fragment_content(CodedBitstreamContext *ctx,
 164                                      CodedBitstreamFragment *frag)
 165 {
 166     int err, i, j;
 167
 168     for (i = 0; i < frag->nb_units; i++) {
 169         CodedBitstreamUnit *unit = &frag->units[i];
 170
 171         if (ctx->decompose_unit_types) {
 172             for (j = 0; j < ctx->nb_decompose_unit_types; j++) {
 173                 if (ctx->decompose_unit_types[j] == unit->type)
 174                     break;
 175             }
 176             if (j >= ctx->nb_decompose_unit_types)
 177                 continue;
 178         }
 179
 180         av_buffer_unref(&unit->content_ref);
 181         unit->content = NULL;
 182
 183         av_assert0(unit->data && unit->data_ref);
 184
 185         err = ctx->codec->read_unit(ctx, unit);
 186         if (err == AVERROR(ENOSYS)) {
 187             av_log(ctx->log_ctx, AV_LOG_VERBOSE,
 188                    "Decomposition unimplemented for unit %d "
 189                    "(type %"PRIu32").\n", i, unit->type);
 190         } else if (err < 0) {
 191             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to read unit %d "
 192                    "(type %"PRIu32").\n", i, unit->type);
 193             return err;
 194         }
 195     }
 196
 197     return 0;
 198 }
 199
 200 static int cbs_fill_fragment_data(CodedBitstreamContext *ctx,
 201                                   CodedBitstreamFragment *frag,
 202                                   const uint8_t *data, size_t size)
 203 {
 204     av_assert0(!frag->data && !frag->data_ref);
 205
 206     frag->data_ref =
 207         av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
 208     if (!frag->data_ref)
 209         return AVERROR(ENOMEM);
 210
 211     frag->data      = frag->data_ref->data;
 212     frag->data_size = size;
 213
 214     memcpy(frag->data, data, size);
 215     memset(frag->data + size, 0,
 216            AV_INPUT_BUFFER_PADDING_SIZE);
 217
 218     return 0;
 219 }
 220
 221 int ff_cbs_read_extradata(CodedBitstreamContext *ctx,
 222                           CodedBitstreamFragment *frag,
 223                           const AVCodecParameters *par)
 224 {
 225     int err;
 226
 227     err = cbs_fill_fragment_data(ctx, frag, par->extradata,
 228                                  par->extradata_size);
 229     if (err < 0)
 230         return err;
 231
 232     err = ctx->codec->split_fragment(ctx, frag, 1);
 233     if (err < 0)
 234         return err;
 235
 236     return cbs_read_fragment_content(ctx, frag);
 237 }
 238
 239 int ff_cbs_read_packet(CodedBitstreamContext *ctx,
 240                        CodedBitstreamFragment *frag,
 241                        const AVPacket *pkt)
 242 {
 243     int err;
 244
 245     if (pkt->buf) {
 246         frag->data_ref = av_buffer_ref(pkt->buf);
 247         if (!frag->data_ref)
 248             return AVERROR(ENOMEM);
 249
 250         frag->data      = pkt->data;
 251         frag->data_size = pkt->size;
 252
 253     } else {
 254         err = cbs_fill_fragment_data(ctx, frag, pkt->data, pkt->size);
 255         if (err < 0)
 256             return err;
 257     }
 258
 259     err = ctx->codec->split_fragment(ctx, frag, 0);
 260     if (err < 0)
 261         return err;
 262
 263     return cbs_read_fragment_content(ctx, frag);
 264 }
 265
 266 int ff_cbs_read(CodedBitstreamContext *ctx,
 267                 CodedBitstreamFragment *frag,
 268                 const uint8_t *data, size_t size)
 269 {
 270     int err;
 271
 272     err = cbs_fill_fragment_data(ctx, frag, data, size);
 273     if (err < 0)
 274         return err;
 275
 276     err = ctx->codec->split_fragment(ctx, frag, 0);
 277     if (err < 0)
 278         return err;
 279
 280     return cbs_read_fragment_content(ctx, frag);
 281 }
 282
 283
 284 int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx,
 285                                CodedBitstreamFragment *frag)
 286 {
 287     int err, i;
 288
 289     for (i = 0; i < frag->nb_units; i++) {
 290         CodedBitstreamUnit *unit = &frag->units[i];
 291
 292         if (!unit->content)
 293             continue;
 294
 295         av_buffer_unref(&unit->data_ref);
 296         unit->data = NULL;
 297
 298         err = ctx->codec->write_unit(ctx, unit);
 299         if (err < 0) {
 300             av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write unit %d "
 301                    "(type %"PRIu32").\n", i, unit->type);
 302             return err;
 303         }
 304         av_assert0(unit->data && unit->data_ref);
 305     }
 306
 307     av_buffer_unref(&frag->data_ref);
 308     frag->data = NULL;
 309
 310     err = ctx->codec->assemble_fragment(ctx, frag);
 311     if (err < 0) {
 312         av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to assemble fragment.\n");
 313         return err;
 314     }
 315     av_assert0(frag->data && frag->data_ref);
 316
 317     return 0;
 318 }
 319
 320 int ff_cbs_write_extradata(CodedBitstreamContext *ctx,
 321                            AVCodecParameters *par,
 322                            CodedBitstreamFragment *frag)
 323 {
 324     int err;
 325
 326     err = ff_cbs_write_fragment_data(ctx, frag);
 327     if (err < 0)
 328         return err;
 329
 330     av_freep(&par->extradata);
 331
 332     par->extradata = av_malloc(frag->data_size +
 333                                AV_INPUT_BUFFER_PADDING_SIZE);
 334     if (!par->extradata)
 335         return AVERROR(ENOMEM);
 336
 337     memcpy(par->extradata, frag->data, frag->data_size);
 338     memset(par->extradata + frag->data_size, 0,
 339            AV_INPUT_BUFFER_PADDING_SIZE);
 340     par->extradata_size = frag->data_size;
 341
 342     return 0;
 343 }
 344
 345 int ff_cbs_write_packet(CodedBitstreamContext *ctx,
 346                         AVPacket *pkt,
 347                         CodedBitstreamFragment *frag)
 348 {
 349     AVBufferRef *buf;
 350     int err;
 351
 352     err = ff_cbs_write_fragment_data(ctx, frag);
 353     if (err < 0)
 354         return err;
 355
 356     buf = av_buffer_ref(frag->data_ref);
 357     if (!buf)
 358         return AVERROR(ENOMEM);
 359
 360     av_buffer_unref(&pkt->buf);
 361
 362     pkt->buf  = buf;
 363     pkt->data = frag->data;
 364     pkt->size = frag->data_size;
 365
 366     return 0;
 367 }
 368
 369
 370 void ff_cbs_trace_header(CodedBitstreamContext *ctx,
 371                          const char *name)
 372 {
 373     if (!ctx->trace_enable)
 374         return;
 375
 376     av_log(ctx->log_ctx, ctx->trace_level, "%s\n", name);
 377 }
 378
 379 void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position,
 380                                  const char *str, const int *subscripts,
 381                                  const char *bits, int64_t value)
 382 {
 383     char name[256];
 384     size_t name_len, bits_len;
 385     int pad, subs, i, j, k, n;
 386
 387     if (!ctx->trace_enable)
 388         return;
 389
 390     av_assert0(value >= INT_MIN && value <= UINT32_MAX);
 391
 392     subs = subscripts ? subscripts[0] : 0;
 393     n = 0;
 394     for (i = j = 0; str[i];) {
 395         if (str[i] == '[') {
 396             if (n < subs) {
 397                 ++n;
 398                 k = snprintf(name + j, sizeof(name) - j, "[%d", subscripts[n]);
 399                 av_assert0(k > 0 && j + k < sizeof(name));
 400                 j += k;
 401                 for (++i; str[i] && str[i] != ']'; i++);
 402                 av_assert0(str[i] == ']');
 403             } else {
 404                 while (str[i] && str[i] != ']')
 405                     name[j++] = str[i++];
 406                 av_assert0(str[i] == ']');
 407             }
 408         } else {
 409             av_assert0(j + 1 < sizeof(name));
 410             name[j++] = str[i++];
 411         }
 412     }
 413     av_assert0(j + 1 < sizeof(name));
 414     name[j] = 0;
 415     av_assert0(n == subs);
 416
 417     name_len = strlen(name);
 418     bits_len = strlen(bits);
 419
 420     if (name_len + bits_len > 60)
 421         pad = bits_len + 2;
 422     else
 423         pad = 61 - name_len;
 424
 425     av_log(ctx->log_ctx, ctx->trace_level, "%-10d  %s%*s = %"PRId64"\n",
 426            position, name, pad, bits, value);
 427 }
 428
 429 int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc,
 430                          int width, const char *name,
 431                          const int *subscripts, uint32_t *write_to,
 432                          uint32_t range_min, uint32_t range_max)
 433 {
 434     uint32_t value;
 435     int position;
 436
 437     av_assert0(width > 0 && width <= 32);
 438
 439     if (get_bits_left(gbc) < width) {
 440         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
 441                "%s: bitstream ended.\n", name);
 442         return AVERROR_INVALIDDATA;
 443     }
 444
 445     if (ctx->trace_enable)
 446         position = get_bits_count(gbc);
 447
 448     value = get_bits_long(gbc, width);
 449
 450     if (ctx->trace_enable) {
 451         char bits[33];
 452         int i;
 453         for (i = 0; i < width; i++)
 454             bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
 455         bits[i] = 0;
 456
 457         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
 458                                     bits, value);
 459     }
 460
 461     if (value < range_min || value > range_max) {
 462         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 463                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
 464                name, value, range_min, range_max);
 465         return AVERROR_INVALIDDATA;
 466     }
 467
 468     *write_to = value;
 469     return 0;
 470 }
 471
 472 int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc,
 473                           int width, const char *name,
 474                           const int *subscripts, uint32_t value,
 475                           uint32_t range_min, uint32_t range_max)
 476 {
 477     av_assert0(width > 0 && width <= 32);
 478
 479     if (value < range_min || value > range_max) {
 480         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 481                "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
 482                name, value, range_min, range_max);
 483         return AVERROR_INVALIDDATA;
 484     }
 485
 486     if (put_bits_left(pbc) < width)
 487         return AVERROR(ENOSPC);
 488
 489     if (ctx->trace_enable) {
 490         char bits[33];
 491         int i;
 492         for (i = 0; i < width; i++)
 493             bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
 494         bits[i] = 0;
 495
 496         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
 497                                     name, subscripts, bits, value);
 498     }
 499
 500     if (width < 32)
 501         put_bits(pbc, width, value);
 502     else
 503         put_bits32(pbc, value);
 504
 505     return 0;
 506 }
 507
 508 int ff_cbs_read_signed(CodedBitstreamContext *ctx, GetBitContext *gbc,
 509                        int width, const char *name,
 510                        const int *subscripts, int32_t *write_to,
 511                        int32_t range_min, int32_t range_max)
 512 {
 513     int32_t value;
 514     int position;
 515
 516     av_assert0(width > 0 && width <= 32);
 517
 518     if (get_bits_left(gbc) < width) {
 519         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
 520                "%s: bitstream ended.\n", name);
 521         return AVERROR_INVALIDDATA;
 522     }
 523
 524     if (ctx->trace_enable)
 525         position = get_bits_count(gbc);
 526
 527     value = get_sbits_long(gbc, width);
 528
 529     if (ctx->trace_enable) {
 530         char bits[33];
 531         int i;
 532         for (i = 0; i < width; i++)
 533             bits[i] = value & (1U << (width - i - 1)) ? '1' : '0';
 534         bits[i] = 0;
 535
 536         ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
 537                                     bits, value);
 538     }
 539
 540     if (value < range_min || value > range_max) {
 541         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 542                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
 543                name, value, range_min, range_max);
 544         return AVERROR_INVALIDDATA;
 545     }
 546
 547     *write_to = value;
 548     return 0;
 549 }
 550
 551 int ff_cbs_write_signed(CodedBitstreamContext *ctx, PutBitContext *pbc,
 552                         int width, const char *name,
 553                         const int *subscripts, int32_t value,
 554                         int32_t range_min, int32_t range_max)
 555 {
 556     av_assert0(width > 0 && width <= 32);
 557
 558     if (value < range_min || value > range_max) {
 559         av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
 560                "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
 561                name, value, range_min, range_max);
 562         return AVERROR_INVALIDDATA;
 563     }
 564
 565     if (put_bits_left(pbc) < width)
 566         return AVERROR(ENOSPC);
 567
 568     if (ctx->trace_enable) {
 569         char bits[33];
 570         int i;
 571         for (i = 0; i < width; i++)
 572             bits[i] = value & (1U << (width - i - 1)) ? '1' : '0';
 573         bits[i] = 0;
 574
 575         ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc),
 576                                     name, subscripts, bits, value);
 577     }
 578
 579     if (width < 32)
 580         put_sbits(pbc, width, value);
 581     else
 582         put_bits32(pbc, value);
 583
 584     return 0;
 585 }
 586
 587
 588 int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx,
 589                               CodedBitstreamUnit *unit,
 590                               size_t size,
 591                               void (*free)(void *opaque, uint8_t *data))
 592 {
 593     av_assert0(!unit->content && !unit->content_ref);
 594
 595     unit->content = av_mallocz(size);
 596     if (!unit->content)
 597         return AVERROR(ENOMEM);
 598
 599     unit->content_ref = av_buffer_create(unit->content, size,
 600                                          free, NULL, 0);
 601     if (!unit->content_ref) {
 602         av_freep(&unit->content);
 603         return AVERROR(ENOMEM);
 604     }
 605
 606     return 0;
 607 }
 608
 609 int ff_cbs_alloc_unit_data(CodedBitstreamContext *ctx,
 610                            CodedBitstreamUnit *unit,
 611                            size_t size)
 612 {
 613     av_assert0(!unit->data && !unit->data_ref);
 614
 615     unit->data_ref = av_buffer_alloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
 616     if (!unit->data_ref)
 617         return AVERROR(ENOMEM);
 618
 619     unit->data      = unit->data_ref->data;
 620     unit->data_size = size;
 621
 622     memset(unit->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 623
 624     return 0;
 625 }
 626
 627 static int cbs_insert_unit(CodedBitstreamContext *ctx,
 628                            CodedBitstreamFragment *frag,
 629                            int position)
 630 {
 631     CodedBitstreamUnit *units;
 632
 633     if (frag->nb_units < frag->nb_units_allocated) {
 634         units = frag->units;
 635
 636         if (position < frag->nb_units)
 637             memmove(units + position + 1, units + position,
 638                     (frag->nb_units - position) * sizeof(*units));
 639     } else {
 640         units = av_malloc_array(frag->nb_units + 1, sizeof(*units));
 641         if (!units)
 642             return AVERROR(ENOMEM);
 643
 644         ++frag->nb_units_allocated;
 645
 646         if (position > 0)
 647             memcpy(units, frag->units, position * sizeof(*units));
 648
 649         if (position < frag->nb_units)
 650             memcpy(units + position + 1, frag->units + position,
 651                    (frag->nb_units - position) * sizeof(*units));
 652     }
 653
 654     memset(units + position, 0, sizeof(*units));
 655
 656     if (units != frag->units) {
 657         av_free(frag->units);
 658         frag->units = units;
 659     }
 660
 661     ++frag->nb_units;
 662
 663     return 0;
 664 }
 665
 666 int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx,
 667                                CodedBitstreamFragment *frag,
 668                                int position,
 669                                CodedBitstreamUnitType type,
 670                                void *content,
 671                                AVBufferRef *content_buf)
 672 {
 673     CodedBitstreamUnit *unit;
 674     AVBufferRef *content_ref;
 675     int err;
 676
 677     if (position == -1)
 678         position = frag->nb_units;
 679     av_assert0(position >= 0 && position <= frag->nb_units);
 680
 681     if (content_buf) {
 682         content_ref = av_buffer_ref(content_buf);
 683         if (!content_ref)
 684             return AVERROR(ENOMEM);
 685     } else {
 686         content_ref = NULL;
 687     }
 688
 689     err = cbs_insert_unit(ctx, frag, position);
 690     if (err < 0) {
 691         av_buffer_unref(&content_ref);
 692         return err;
 693     }
 694
 695     unit = &frag->units[position];
 696     unit->type        = type;
 697     unit->content     = content;
 698     unit->content_ref = content_ref;
 699
 700     return 0;
 701 }
 702
 703 int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx,
 704                             CodedBitstreamFragment *frag,
 705                             int position,
 706                             CodedBitstreamUnitType type,
 707                             uint8_t *data, size_t data_size,
 708                             AVBufferRef *data_buf)
 709 {
 710     CodedBitstreamUnit *unit;
 711     AVBufferRef *data_ref;
 712     int err;
 713
 714     if (position == -1)
 715         position = frag->nb_units;
 716     av_assert0(position >= 0 && position <= frag->nb_units);
 717
 718     if (data_buf)
 719         data_ref = av_buffer_ref(data_buf);
 720     else
 721         data_ref = av_buffer_create(data, data_size, NULL, NULL, 0);
 722     if (!data_ref)
 723         return AVERROR(ENOMEM);
 724
 725     err = cbs_insert_unit(ctx, frag, position);
 726     if (err < 0) {
 727         av_buffer_unref(&data_ref);
 728         return err;
 729     }
 730
 731     unit = &frag->units[position];
 732     unit->type      = type;
 733     unit->data      = data;
 734     unit->data_size = data_size;
 735     unit->data_ref  = data_ref;
 736
 737     return 0;
 738 }
 739
 740 void ff_cbs_delete_unit(CodedBitstreamContext *ctx,
 741                         CodedBitstreamFragment *frag,
 742                         int position)
 743 {
 744     av_assert0(0 <= position && position < frag->nb_units
 745                              && "Unit to be deleted not in fragment.");
 746
 747     cbs_unit_uninit(ctx, &frag->units[position]);
 748
 749     --frag->nb_units;
 750
 751     if (frag->nb_units > 0)
 752         memmove(frag->units + position,
 753                 frag->units + position + 1,
 754                 (frag->nb_units - position) * sizeof(*frag->units));
 755 }