FFmpeg
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 
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 
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 
128  CodedBitstreamUnit *unit)
129 {
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 
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 
156 {
157  ff_cbs_fragment_reset(ctx, frag);
158 
159  av_freep(&frag->units);
160  frag->nb_units_allocated = 0;
161 }
162 
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 
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)) {
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 
202  const uint8_t *data, size_t size)
203 {
204  av_assert0(!frag->data && !frag->data_ref);
205 
206  frag->data_ref =
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,
217 
218  return 0;
219 }
220 
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 
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 
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 
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 
321  AVCodecParameters *par,
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 +
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,
340  par->extradata_size = frag->data_size;
341 
342  return 0;
343 }
344 
346  AVPacket *pkt,
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_init_packet(pkt);
361  pkt->buf = buf;
362  pkt->data = frag->data;
363  pkt->size = frag->data_size;
364 
365  return 0;
366 }
367 
368 
370  const char *name)
371 {
372  if (!ctx->trace_enable)
373  return;
374 
375  av_log(ctx->log_ctx, ctx->trace_level, "%s\n", name);
376 }
377 
379  const char *str, const int *subscripts,
380  const char *bits, int64_t value)
381 {
382  char name[256];
383  size_t name_len, bits_len;
384  int pad, subs, i, j, k, n;
385 
386  if (!ctx->trace_enable)
387  return;
388 
389  av_assert0(value >= INT_MIN && value <= UINT32_MAX);
390 
391  subs = subscripts ? subscripts[0] : 0;
392  n = 0;
393  for (i = j = 0; str[i];) {
394  if (str[i] == '[') {
395  if (n < subs) {
396  ++n;
397  k = snprintf(name + j, sizeof(name) - j, "[%d", subscripts[n]);
398  av_assert0(k > 0 && j + k < sizeof(name));
399  j += k;
400  for (++i; str[i] && str[i] != ']'; i++);
401  av_assert0(str[i] == ']');
402  } else {
403  while (str[i] && str[i] != ']')
404  name[j++] = str[i++];
405  av_assert0(str[i] == ']');
406  }
407  } else {
408  av_assert0(j + 1 < sizeof(name));
409  name[j++] = str[i++];
410  }
411  }
412  av_assert0(j + 1 < sizeof(name));
413  name[j] = 0;
414  av_assert0(n == subs);
415 
416  name_len = strlen(name);
417  bits_len = strlen(bits);
418 
419  if (name_len + bits_len > 60)
420  pad = bits_len + 2;
421  else
422  pad = 61 - name_len;
423 
424  av_log(ctx->log_ctx, ctx->trace_level, "%-10d %s%*s = %"PRId64"\n",
425  position, name, pad, bits, value);
426 }
427 
429  int width, const char *name,
430  const int *subscripts, uint32_t *write_to,
431  uint32_t range_min, uint32_t range_max)
432 {
433  uint32_t value;
434  int position;
435 
436  av_assert0(width > 0 && width <= 32);
437 
438  if (get_bits_left(gbc) < width) {
439  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
440  "%s: bitstream ended.\n", name);
441  return AVERROR_INVALIDDATA;
442  }
443 
444  if (ctx->trace_enable)
445  position = get_bits_count(gbc);
446 
447  value = get_bits_long(gbc, width);
448 
449  if (ctx->trace_enable) {
450  char bits[33];
451  int i;
452  for (i = 0; i < width; i++)
453  bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
454  bits[i] = 0;
455 
456  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
457  bits, value);
458  }
459 
460  if (value < range_min || value > range_max) {
461  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
462  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
463  name, value, range_min, range_max);
464  return AVERROR_INVALIDDATA;
465  }
466 
467  *write_to = value;
468  return 0;
469 }
470 
472  int width, const char *name,
473  const int *subscripts, uint32_t value,
474  uint32_t range_min, uint32_t range_max)
475 {
476  av_assert0(width > 0 && width <= 32);
477 
478  if (value < range_min || value > range_max) {
479  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
480  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
481  name, value, range_min, range_max);
482  return AVERROR_INVALIDDATA;
483  }
484 
485  if (put_bits_left(pbc) < width)
486  return AVERROR(ENOSPC);
487 
488  if (ctx->trace_enable) {
489  char bits[33];
490  int i;
491  for (i = 0; i < width; i++)
492  bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
493  bits[i] = 0;
494 
496  name, subscripts, bits, value);
497  }
498 
499  if (width < 32)
500  put_bits(pbc, width, value);
501  else
502  put_bits32(pbc, value);
503 
504  return 0;
505 }
506 
508  int width, const char *name,
509  const int *subscripts, int32_t *write_to,
510  int32_t range_min, int32_t range_max)
511 {
512  int32_t value;
513  int position;
514 
515  av_assert0(width > 0 && width <= 32);
516 
517  if (get_bits_left(gbc) < width) {
518  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
519  "%s: bitstream ended.\n", name);
520  return AVERROR_INVALIDDATA;
521  }
522 
523  if (ctx->trace_enable)
524  position = get_bits_count(gbc);
525 
526  value = get_sbits_long(gbc, width);
527 
528  if (ctx->trace_enable) {
529  char bits[33];
530  int i;
531  for (i = 0; i < width; i++)
532  bits[i] = value & (1U << (width - i - 1)) ? '1' : '0';
533  bits[i] = 0;
534 
535  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
536  bits, value);
537  }
538 
539  if (value < range_min || value > range_max) {
540  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
541  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
542  name, value, range_min, range_max);
543  return AVERROR_INVALIDDATA;
544  }
545 
546  *write_to = value;
547  return 0;
548 }
549 
551  int width, const char *name,
552  const int *subscripts, int32_t value,
553  int32_t range_min, int32_t range_max)
554 {
555  av_assert0(width > 0 && width <= 32);
556 
557  if (value < range_min || value > range_max) {
558  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
559  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
560  name, value, range_min, range_max);
561  return AVERROR_INVALIDDATA;
562  }
563 
564  if (put_bits_left(pbc) < width)
565  return AVERROR(ENOSPC);
566 
567  if (ctx->trace_enable) {
568  char bits[33];
569  int i;
570  for (i = 0; i < width; i++)
571  bits[i] = value & (1U << (width - i - 1)) ? '1' : '0';
572  bits[i] = 0;
573 
575  name, subscripts, bits, value);
576  }
577 
578  if (width < 32)
579  put_sbits(pbc, width, value);
580  else
581  put_bits32(pbc, value);
582 
583  return 0;
584 }
585 
586 
588  CodedBitstreamUnit *unit,
589  size_t size,
590  void (*free)(void *opaque, uint8_t *data))
591 {
592  av_assert0(!unit->content && !unit->content_ref);
593 
594  unit->content = av_mallocz(size);
595  if (!unit->content)
596  return AVERROR(ENOMEM);
597 
598  unit->content_ref = av_buffer_create(unit->content, size,
599  free, ctx, 0);
600  if (!unit->content_ref) {
601  av_freep(&unit->content);
602  return AVERROR(ENOMEM);
603  }
604 
605  return 0;
606 }
607 
609  CodedBitstreamUnit *unit,
610  size_t size)
611 {
612  av_assert0(!unit->data && !unit->data_ref);
613 
615  if (!unit->data_ref)
616  return AVERROR(ENOMEM);
617 
618  unit->data = unit->data_ref->data;
619  unit->data_size = size;
620 
621  memset(unit->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
622 
623  return 0;
624 }
625 
628  int position)
629 {
630  CodedBitstreamUnit *units;
631 
632  if (frag->nb_units < frag->nb_units_allocated) {
633  units = frag->units;
634 
635  if (position < frag->nb_units)
636  memmove(units + position + 1, units + position,
637  (frag->nb_units - position) * sizeof(*units));
638  } else {
639  units = av_malloc_array(frag->nb_units + 1, sizeof(*units));
640  if (!units)
641  return AVERROR(ENOMEM);
642 
643  ++frag->nb_units_allocated;
644 
645  if (position > 0)
646  memcpy(units, frag->units, position * sizeof(*units));
647 
648  if (position < frag->nb_units)
649  memcpy(units + position + 1, frag->units + position,
650  (frag->nb_units - position) * sizeof(*units));
651  }
652 
653  memset(units + position, 0, sizeof(*units));
654 
655  if (units != frag->units) {
656  av_free(frag->units);
657  frag->units = units;
658  }
659 
660  ++frag->nb_units;
661 
662  return 0;
663 }
664 
667  int position,
669  void *content,
670  AVBufferRef *content_buf)
671 {
672  CodedBitstreamUnit *unit;
673  AVBufferRef *content_ref;
674  int err;
675 
676  if (position == -1)
677  position = frag->nb_units;
678  av_assert0(position >= 0 && position <= frag->nb_units);
679 
680  if (content_buf) {
681  content_ref = av_buffer_ref(content_buf);
682  if (!content_ref)
683  return AVERROR(ENOMEM);
684  } else {
685  content_ref = NULL;
686  }
687 
688  err = cbs_insert_unit(ctx, frag, position);
689  if (err < 0) {
690  av_buffer_unref(&content_ref);
691  return err;
692  }
693 
694  unit = &frag->units[position];
695  unit->type = type;
696  unit->content = content;
697  unit->content_ref = content_ref;
698 
699  return 0;
700 }
701 
704  int position,
706  uint8_t *data, size_t data_size,
707  AVBufferRef *data_buf)
708 {
709  CodedBitstreamUnit *unit;
710  AVBufferRef *data_ref;
711  int err;
712 
713  if (position == -1)
714  position = frag->nb_units;
715  av_assert0(position >= 0 && position <= frag->nb_units);
716 
717  if (data_buf)
718  data_ref = av_buffer_ref(data_buf);
719  else
720  data_ref = av_buffer_create(data, data_size, NULL, NULL, 0);
721  if (!data_ref)
722  return AVERROR(ENOMEM);
723 
724  err = cbs_insert_unit(ctx, frag, position);
725  if (err < 0) {
726  av_buffer_unref(&data_ref);
727  return err;
728  }
729 
730  unit = &frag->units[position];
731  unit->type = type;
732  unit->data = data;
733  unit->data_size = data_size;
734  unit->data_ref = data_ref;
735 
736  return 0;
737 }
738 
741  int position)
742 {
743  if (position < 0 || position >= frag->nb_units)
744  return AVERROR(EINVAL);
745 
746  cbs_unit_uninit(ctx, &frag->units[position]);
747 
748  --frag->nb_units;
749 
750  if (frag->nb_units > 0)
751  memmove(frag->units + position,
752  frag->units + position + 1,
753  (frag->nb_units - position) * sizeof(*frag->units));
754 
755  return 0;
756 }
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
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:345
static void cbs_unit_uninit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:127
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
enum AVCodecID codec_id
Definition: qsv.c:72
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int size
Definition: avcodec.h:1478
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:587
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:665
void ff_cbs_trace_header(CodedBitstreamContext *ctx, const char *name)
Definition: cbs.c:369
GLint GLenum type
Definition: opengl_enc.c:104
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static AVPacket pkt
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3945
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:471
#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:53
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:428
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
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
static int cbs_read_fragment_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs.c:163
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:239
uint8_t * data
Definition: avcodec.h:1477
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:550
#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:608
Coded bitstream unit structure.
Definition: cbs.h:64
ptrdiff_t size
Definition: opengl_enc.c:100
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:507
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:702
#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:154
#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:260
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void(* close)(CodedBitstreamContext *ctx)
Definition: cbs_internal.h:57
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1460
simple assert() macros that are a bit more flexible than ISO C assert().
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:28
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:85
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3971
const CodedBitstreamType ff_cbs_type_mpeg2
Definition: cbs_mpeg2.c:436
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:1559
const CodedBitstreamType ff_cbs_type_av1
Definition: cbs_av1.c:1305
int(* write_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_internal.h:48
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:320
#define width
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
int 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:739
int n
Definition: avisynth_c.h:760
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
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:284
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:509
uint8_t * data
The data buffer.
Definition: buffer.h:89
int trace_level
Log level to use for trace output.
Definition: cbs.h:212
void * buf
Definition: avisynth_c.h:766
static int cbs_fill_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Definition: cbs.c:200
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:139
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
refcounted data buffer API
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:113
#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:221
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
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:626
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:1572
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
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:790
#define av_free(p)
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3967
#define av_freep(p)
#define AV_CODEC_ID_H265
Definition: avcodec.h:393
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:266
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:139
const CodedBitstreamType ff_cbs_type_vp9
Definition: cbs_vp9.c:681
This structure stores compressed data.
Definition: avcodec.h:1454
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:378
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:80
const char * name
Definition: opengl_enc.c:102