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