FFmpeg  4.3.7
cbs.c
Go to the documentation of this file.
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 
32 #if CONFIG_CBS_AV1
34 #endif
35 #if CONFIG_CBS_H264
37 #endif
38 #if CONFIG_CBS_H265
40 #endif
41 #if CONFIG_CBS_JPEG
43 #endif
44 #if CONFIG_CBS_MPEG2
46 #endif
47 #if CONFIG_CBS_VP9
49 #endif
50 };
51 
53 #if CONFIG_CBS_AV1
55 #endif
56 #if CONFIG_CBS_H264
58 #endif
59 #if CONFIG_CBS_H265
61 #endif
62 #if CONFIG_CBS_JPEG
64 #endif
65 #if CONFIG_CBS_MPEG2
67 #endif
68 #if CONFIG_CBS_VP9
70 #endif
72 };
73 
75  enum AVCodecID codec_id, void *log_ctx)
76 {
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  if (type->priv_data_size) {
100  if (!ctx->priv_data) {
101  av_freep(&ctx);
102  return AVERROR(ENOMEM);
103  }
104  }
105 
106  ctx->decompose_unit_types = NULL;
107 
108  ctx->trace_enable = 0;
109  ctx->trace_level = AV_LOG_TRACE;
110 
111  *ctx_ptr = ctx;
112  return 0;
113 }
114 
116 {
117  CodedBitstreamContext *ctx = *ctx_ptr;
118 
119  if (!ctx)
120  return;
121 
122  if (ctx->codec && ctx->codec->close)
123  ctx->codec->close(ctx);
124 
125  av_freep(&ctx->write_buffer);
126  av_freep(&ctx->priv_data);
127  av_freep(ctx_ptr);
128 }
129 
131  CodedBitstreamUnit *unit)
132 {
134  unit->content = NULL;
135 
136  av_buffer_unref(&unit->data_ref);
137  unit->data = NULL;
138  unit->data_size = 0;
139  unit->data_bit_padding = 0;
140 }
141 
144 {
145  int i;
146 
147  for (i = 0; i < frag->nb_units; i++)
148  cbs_unit_uninit(ctx, &frag->units[i]);
149  frag->nb_units = 0;
150 
151  av_buffer_unref(&frag->data_ref);
152  frag->data = NULL;
153  frag->data_size = 0;
154  frag->data_bit_padding = 0;
155 }
156 
159 {
160  ff_cbs_fragment_reset(ctx, frag);
161 
162  av_freep(&frag->units);
163  frag->nb_units_allocated = 0;
164 }
165 
168 {
169  int err, i, j;
170 
171  for (i = 0; i < frag->nb_units; i++) {
172  CodedBitstreamUnit *unit = &frag->units[i];
173 
174  if (ctx->decompose_unit_types) {
175  for (j = 0; j < ctx->nb_decompose_unit_types; j++) {
176  if (ctx->decompose_unit_types[j] == unit->type)
177  break;
178  }
179  if (j >= ctx->nb_decompose_unit_types)
180  continue;
181  }
182 
184  unit->content = NULL;
185 
186  av_assert0(unit->data && unit->data_ref);
187 
188  err = ctx->codec->read_unit(ctx, unit);
189  if (err == AVERROR(ENOSYS)) {
191  "Decomposition unimplemented for unit %d "
192  "(type %"PRIu32").\n", i, unit->type);
193  } else if (err < 0) {
194  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to read unit %d "
195  "(type %"PRIu32").\n", i, unit->type);
196  return err;
197  }
198  }
199 
200  return 0;
201 }
202 
205  const uint8_t *data, size_t size)
206 {
207  av_assert0(!frag->data && !frag->data_ref);
208 
209  frag->data_ref =
211  if (!frag->data_ref)
212  return AVERROR(ENOMEM);
213 
214  frag->data = frag->data_ref->data;
215  frag->data_size = size;
216 
217  memcpy(frag->data, data, size);
218  memset(frag->data + size, 0,
220 
221  return 0;
222 }
223 
226  const AVCodecParameters *par)
227 {
228  int err;
229 
230  err = cbs_fill_fragment_data(ctx, frag, par->extradata,
231  par->extradata_size);
232  if (err < 0)
233  return err;
234 
235  err = ctx->codec->split_fragment(ctx, frag, 1);
236  if (err < 0)
237  return err;
238 
239  return cbs_read_fragment_content(ctx, frag);
240 }
241 
244  const AVPacket *pkt)
245 {
246  int err;
247 
248  if (pkt->buf) {
249  frag->data_ref = av_buffer_ref(pkt->buf);
250  if (!frag->data_ref)
251  return AVERROR(ENOMEM);
252 
253  frag->data = pkt->data;
254  frag->data_size = pkt->size;
255 
256  } else {
257  err = cbs_fill_fragment_data(ctx, frag, pkt->data, pkt->size);
258  if (err < 0)
259  return err;
260  }
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 
271  const uint8_t *data, size_t size)
272 {
273  int err;
274 
275  err = cbs_fill_fragment_data(ctx, frag, data, size);
276  if (err < 0)
277  return err;
278 
279  err = ctx->codec->split_fragment(ctx, frag, 0);
280  if (err < 0)
281  return err;
282 
283  return cbs_read_fragment_content(ctx, frag);
284 }
285 
287  CodedBitstreamUnit *unit)
288 {
289  PutBitContext pbc;
290  int ret;
291 
292  if (!ctx->write_buffer) {
293  // Initial write buffer size is 1MB.
294  ctx->write_buffer_size = 1024 * 1024;
295 
296  reallocate_and_try_again:
297  ret = av_reallocp(&ctx->write_buffer, ctx->write_buffer_size);
298  if (ret < 0) {
299  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
300  "sufficiently large write buffer (last attempt "
301  "%"SIZE_SPECIFIER" bytes).\n", ctx->write_buffer_size);
302  return ret;
303  }
304  }
305 
306  init_put_bits(&pbc, ctx->write_buffer, ctx->write_buffer_size);
307 
308  ret = ctx->codec->write_unit(ctx, unit, &pbc);
309  if (ret < 0) {
310  if (ret == AVERROR(ENOSPC)) {
311  // Overflow.
312  if (ctx->write_buffer_size == INT_MAX / 8)
313  return AVERROR(ENOMEM);
314  ctx->write_buffer_size = FFMIN(2 * ctx->write_buffer_size, INT_MAX / 8);
315  goto reallocate_and_try_again;
316  }
317  // Write failed for some other reason.
318  return ret;
319  }
320 
321  // Overflow but we didn't notice.
322  av_assert0(put_bits_count(&pbc) <= 8 * ctx->write_buffer_size);
323 
324  if (put_bits_count(&pbc) % 8)
325  unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
326  else
327  unit->data_bit_padding = 0;
328 
329  flush_put_bits(&pbc);
330 
331  ret = ff_cbs_alloc_unit_data(ctx, unit, put_bits_count(&pbc) / 8);
332  if (ret < 0)
333  return ret;
334 
335  memcpy(unit->data, ctx->write_buffer, unit->data_size);
336 
337  return 0;
338 }
339 
342 {
343  int err, i;
344 
345  for (i = 0; i < frag->nb_units; i++) {
346  CodedBitstreamUnit *unit = &frag->units[i];
347 
348  if (!unit->content)
349  continue;
350 
351  av_buffer_unref(&unit->data_ref);
352  unit->data = NULL;
353 
354  err = cbs_write_unit_data(ctx, unit);
355  if (err < 0) {
356  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write unit %d "
357  "(type %"PRIu32").\n", i, unit->type);
358  return err;
359  }
360  av_assert0(unit->data && unit->data_ref);
361  }
362 
363  av_buffer_unref(&frag->data_ref);
364  frag->data = NULL;
365 
366  err = ctx->codec->assemble_fragment(ctx, frag);
367  if (err < 0) {
368  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to assemble fragment.\n");
369  return err;
370  }
371  av_assert0(frag->data && frag->data_ref);
372 
373  return 0;
374 }
375 
377  AVCodecParameters *par,
379 {
380  int err;
381 
382  err = ff_cbs_write_fragment_data(ctx, frag);
383  if (err < 0)
384  return err;
385 
386  av_freep(&par->extradata);
387 
388  par->extradata = av_malloc(frag->data_size +
390  if (!par->extradata)
391  return AVERROR(ENOMEM);
392 
393  memcpy(par->extradata, frag->data, frag->data_size);
394  memset(par->extradata + frag->data_size, 0,
396  par->extradata_size = frag->data_size;
397 
398  return 0;
399 }
400 
402  AVPacket *pkt,
404 {
405  AVBufferRef *buf;
406  int err;
407 
408  err = ff_cbs_write_fragment_data(ctx, frag);
409  if (err < 0)
410  return err;
411 
412  buf = av_buffer_ref(frag->data_ref);
413  if (!buf)
414  return AVERROR(ENOMEM);
415 
416  av_buffer_unref(&pkt->buf);
417 
418  pkt->buf = buf;
419  pkt->data = frag->data;
420  pkt->size = frag->data_size;
421 
422  return 0;
423 }
424 
425 
427  const char *name)
428 {
429  if (!ctx->trace_enable)
430  return;
431 
432  av_log(ctx->log_ctx, ctx->trace_level, "%s\n", name);
433 }
434 
436  const char *str, const int *subscripts,
437  const char *bits, int64_t value)
438 {
439  char name[256];
440  size_t name_len, bits_len;
441  int pad, subs, i, j, k, n;
442 
443  if (!ctx->trace_enable)
444  return;
445 
446  av_assert0(value >= INT_MIN && value <= UINT32_MAX);
447 
448  subs = subscripts ? subscripts[0] : 0;
449  n = 0;
450  for (i = j = 0; str[i];) {
451  if (str[i] == '[') {
452  if (n < subs) {
453  ++n;
454  k = snprintf(name + j, sizeof(name) - j, "[%d", subscripts[n]);
455  av_assert0(k > 0 && j + k < sizeof(name));
456  j += k;
457  for (++i; str[i] && str[i] != ']'; i++);
458  av_assert0(str[i] == ']');
459  } else {
460  while (str[i] && str[i] != ']')
461  name[j++] = str[i++];
462  av_assert0(str[i] == ']');
463  }
464  } else {
465  av_assert0(j + 1 < sizeof(name));
466  name[j++] = str[i++];
467  }
468  }
469  av_assert0(j + 1 < sizeof(name));
470  name[j] = 0;
471  av_assert0(n == subs);
472 
473  name_len = strlen(name);
474  bits_len = strlen(bits);
475 
476  if (name_len + bits_len > 60)
477  pad = bits_len + 2;
478  else
479  pad = 61 - name_len;
480 
481  av_log(ctx->log_ctx, ctx->trace_level, "%-10d %s%*s = %"PRId64"\n",
482  position, name, pad, bits, value);
483 }
484 
486  int width, const char *name,
487  const int *subscripts, uint32_t *write_to,
488  uint32_t range_min, uint32_t range_max)
489 {
490  uint32_t value;
491  int position;
492 
493  av_assert0(width > 0 && width <= 32);
494 
495  if (get_bits_left(gbc) < width) {
496  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
497  "%s: bitstream ended.\n", name);
498  return AVERROR_INVALIDDATA;
499  }
500 
501  if (ctx->trace_enable)
502  position = get_bits_count(gbc);
503 
504  value = get_bits_long(gbc, width);
505 
506  if (ctx->trace_enable) {
507  char bits[33];
508  int i;
509  for (i = 0; i < width; i++)
510  bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
511  bits[i] = 0;
512 
513  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
514  bits, value);
515  }
516 
517  if (value < range_min || value > range_max) {
518  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
519  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
520  name, value, range_min, range_max);
521  return AVERROR_INVALIDDATA;
522  }
523 
524  *write_to = value;
525  return 0;
526 }
527 
529  int width, const char *name,
530  const int *subscripts, uint32_t value,
531  uint32_t range_min, uint32_t range_max)
532 {
533  av_assert0(width > 0 && width <= 32);
534 
535  if (value < range_min || value > range_max) {
536  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
537  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
538  name, value, range_min, range_max);
539  return AVERROR_INVALIDDATA;
540  }
541 
542  if (put_bits_left(pbc) < width)
543  return AVERROR(ENOSPC);
544 
545  if (ctx->trace_enable) {
546  char bits[33];
547  int i;
548  for (i = 0; i < width; i++)
549  bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
550  bits[i] = 0;
551 
553  name, subscripts, bits, value);
554  }
555 
556  if (width < 32)
557  put_bits(pbc, width, value);
558  else
559  put_bits32(pbc, value);
560 
561  return 0;
562 }
563 
565  int width, const char *name,
566  const int *subscripts, int32_t *write_to,
567  int32_t range_min, int32_t range_max)
568 {
569  int32_t value;
570  int position;
571 
572  av_assert0(width > 0 && width <= 32);
573 
574  if (get_bits_left(gbc) < width) {
575  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
576  "%s: bitstream ended.\n", name);
577  return AVERROR_INVALIDDATA;
578  }
579 
580  if (ctx->trace_enable)
581  position = get_bits_count(gbc);
582 
583  value = get_sbits_long(gbc, width);
584 
585  if (ctx->trace_enable) {
586  char bits[33];
587  int i;
588  for (i = 0; i < width; i++)
589  bits[i] = value & (1U << (width - i - 1)) ? '1' : '0';
590  bits[i] = 0;
591 
592  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
593  bits, value);
594  }
595 
596  if (value < range_min || value > range_max) {
597  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
598  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
599  name, value, range_min, range_max);
600  return AVERROR_INVALIDDATA;
601  }
602 
603  *write_to = value;
604  return 0;
605 }
606 
608  int width, const char *name,
609  const int *subscripts, int32_t value,
610  int32_t range_min, int32_t range_max)
611 {
612  av_assert0(width > 0 && width <= 32);
613 
614  if (value < range_min || value > range_max) {
615  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
616  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
617  name, value, range_min, range_max);
618  return AVERROR_INVALIDDATA;
619  }
620 
621  if (put_bits_left(pbc) < width)
622  return AVERROR(ENOSPC);
623 
624  if (ctx->trace_enable) {
625  char bits[33];
626  int i;
627  for (i = 0; i < width; i++)
628  bits[i] = value & (1U << (width - i - 1)) ? '1' : '0';
629  bits[i] = 0;
630 
632  name, subscripts, bits, value);
633  }
634 
635  if (width < 32)
636  put_sbits(pbc, width, value);
637  else
638  put_bits32(pbc, value);
639 
640  return 0;
641 }
642 
643 
645  CodedBitstreamUnit *unit,
646  size_t size,
647  void (*free)(void *opaque, uint8_t *data))
648 {
649  av_assert0(!unit->content && !unit->content_ref);
650 
651  unit->content = av_mallocz(size);
652  if (!unit->content)
653  return AVERROR(ENOMEM);
654 
655  unit->content_ref = av_buffer_create(unit->content, size,
656  free, NULL, 0);
657  if (!unit->content_ref) {
658  av_freep(&unit->content);
659  return AVERROR(ENOMEM);
660  }
661 
662  return 0;
663 }
664 
666  CodedBitstreamUnit *unit,
667  size_t size)
668 {
669  av_assert0(!unit->data && !unit->data_ref);
670 
672  if (!unit->data_ref)
673  return AVERROR(ENOMEM);
674 
675  unit->data = unit->data_ref->data;
676  unit->data_size = size;
677 
678  memset(unit->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
679 
680  return 0;
681 }
682 
685  int position)
686 {
687  CodedBitstreamUnit *units;
688 
689  if (frag->nb_units < frag->nb_units_allocated) {
690  units = frag->units;
691 
692  if (position < frag->nb_units)
693  memmove(units + position + 1, units + position,
694  (frag->nb_units - position) * sizeof(*units));
695  } else {
696  units = av_malloc_array(frag->nb_units*2 + 1, sizeof(*units));
697  if (!units)
698  return AVERROR(ENOMEM);
699 
700  frag->nb_units_allocated = 2*frag->nb_units_allocated + 1;
701 
702  if (position > 0)
703  memcpy(units, frag->units, position * sizeof(*units));
704 
705  if (position < frag->nb_units)
706  memcpy(units + position + 1, frag->units + position,
707  (frag->nb_units - position) * sizeof(*units));
708  }
709 
710  memset(units + position, 0, sizeof(*units));
711 
712  if (units != frag->units) {
713  av_free(frag->units);
714  frag->units = units;
715  }
716 
717  ++frag->nb_units;
718 
719  return 0;
720 }
721 
724  int position,
726  void *content,
727  AVBufferRef *content_buf)
728 {
729  CodedBitstreamUnit *unit;
730  AVBufferRef *content_ref;
731  int err;
732 
733  if (position == -1)
734  position = frag->nb_units;
735  av_assert0(position >= 0 && position <= frag->nb_units);
736 
737  if (content_buf) {
738  content_ref = av_buffer_ref(content_buf);
739  if (!content_ref)
740  return AVERROR(ENOMEM);
741  } else {
742  content_ref = NULL;
743  }
744 
745  err = cbs_insert_unit(ctx, frag, position);
746  if (err < 0) {
747  av_buffer_unref(&content_ref);
748  return err;
749  }
750 
751  unit = &frag->units[position];
752  unit->type = type;
753  unit->content = content;
754  unit->content_ref = content_ref;
755 
756  return 0;
757 }
758 
761  int position,
763  uint8_t *data, size_t data_size,
764  AVBufferRef *data_buf)
765 {
766  CodedBitstreamUnit *unit;
767  AVBufferRef *data_ref;
768  int err;
769 
770  if (position == -1)
771  position = frag->nb_units;
772  av_assert0(position >= 0 && position <= frag->nb_units);
773 
774  if (data_buf)
775  data_ref = av_buffer_ref(data_buf);
776  else
777  data_ref = av_buffer_create(data, data_size, NULL, NULL, 0);
778  if (!data_ref) {
779  if (!data_buf)
780  av_free(data);
781  return AVERROR(ENOMEM);
782  }
783 
784  err = cbs_insert_unit(ctx, frag, position);
785  if (err < 0) {
786  av_buffer_unref(&data_ref);
787  return err;
788  }
789 
790  unit = &frag->units[position];
791  unit->type = type;
792  unit->data = data;
793  unit->data_size = data_size;
794  unit->data_ref = data_ref;
795 
796  return 0;
797 }
798 
801  int position)
802 {
803  av_assert0(0 <= position && position < frag->nb_units
804  && "Unit to be deleted not in fragment.");
805 
806  cbs_unit_uninit(ctx, &frag->units[position]);
807 
808  --frag->nb_units;
809 
810  if (frag->nb_units > 0)
811  memmove(frag->units + position,
812  frag->units + position + 1,
813  (frag->nb_units - position) * sizeof(*frag->units));
814 }
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:250
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
int size
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:401
static void cbs_unit_uninit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:130
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
void ff_cbs_delete_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:799
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int size
Definition: packet.h:356
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:644
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:722
void ff_cbs_trace_header(CodedBitstreamContext *ctx, const char *name)
Definition: cbs.c:426
static AVPacket pkt
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:590
int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, const int *subscripts, uint32_t value, uint32_t range_min, uint32_t range_max)
Definition: cbs.c:528
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int trace_enable
Enable trace output during read/write operations.
Definition: cbs.h:206
int(* assemble_fragment)(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_internal.h:55
uint8_t
#define av_malloc(s)
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:43
int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, uint32_t *write_to, uint32_t range_min, uint32_t range_max)
Definition: cbs.c:485
uint8_t * write_buffer
Write buffer.
Definition: cbs.h:218
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:86
static const CodedBitstreamType * cbs_type_table[]
Definition: cbs.c:31
const char data[16]
Definition: mxf.c:91
static int cbs_read_fragment_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs.c:166
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:242
uint8_t * data
Definition: packet.h:355
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
int ff_cbs_write_signed(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, const int *subscripts, int32_t value, int32_t range_min, int32_t range_max)
Definition: cbs.c:607
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int ff_cbs_alloc_unit_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size)
Allocate a new internal data buffer of the given size in the unit.
Definition: cbs.c:665
Coded bitstream unit structure.
Definition: cbs.h:64
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:162
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:75
int ff_cbs_read_signed(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, int32_t *write_to, int32_t range_min, int32_t range_max)
Definition: cbs.c:564
int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Insert a new unit into a fragment with the given data bitstream.
Definition: cbs.c:759
#define av_log(a,...)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:157
int(* write_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_internal.h:49
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void(* close)(CodedBitstreamContext *ctx)
Definition: cbs_internal.h:59
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
#define AVERROR(e)
Definition: error.h:43
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:338
simple assert() macros that are a bit more flexible than ISO C assert().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
uint8_t bits
Definition: vp3data.h:202
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:133
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
const CodedBitstreamType ff_cbs_type_mpeg2
Definition: cbs_mpeg2.c:423
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:173
const CodedBitstreamType ff_cbs_type_h264
Definition: cbs_h2645.c:1508
const CodedBitstreamType ff_cbs_type_av1
Definition: cbs_av1.c:1265
const char * name
Definition: qsvenc.c:46
#define FFMIN(a, b)
Definition: common.h:96
static int cbs_write_unit_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:286
int ff_cbs_write_extradata(CodedBitstreamContext *ctx, AVCodecParameters *par, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to the extradata in codec parameters.
Definition: cbs.c:376
#define width
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
#define AV_CODEC_ID_H265
Definition: codec_id.h:224
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define FF_ARRAY_ELEMS(a)
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:340
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:161
int nb_decompose_unit_types
Length of the decompose_unit_types array.
Definition: cbs.h:201
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
const CodedBitstreamType ff_cbs_type_jpeg
Definition: cbs_jpeg.c:461
uint8_t * data
The data buffer.
Definition: buffer.h:89
int trace_level
Log level to use for trace output.
Definition: cbs.h:212
static int cbs_fill_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Definition: cbs.c:203
double value
Definition: eval.c:98
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:142
Context structure for coded bitstream operations.
Definition: cbs.h:168
AVBufferRef * content_ref
If content is reference counted, a reference to the buffer containing content.
Definition: cbs.h:106
cl_device_type type
refcounted data buffer API
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
#define snprintf
Definition: snprintf.h:34
int(* read_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_internal.h:44
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
int ff_cbs_read_extradata(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecParameters *par)
Read the extradata bitstream found in codec parameters into a fragment, then split into units and dec...
Definition: cbs.c:224
#define SIZE_SPECIFIER
Definition: internal.h:264
int nb_units_allocated
Number of allocated units.
Definition: cbs.h:154
void * priv_data
Internal codec-specific data.
Definition: cbs.h:189
A reference to a data buffer.
Definition: buffer.h:81
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
common internal and external API header
int(* split_fragment)(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_internal.h:38
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:92
static int cbs_insert_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Definition: cbs.c:683
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
CodedBitstreamUnitType * decompose_unit_types
Array of unit types which should be decomposed when reading.
Definition: cbs.h:197
const CodedBitstreamType ff_cbs_type_h265
Definition: cbs_h2645.c:1521
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
enum AVCodecID ff_cbs_all_codec_ids[]
Table of all supported codec IDs.
Definition: cbs.c:52
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define av_free(p)
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
size_t write_buffer_size
Definition: cbs.h:219
#define av_freep(p)
const struct CodedBitstreamType * codec
Internal codec-specific hooks.
Definition: cbs.h:178
#define av_malloc_array(a, b)
int ff_cbs_read(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Read a bitstream from a memory region into a fragment, then split into units and decompose.
Definition: cbs.c:269
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:139
const CodedBitstreamType ff_cbs_type_vp9
Definition: cbs_vp9.c:645
This structure stores compressed data.
Definition: packet.h:332
void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position, const char *str, const int *subscripts, const char *bits, int64_t value)
Definition: cbs.c:435
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:80