FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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_H264
34 #endif
35 #if CONFIG_CBS_H265
37 #endif
38 #if CONFIG_CBS_MPEG2
40 #endif
41 };
42 
44  enum AVCodecID codec_id, void *log_ctx)
45 {
47  const CodedBitstreamType *type;
48  int i;
49 
50  type = NULL;
51  for (i = 0; i < FF_ARRAY_ELEMS(cbs_type_table); i++) {
52  if (cbs_type_table[i]->codec_id == codec_id) {
53  type = cbs_type_table[i];
54  break;
55  }
56  }
57  if (!type)
58  return AVERROR(EINVAL);
59 
60  ctx = av_mallocz(sizeof(*ctx));
61  if (!ctx)
62  return AVERROR(ENOMEM);
63 
64  ctx->log_ctx = log_ctx;
65  ctx->codec = type;
66 
68  if (!ctx->priv_data) {
69  av_freep(&ctx);
70  return AVERROR(ENOMEM);
71  }
72 
74 
75  ctx->trace_enable = 0;
77 
78  *ctx_ptr = ctx;
79  return 0;
80 }
81 
83 {
84  CodedBitstreamContext *ctx = *ctx_ptr;
85 
86  if (!ctx)
87  return;
88 
89  if (ctx->codec && ctx->codec->close)
90  ctx->codec->close(ctx);
91 
92  av_freep(&ctx->priv_data);
93  av_freep(ctx_ptr);
94 }
95 
97  CodedBitstreamUnit *unit)
98 {
100  unit->content = NULL;
101 
102  av_buffer_unref(&unit->data_ref);
103  unit->data = NULL;
104  unit->data_size = 0;
105  unit->data_bit_padding = 0;
106 }
107 
110 {
111  int i;
112 
113  for (i = 0; i < frag->nb_units; i++)
114  cbs_unit_uninit(ctx, &frag->units[i]);
115  av_freep(&frag->units);
116  frag->nb_units = 0;
117 
118  av_buffer_unref(&frag->data_ref);
119  frag->data = NULL;
120  frag->data_size = 0;
121  frag->data_bit_padding = 0;
122 }
123 
126 {
127  int err, i, j;
128 
129  for (i = 0; i < frag->nb_units; i++) {
130  if (ctx->decompose_unit_types) {
131  for (j = 0; j < ctx->nb_decompose_unit_types; j++) {
132  if (ctx->decompose_unit_types[j] == frag->units[i].type)
133  break;
134  }
135  if (j >= ctx->nb_decompose_unit_types)
136  continue;
137  }
138 
139  av_buffer_unref(&frag->units[i].content_ref);
140  frag->units[i].content = NULL;
141 
142  err = ctx->codec->read_unit(ctx, &frag->units[i]);
143  if (err == AVERROR(ENOSYS)) {
145  "Decomposition unimplemented for unit %d "
146  "(type %"PRIu32").\n", i, frag->units[i].type);
147  } else if (err < 0) {
148  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to read unit %d "
149  "(type %"PRIu32").\n", i, frag->units[i].type);
150  return err;
151  }
152  }
153 
154  return 0;
155 }
156 
159  const AVCodecParameters *par)
160 {
161  int err;
162 
163  memset(frag, 0, sizeof(*frag));
164 
165  frag->data = par->extradata;
166  frag->data_size = par->extradata_size;
167 
168  err = ctx->codec->split_fragment(ctx, frag, 1);
169  if (err < 0)
170  return err;
171 
172  frag->data = NULL;
173  frag->data_size = 0;
174 
175  return cbs_read_fragment_content(ctx, frag);
176 }
177 
180  const uint8_t *data, size_t size)
181 {
182  av_assert0(!frag->data && !frag->data_ref);
183 
184  frag->data_ref =
186  if (!frag->data_ref)
187  return AVERROR(ENOMEM);
188 
189  frag->data = frag->data_ref->data;
190  frag->data_size = size;
191 
192  memcpy(frag->data, data, size);
193  memset(frag->data + size, 0,
195 
196  return 0;
197 }
198 
201  const AVPacket *pkt)
202 {
203  int err;
204 
205  memset(frag, 0, sizeof(*frag));
206 
207  if (pkt->buf) {
208  frag->data_ref = av_buffer_ref(pkt->buf);
209  if (!frag->data_ref)
210  return AVERROR(ENOMEM);
211 
212  frag->data = pkt->data;
213  frag->data_size = pkt->size;
214 
215  } else {
216  err = cbs_fill_fragment_data(ctx, frag, pkt->data, pkt->size);
217  if (err < 0)
218  return err;
219  }
220 
221  err = ctx->codec->split_fragment(ctx, frag, 0);
222  if (err < 0)
223  return err;
224 
225  return cbs_read_fragment_content(ctx, frag);
226 }
227 
230  const uint8_t *data, size_t size)
231 {
232  int err;
233 
234  memset(frag, 0, sizeof(*frag));
235 
236  err = cbs_fill_fragment_data(ctx, frag, data, size);
237  if (err < 0)
238  return err;
239 
240  err = ctx->codec->split_fragment(ctx, frag, 0);
241  if (err < 0)
242  return err;
243 
244  return cbs_read_fragment_content(ctx, frag);
245 }
246 
247 
250 {
251  int err, i;
252 
253  for (i = 0; i < frag->nb_units; i++) {
254  CodedBitstreamUnit *unit = &frag->units[i];
255 
256  if (!unit->content)
257  continue;
258 
259  av_buffer_unref(&unit->data_ref);
260  unit->data = NULL;
261 
262  err = ctx->codec->write_unit(ctx, unit);
263  if (err < 0) {
264  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write unit %d "
265  "(type %"PRIu32").\n", i, unit->type);
266  return err;
267  }
268  }
269 
270  av_buffer_unref(&frag->data_ref);
271  frag->data = NULL;
272 
273  err = ctx->codec->assemble_fragment(ctx, frag);
274  if (err < 0) {
275  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to assemble fragment.\n");
276  return err;
277  }
278 
279  return 0;
280 }
281 
283  AVCodecParameters *par,
285 {
286  int err;
287 
288  err = ff_cbs_write_fragment_data(ctx, frag);
289  if (err < 0)
290  return err;
291 
292  av_freep(&par->extradata);
293 
294  par->extradata = av_malloc(frag->data_size +
296  if (!par->extradata)
297  return AVERROR(ENOMEM);
298 
299  memcpy(par->extradata, frag->data, frag->data_size);
300  memset(par->extradata + frag->data_size, 0,
302  par->extradata_size = frag->data_size;
303 
304  return 0;
305 }
306 
308  AVPacket *pkt,
310 {
311  int err;
312 
313  err = ff_cbs_write_fragment_data(ctx, frag);
314  if (err < 0)
315  return err;
316 
317  err = av_new_packet(pkt, frag->data_size);
318  if (err < 0)
319  return err;
320 
321  memcpy(pkt->data, frag->data, frag->data_size);
322  pkt->size = frag->data_size;
323 
324  return 0;
325 }
326 
327 
329  const char *name)
330 {
331  if (!ctx->trace_enable)
332  return;
333 
334  av_log(ctx->log_ctx, ctx->trace_level, "%s\n", name);
335 }
336 
338  const char *name, const char *bits,
339  int64_t value)
340 {
341  size_t name_len, bits_len;
342  int pad;
343 
344  if (!ctx->trace_enable)
345  return;
346 
347  av_assert0(value >= INT_MIN && value <= UINT32_MAX);
348 
349  name_len = strlen(name);
350  bits_len = strlen(bits);
351 
352  if (name_len + bits_len > 60)
353  pad = bits_len + 2;
354  else
355  pad = 61 - name_len;
356 
357  av_log(ctx->log_ctx, ctx->trace_level, "%-10d %s%*s = %"PRId64"\n",
358  position, name, pad, bits, value);
359 }
360 
362  int width, const char *name, uint32_t *write_to,
363  uint32_t range_min, uint32_t range_max)
364 {
365  uint32_t value;
366  int position;
367 
368  av_assert0(width > 0 && width <= 32);
369 
370  if (get_bits_left(gbc) < width) {
371  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
372  "%s: bitstream ended.\n", name);
373  return AVERROR_INVALIDDATA;
374  }
375 
376  if (ctx->trace_enable)
377  position = get_bits_count(gbc);
378 
379  value = get_bits_long(gbc, width);
380 
381  if (ctx->trace_enable) {
382  char bits[33];
383  int i;
384  for (i = 0; i < width; i++)
385  bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
386  bits[i] = 0;
387 
388  ff_cbs_trace_syntax_element(ctx, position, name, bits, value);
389  }
390 
391  if (value < range_min || value > range_max) {
392  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
393  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
394  name, value, range_min, range_max);
395  return AVERROR_INVALIDDATA;
396  }
397 
398  *write_to = value;
399  return 0;
400 }
401 
403  int width, const char *name, uint32_t value,
404  uint32_t range_min, uint32_t range_max)
405 {
406  av_assert0(width > 0 && width <= 32);
407 
408  if (value < range_min || value > range_max) {
409  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
410  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
411  name, value, range_min, range_max);
412  return AVERROR_INVALIDDATA;
413  }
414 
415  if (put_bits_left(pbc) < width)
416  return AVERROR(ENOSPC);
417 
418  if (ctx->trace_enable) {
419  char bits[33];
420  int i;
421  for (i = 0; i < width; i++)
422  bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
423  bits[i] = 0;
424 
425  ff_cbs_trace_syntax_element(ctx, put_bits_count(pbc), name, bits, value);
426  }
427 
428  if (width < 32)
429  put_bits(pbc, width, value);
430  else
431  put_bits32(pbc, value);
432 
433  return 0;
434 }
435 
436 
438  CodedBitstreamUnit *unit,
439  size_t size,
440  void (*free)(void *opaque, uint8_t *data))
441 {
442  av_assert0(!unit->content && !unit->content_ref);
443 
444  unit->content = av_mallocz(size);
445  if (!unit->content)
446  return AVERROR(ENOMEM);
447 
448  unit->content_ref = av_buffer_create(unit->content, size,
449  free, ctx, 0);
450  if (!unit->content_ref) {
451  av_freep(&unit->content);
452  return AVERROR(ENOMEM);
453  }
454 
455  return 0;
456 }
457 
459  CodedBitstreamUnit *unit,
460  size_t size)
461 {
462  av_assert0(!unit->data && !unit->data_ref);
463 
465  if (!unit->data_ref)
466  return AVERROR(ENOMEM);
467 
468  unit->data = unit->data_ref->data;
469  unit->data_size = size;
470 
471  memset(unit->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
472 
473  return 0;
474 }
475 
478  int position)
479 {
480  CodedBitstreamUnit *units;
481 
482  units = av_malloc_array(frag->nb_units + 1, sizeof(*units));
483  if (!units)
484  return AVERROR(ENOMEM);
485 
486  if (position > 0)
487  memcpy(units, frag->units, position * sizeof(*units));
488  if (position < frag->nb_units)
489  memcpy(units + position + 1, frag->units + position,
490  (frag->nb_units - position) * sizeof(*units));
491 
492  memset(units + position, 0, sizeof(*units));
493 
494  av_freep(&frag->units);
495  frag->units = units;
496  ++frag->nb_units;
497 
498  return 0;
499 }
500 
503  int position,
505  void *content,
506  AVBufferRef *content_buf)
507 {
508  CodedBitstreamUnit *unit;
509  AVBufferRef *content_ref;
510  int err;
511 
512  if (position == -1)
513  position = frag->nb_units;
514  av_assert0(position >= 0 && position <= frag->nb_units);
515 
516  if (content_buf) {
517  content_ref = av_buffer_ref(content_buf);
518  if (!content_ref)
519  return AVERROR(ENOMEM);
520  } else {
521  content_ref = NULL;
522  }
523 
524  err = cbs_insert_unit(ctx, frag, position);
525  if (err < 0) {
526  av_buffer_unref(&content_ref);
527  return err;
528  }
529 
530  unit = &frag->units[position];
531  unit->type = type;
532  unit->content = content;
533  unit->content_ref = content_ref;
534 
535  return 0;
536 }
537 
540  int position,
542  uint8_t *data, size_t data_size,
543  AVBufferRef *data_buf)
544 {
545  CodedBitstreamUnit *unit;
546  AVBufferRef *data_ref;
547  int err;
548 
549  if (position == -1)
550  position = frag->nb_units;
551  av_assert0(position >= 0 && position <= frag->nb_units);
552 
553  if (data_buf)
554  data_ref = av_buffer_ref(data_buf);
555  else
556  data_ref = av_buffer_create(data, data_size, NULL, NULL, 0);
557  if (!data_ref)
558  return AVERROR(ENOMEM);
559 
560  err = cbs_insert_unit(ctx, frag, position);
561  if (err < 0) {
562  av_buffer_unref(&data_ref);
563  return err;
564  }
565 
566  unit = &frag->units[position];
567  unit->type = type;
568  unit->data = data;
569  unit->data_size = data_size;
570  unit->data_ref = data_ref;
571 
572  return 0;
573 }
574 
577  int position)
578 {
579  if (position < 0 || position >= frag->nb_units)
580  return AVERROR(EINVAL);
581 
582  cbs_unit_uninit(ctx, &frag->units[position]);
583 
584  --frag->nb_units;
585 
586  if (frag->nb_units == 0) {
587  av_freep(&frag->units);
588 
589  } else {
590  memmove(frag->units + position,
591  frag->units + position + 1,
592  (frag->nb_units - position) * sizeof(*frag->units));
593 
594  // Don't bother reallocating the unit array.
595  }
596 
597  return 0;
598 }
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:144
#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:101
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:207
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:307
static void cbs_unit_uninit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:96
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:43
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:67
int size
Definition: avcodec.h:1417
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:437
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:501
void ff_cbs_trace_header(CodedBitstreamContext *ctx, const char *name)
Definition: cbs.c:328
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:3855
#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:194
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
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:85
static const CodedBitstreamType * cbs_type_table[]
Definition: cbs.c:31
int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, uint32_t value, uint32_t range_min, uint32_t range_max)
Definition: cbs.c:402
void(* close)(CodedBitstreamContext *ctx)
Definition: cbs_internal.h:57
static int cbs_read_fragment_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs.c:124
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:199
uint8_t * data
Definition: avcodec.h:1416
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
#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:458
Coded bitstream unit structure.
Definition: cbs.h:63
ptrdiff_t size
Definition: opengl_enc.c:101
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:99
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units.
Definition: cbs.h:150
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:74
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:538
#define av_log(a,...)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:127
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:588
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 ff_cbs_fragment_uninit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free all allocated memory in a fragment.
Definition: cbs.c:108
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
#define AVERROR(e)
Definition: error.h:43
int(* split_fragment)(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_internal.h:38
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1399
uint16_t width
Definition: gdv.c:47
simple assert() macros that are a bit more flexible than ISO C assert().
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
int(* read_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_internal.h:44
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:131
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:3881
const CodedBitstreamType ff_cbs_type_mpeg2
Definition: cbs_mpeg2.c:404
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:161
const CodedBitstreamType ff_cbs_type_h264
Definition: cbs_h2645.c:1400
int(* assemble_fragment)(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_internal.h:53
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:282
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
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:575
enum AVCodecID codec_id
Definition: vaapi_decode.c:362
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:120
#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:248
int nb_decompose_unit_types
Length of the decompose_unit_types array.
Definition: cbs.h:189
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:114
uint8_t * data
The data buffer.
Definition: buffer.h:89
int trace_level
Log level to use for trace output.
Definition: cbs.h:200
GLint GLenum type
Definition: opengl_enc.c:105
static int cbs_fill_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Definition: cbs.c:178
Context structure for coded bitstream operations.
Definition: cbs.h:156
AVBufferRef * content_ref
If content is reference counted, a reference to the buffer containing content.
Definition: cbs.h:104
refcounted data buffer API
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:82
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:346
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:157
void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position, const char *name, const char *bits, int64_t value)
Definition: cbs.c:337
void * priv_data
Internal codec-specific data.
Definition: cbs.h:177
A reference to a data buffer.
Definition: buffer.h:81
common internal and external API header
AVBufferRef * data_ref
If data is reference counted, a reference to the buffer containing data.
Definition: cbs.h:90
static int cbs_insert_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Definition: cbs.c:476
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:185
const CodedBitstreamType ff_cbs_type_h265
Definition: cbs_h2645.c:1413
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:772
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3877
#define av_freep(p)
const struct CodedBitstreamType * codec
Internal codec-specific hooks.
Definition: cbs.h:166
#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:228
AVBufferRef * data_ref
If data is reference counted, a reference to the buffer containing data.
Definition: cbs.h:136
This structure stores compressed data.
Definition: avcodec.h:1393
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:79
const char * name
Definition: opengl_enc.c:103
int(* write_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_internal.h:48
int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, uint32_t *write_to, uint32_t range_min, uint32_t range_max)
Definition: cbs.c:361