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 #include "libavutil/mem.h"
27 #include "libavutil/opt.h"
28 
29 #include "avcodec.h"
30 #include "cbs.h"
31 #include "cbs_internal.h"
32 #include "refstruct.h"
33 
34 
35 static const CodedBitstreamType *const cbs_type_table[] = {
36 #if CONFIG_CBS_AV1
38 #endif
39 #if CONFIG_CBS_H264
41 #endif
42 #if CONFIG_CBS_H265
44 #endif
45 #if CONFIG_CBS_H266
47 #endif
48 #if CONFIG_CBS_JPEG
50 #endif
51 #if CONFIG_CBS_MPEG2
53 #endif
54 #if CONFIG_CBS_VP8
56 #endif
57 #if CONFIG_CBS_VP9
59 #endif
60 };
61 
63 #if CONFIG_CBS_AV1
65 #endif
66 #if CONFIG_CBS_H264
68 #endif
69 #if CONFIG_CBS_H265
71 #endif
72 #if CONFIG_CBS_H266
74 #endif
75 #if CONFIG_CBS_JPEG
77 #endif
78 #if CONFIG_CBS_MPEG2
80 #endif
81 #if CONFIG_CBS_VP8
83 #endif
84 #if CONFIG_CBS_VP9
86 #endif
88 };
89 
91  enum AVCodecID codec_id, void *log_ctx)
92 {
94  const CodedBitstreamType *type;
95  int i;
96 
97  type = NULL;
98  for (i = 0; i < FF_ARRAY_ELEMS(cbs_type_table); i++) {
99  if (cbs_type_table[i]->codec_id == codec_id) {
100  type = cbs_type_table[i];
101  break;
102  }
103  }
104  if (!type)
105  return AVERROR(EINVAL);
106 
107  ctx = av_mallocz(sizeof(*ctx));
108  if (!ctx)
109  return AVERROR(ENOMEM);
110 
111  ctx->log_ctx = log_ctx;
112  ctx->codec = type; /* Must be before any error */
113 
114  if (type->priv_data_size) {
115  ctx->priv_data = av_mallocz(ctx->codec->priv_data_size);
116  if (!ctx->priv_data) {
117  av_freep(&ctx);
118  return AVERROR(ENOMEM);
119  }
120  if (type->priv_class) {
121  *(const AVClass **)ctx->priv_data = type->priv_class;
123  }
124  }
125 
126  ctx->decompose_unit_types = NULL;
127 
128  ctx->trace_enable = 0;
129  ctx->trace_level = AV_LOG_TRACE;
130  ctx->trace_context = ctx;
131 
132  *ctx_ptr = ctx;
133  return 0;
134 }
135 
137 {
138  if (ctx->codec->flush)
139  ctx->codec->flush(ctx);
140 }
141 
143 {
144  CodedBitstreamContext *ctx = *ctx_ptr;
145 
146  if (!ctx)
147  return;
148 
149  if (ctx->codec->close)
150  ctx->codec->close(ctx);
151 
152  av_freep(&ctx->write_buffer);
153 
154  if (ctx->codec->priv_class && ctx->priv_data)
156 
158  av_freep(ctx_ptr);
159 }
160 
162 {
164  unit->content = NULL;
165 
166  av_buffer_unref(&unit->data_ref);
167  unit->data = NULL;
168  unit->data_size = 0;
169  unit->data_bit_padding = 0;
170 }
171 
173 {
174  int i;
175 
176  for (i = 0; i < frag->nb_units; i++)
177  cbs_unit_uninit(&frag->units[i]);
178  frag->nb_units = 0;
179 
180  av_buffer_unref(&frag->data_ref);
181  frag->data = NULL;
182  frag->data_size = 0;
183  frag->data_bit_padding = 0;
184 }
185 
187 {
188  ff_cbs_fragment_reset(frag);
189 
190  av_freep(&frag->units);
191  frag->nb_units_allocated = 0;
192 }
193 
196 {
197  int err, i, j;
198 
199  for (i = 0; i < frag->nb_units; i++) {
200  CodedBitstreamUnit *unit = &frag->units[i];
201 
202  if (ctx->decompose_unit_types) {
203  for (j = 0; j < ctx->nb_decompose_unit_types; j++) {
204  if (ctx->decompose_unit_types[j] == unit->type)
205  break;
206  }
207  if (j >= ctx->nb_decompose_unit_types)
208  continue;
209  }
210 
212  unit->content = NULL;
213 
214  av_assert0(unit->data && unit->data_ref);
215 
216  err = ctx->codec->read_unit(ctx, unit);
217  if (err == AVERROR(ENOSYS)) {
218  av_log(ctx->log_ctx, AV_LOG_VERBOSE,
219  "Decomposition unimplemented for unit %d "
220  "(type %"PRIu32").\n", i, unit->type);
221  } else if (err == AVERROR(EAGAIN)) {
222  av_log(ctx->log_ctx, AV_LOG_VERBOSE,
223  "Skipping decomposition of unit %d "
224  "(type %"PRIu32").\n", i, unit->type);
226  unit->content = NULL;
227  } else if (err < 0) {
228  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to read unit %d "
229  "(type %"PRIu32").\n", i, unit->type);
230  return err;
231  }
232  }
233 
234  return 0;
235 }
236 
238  const uint8_t *data, size_t size)
239 {
240  av_assert0(!frag->data && !frag->data_ref);
241 
242  frag->data_ref =
244  if (!frag->data_ref)
245  return AVERROR(ENOMEM);
246 
247  frag->data = frag->data_ref->data;
248  frag->data_size = size;
249 
250  memcpy(frag->data, data, size);
251  memset(frag->data + size, 0,
253 
254  return 0;
255 }
256 
259  AVBufferRef *buf,
260  const uint8_t *data, size_t size,
261  int header)
262 {
263  int err;
264 
265  if (buf) {
266  frag->data_ref = av_buffer_ref(buf);
267  if (!frag->data_ref)
268  return AVERROR(ENOMEM);
269 
270  frag->data = (uint8_t *)data;
271  frag->data_size = size;
272 
273  } else {
274  err = cbs_fill_fragment_data(frag, data, size);
275  if (err < 0)
276  return err;
277  }
278 
279  err = ctx->codec->split_fragment(ctx, frag, header);
280  if (err < 0)
281  return err;
282 
283  return cbs_read_fragment_content(ctx, frag);
284 }
285 
288  const AVCodecParameters *par)
289 {
290  return cbs_read_data(ctx, frag, NULL,
291  par->extradata,
292  par->extradata_size, 1);
293 }
294 
297  const AVCodecContext *avctx)
298 {
299  return cbs_read_data(ctx, frag, NULL,
300  avctx->extradata,
301  avctx->extradata_size, 1);
302 }
303 
306  const AVPacket *pkt)
307 {
308  return cbs_read_data(ctx, frag, pkt->buf,
309  pkt->data, pkt->size, 0);
310 }
311 
314  const AVPacket *pkt)
315 {
316  size_t side_data_size;
317  const uint8_t *side_data =
319  &side_data_size);
320 
321  return cbs_read_data(ctx, frag, NULL,
322  side_data, side_data_size, 1);
323 }
324 
327  const uint8_t *data, size_t size)
328 {
329  return cbs_read_data(ctx, frag, NULL,
330  data, size, 0);
331 }
332 
333 /**
334  * Allocate a new internal data buffer of the given size in the unit.
335  *
336  * The data buffer will have input padding.
337  */
339  size_t size)
340 {
341  av_assert0(!unit->data && !unit->data_ref);
342 
344  if (!unit->data_ref)
345  return AVERROR(ENOMEM);
346 
347  unit->data = unit->data_ref->data;
348  unit->data_size = size;
349 
350  memset(unit->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
351 
352  return 0;
353 }
354 
356  CodedBitstreamUnit *unit)
357 {
358  PutBitContext pbc;
359  int ret;
360 
361  if (!ctx->write_buffer) {
362  // Initial write buffer size is 1MB.
363  ctx->write_buffer_size = 1024 * 1024;
364 
365  reallocate_and_try_again:
366  ret = av_reallocp(&ctx->write_buffer, ctx->write_buffer_size);
367  if (ret < 0) {
368  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
369  "sufficiently large write buffer (last attempt "
370  "%"SIZE_SPECIFIER" bytes).\n", ctx->write_buffer_size);
371  return ret;
372  }
373  }
374 
375  init_put_bits(&pbc, ctx->write_buffer, ctx->write_buffer_size);
376 
377  ret = ctx->codec->write_unit(ctx, unit, &pbc);
378  if (ret < 0) {
379  if (ret == AVERROR(ENOSPC)) {
380  // Overflow.
381  if (ctx->write_buffer_size == INT_MAX / 8)
382  return AVERROR(ENOMEM);
383  ctx->write_buffer_size = FFMIN(2 * ctx->write_buffer_size, INT_MAX / 8);
384  goto reallocate_and_try_again;
385  }
386  // Write failed for some other reason.
387  return ret;
388  }
389 
390  // Overflow but we didn't notice.
391  av_assert0(put_bits_count(&pbc) <= 8 * ctx->write_buffer_size);
392 
393  if (put_bits_count(&pbc) % 8)
394  unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
395  else
396  unit->data_bit_padding = 0;
397 
398  flush_put_bits(&pbc);
399 
401  if (ret < 0)
402  return ret;
403 
404  memcpy(unit->data, ctx->write_buffer, unit->data_size);
405 
406  return 0;
407 }
408 
411 {
412  int err, i;
413 
414  for (i = 0; i < frag->nb_units; i++) {
415  CodedBitstreamUnit *unit = &frag->units[i];
416 
417  if (!unit->content)
418  continue;
419 
420  av_buffer_unref(&unit->data_ref);
421  unit->data = NULL;
422 
423  err = cbs_write_unit_data(ctx, unit);
424  if (err < 0) {
425  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write unit %d "
426  "(type %"PRIu32").\n", i, unit->type);
427  return err;
428  }
429  av_assert0(unit->data && unit->data_ref);
430  }
431 
432  av_buffer_unref(&frag->data_ref);
433  frag->data = NULL;
434 
435  err = ctx->codec->assemble_fragment(ctx, frag);
436  if (err < 0) {
437  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to assemble fragment.\n");
438  return err;
439  }
440  av_assert0(frag->data && frag->data_ref);
441 
442  return 0;
443 }
444 
446  AVCodecParameters *par,
448 {
449  int err;
450 
451  err = ff_cbs_write_fragment_data(ctx, frag);
452  if (err < 0)
453  return err;
454 
455  av_freep(&par->extradata);
456  par->extradata_size = 0;
457 
458  if (!frag->data_size)
459  return 0;
460 
461  par->extradata = av_malloc(frag->data_size +
463  if (!par->extradata)
464  return AVERROR(ENOMEM);
465 
466  memcpy(par->extradata, frag->data, frag->data_size);
467  memset(par->extradata + frag->data_size, 0,
469  par->extradata_size = frag->data_size;
470 
471  return 0;
472 }
473 
475  AVPacket *pkt,
477 {
478  AVBufferRef *buf;
479  int err;
480 
481  err = ff_cbs_write_fragment_data(ctx, frag);
482  if (err < 0)
483  return err;
484 
485  buf = av_buffer_ref(frag->data_ref);
486  if (!buf)
487  return AVERROR(ENOMEM);
488 
490 
491  pkt->buf = buf;
492  pkt->data = frag->data;
493  pkt->size = frag->data_size;
494 
495  return 0;
496 }
497 
498 
500  const char *name)
501 {
502  if (!ctx->trace_enable)
503  return;
504 
505  av_log(ctx->log_ctx, ctx->trace_level, "%s\n", name);
506 }
507 
508 void ff_cbs_trace_read_log(void *trace_context,
509  GetBitContext *gbc, int length,
510  const char *str, const int *subscripts,
511  int64_t value)
512 {
513  CodedBitstreamContext *ctx = trace_context;
514  char name[256];
515  char bits[256];
516  size_t name_len, bits_len;
517  int pad, subs, i, j, k, n;
518  int position;
519 
520  av_assert0(value >= INT_MIN && value <= UINT32_MAX);
521 
522  position = get_bits_count(gbc);
523 
524  av_assert0(length < 256);
525  for (i = 0; i < length; i++)
526  bits[i] = get_bits1(gbc) ? '1' : '0';
527  bits[length] = 0;
528 
529  subs = subscripts ? subscripts[0] : 0;
530  n = 0;
531  for (i = j = 0; str[i];) {
532  if (str[i] == '[') {
533  if (n < subs) {
534  ++n;
535  k = snprintf(name + j, sizeof(name) - j, "[%d", subscripts[n]);
536  av_assert0(k > 0 && j + k < sizeof(name));
537  j += k;
538  for (++i; str[i] && str[i] != ']'; i++);
539  av_assert0(str[i] == ']');
540  } else {
541  while (str[i] && str[i] != ']')
542  name[j++] = str[i++];
543  av_assert0(str[i] == ']');
544  }
545  } else {
546  av_assert0(j + 1 < sizeof(name));
547  name[j++] = str[i++];
548  }
549  }
550  av_assert0(j + 1 < sizeof(name));
551  name[j] = 0;
552  av_assert0(n == subs);
553 
554  name_len = strlen(name);
555  bits_len = length;
556 
557  if (name_len + bits_len > 60)
558  pad = bits_len + 2;
559  else
560  pad = 61 - name_len;
561 
562  av_log(ctx->log_ctx, ctx->trace_level, "%-10d %s%*s = %"PRId64"\n",
563  position, name, pad, bits, value);
564 }
565 
566 void ff_cbs_trace_write_log(void *trace_context,
567  PutBitContext *pbc, int length,
568  const char *str, const int *subscripts,
569  int64_t value)
570 {
571  CodedBitstreamContext *ctx = trace_context;
572 
573  // Ensure that the syntax element is written to the output buffer,
574  // make a GetBitContext pointed at the start position, then call the
575  // read log function which can read the bits back to log them.
576 
577  GetBitContext gbc;
578  int position;
579 
580  if (length > 0) {
582  flush = *pbc;
584  }
585 
586  position = put_bits_count(pbc);
587  av_assert0(position >= length);
588 
589  init_get_bits(&gbc, pbc->buf, position);
590 
591  skip_bits_long(&gbc, position - length);
592 
593  ff_cbs_trace_read_log(ctx, &gbc, length, str, subscripts, value);
594 }
595 
597  GetBitContext *gbc,
598  int width, const char *name,
599  const int *subscripts,
600  uint32_t *write_to,
601  uint32_t range_min,
602  uint32_t range_max)
603 {
604  uint32_t value;
605 
607 
608  av_assert0(width > 0 && width <= 32);
609 
610  if (get_bits_left(gbc) < width) {
611  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
612  "%s: bitstream ended.\n", name);
613  return AVERROR_INVALIDDATA;
614  }
615 
616  value = get_bits_long(gbc, width);
617 
619 
620  if (value < range_min || value > range_max) {
621  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
622  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
623  name, value, range_min, range_max);
624  return AVERROR_INVALIDDATA;
625  }
626 
627  *write_to = value;
628  return 0;
629 }
630 
632  int width, const char *name,
633  const int *subscripts, uint32_t *write_to,
634  uint32_t range_min, uint32_t range_max)
635 {
636  return cbs_read_unsigned(ctx, gbc, width, name, subscripts,
637  write_to, range_min, range_max);
638 }
639 
641  int width, const char *name, uint32_t *write_to)
642 {
643  return cbs_read_unsigned(ctx, gbc, width, name, NULL,
644  write_to, 0, UINT32_MAX);
645 }
646 
648  int width, const char *name,
649  const int *subscripts, uint32_t value,
650  uint32_t range_min, uint32_t range_max)
651 {
653 
654  av_assert0(width > 0 && width <= 32);
655 
656  if (value < range_min || value > range_max) {
657  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
658  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
659  name, value, range_min, range_max);
660  return AVERROR_INVALIDDATA;
661  }
662 
663  if (put_bits_left(pbc) < width)
664  return AVERROR(ENOSPC);
665 
666  if (width < 32)
667  put_bits(pbc, width, value);
668  else
669  put_bits32(pbc, value);
670 
672 
673  return 0;
674 }
675 
677  int width, const char *name, uint32_t value)
678 {
679  return ff_cbs_write_unsigned(ctx, pbc, width, name, NULL,
680  value, 0, MAX_UINT_BITS(width));
681 }
682 
684  int width, const char *name,
685  const int *subscripts, int32_t *write_to,
686  int32_t range_min, int32_t range_max)
687 {
688  int32_t value;
689 
691 
692  av_assert0(width > 0 && width <= 32);
693 
694  if (get_bits_left(gbc) < width) {
695  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid value at "
696  "%s: bitstream ended.\n", name);
697  return AVERROR_INVALIDDATA;
698  }
699 
700  value = get_sbits_long(gbc, width);
701 
703 
704  if (value < range_min || value > range_max) {
705  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
706  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
707  name, value, range_min, range_max);
708  return AVERROR_INVALIDDATA;
709  }
710 
711  *write_to = value;
712  return 0;
713 }
714 
716  int width, const char *name,
717  const int *subscripts, int32_t value,
718  int32_t range_min, int32_t range_max)
719 {
721 
722  av_assert0(width > 0 && width <= 32);
723 
724  if (value < range_min || value > range_max) {
725  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
726  "%"PRId32", but must be in [%"PRId32",%"PRId32"].\n",
727  name, value, range_min, range_max);
728  return AVERROR_INVALIDDATA;
729  }
730 
731  if (put_bits_left(pbc) < width)
732  return AVERROR(ENOSPC);
733 
734  if (width < 32)
735  put_sbits(pbc, width, value);
736  else
737  put_bits32(pbc, value);
738 
740 
741  return 0;
742 }
743 
744 
746  int position)
747 {
748  CodedBitstreamUnit *units;
749 
750  if (frag->nb_units < frag->nb_units_allocated) {
751  units = frag->units;
752 
753  if (position < frag->nb_units)
754  memmove(units + position + 1, units + position,
755  (frag->nb_units - position) * sizeof(*units));
756  } else {
757  units = av_malloc_array(frag->nb_units*2 + 1, sizeof(*units));
758  if (!units)
759  return AVERROR(ENOMEM);
760 
761  frag->nb_units_allocated = 2*frag->nb_units_allocated + 1;
762 
763  if (position > 0)
764  memcpy(units, frag->units, position * sizeof(*units));
765 
766  if (position < frag->nb_units)
767  memcpy(units + position + 1, frag->units + position,
768  (frag->nb_units - position) * sizeof(*units));
769  }
770 
771  memset(units + position, 0, sizeof(*units));
772 
773  if (units != frag->units) {
774  av_free(frag->units);
775  frag->units = units;
776  }
777 
778  ++frag->nb_units;
779 
780  return 0;
781 }
782 
784  int position,
786  void *content,
787  void *content_ref)
788 {
789  CodedBitstreamUnit *unit;
790  int err;
791 
792  if (position == -1)
793  position = frag->nb_units;
794  av_assert0(position >= 0 && position <= frag->nb_units);
795 
796  err = cbs_insert_unit(frag, position);
797  if (err < 0)
798  return err;
799 
800  if (content_ref) {
801  // Create our own reference out of the user-supplied one.
802  content_ref = ff_refstruct_ref(content_ref);
803  }
804 
805  unit = &frag->units[position];
806  unit->type = type;
807  unit->content = content;
808  unit->content_ref = content_ref;
809 
810  return 0;
811 }
812 
815  uint8_t *data, size_t data_size,
816  AVBufferRef *data_buf,
817  int position)
818 {
819  CodedBitstreamUnit *unit;
820  AVBufferRef *data_ref;
821  int err;
822 
823  av_assert0(position >= 0 && position <= frag->nb_units);
824 
825  if (data_buf)
826  data_ref = av_buffer_ref(data_buf);
827  else
828  data_ref = av_buffer_create(data, data_size, NULL, NULL, 0);
829  if (!data_ref) {
830  if (!data_buf)
831  av_free(data);
832  return AVERROR(ENOMEM);
833  }
834 
835  err = cbs_insert_unit(frag, position);
836  if (err < 0) {
837  av_buffer_unref(&data_ref);
838  return err;
839  }
840 
841  unit = &frag->units[position];
842  unit->type = type;
843  unit->data = data;
844  unit->data_size = data_size;
845  unit->data_ref = data_ref;
846 
847  return 0;
848 }
849 
852  uint8_t *data, size_t data_size,
853  AVBufferRef *data_buf)
854 {
855  return cbs_insert_unit_data(frag, type,
856  data, data_size, data_buf,
857  frag->nb_units);
858 }
859 
861  int position)
862 {
863  av_assert0(0 <= position && position < frag->nb_units
864  && "Unit to be deleted not in fragment.");
865 
866  cbs_unit_uninit(&frag->units[position]);
867 
868  --frag->nb_units;
869 
870  if (frag->nb_units > 0)
871  memmove(frag->units + position,
872  frag->units + position + 1,
873  (frag->nb_units - position) * sizeof(*frag->units));
874 }
875 
876 static void cbs_default_free_unit_content(FFRefStructOpaque opaque, void *content)
877 {
878  const CodedBitstreamUnitTypeDescriptor *desc = opaque.c;
879 
880  for (int i = 0; i < desc->type.ref.nb_offsets; i++) {
881  void **ptr = (void**)((char*)content + desc->type.ref.offsets[i]);
882  av_buffer_unref((AVBufferRef**)(ptr + 1));
883  }
884 }
885 
888  CodedBitstreamUnit *unit)
889 {
891  int i, j;
892 
893  if (!ctx->codec->unit_types)
894  return NULL;
895 
896  for (i = 0;; i++) {
897  desc = &ctx->codec->unit_types[i];
898  if (desc->nb_unit_types == 0)
899  break;
900  if (desc->nb_unit_types == CBS_UNIT_TYPE_RANGE) {
901  if (unit->type >= desc->unit_type.range.start &&
902  unit->type <= desc->unit_type.range.end)
903  return desc;
904  } else {
905  for (j = 0; j < desc->nb_unit_types; j++) {
906  if (desc->unit_type.list[j] == unit->type)
907  return desc;
908  }
909  }
910  }
911  return NULL;
912 }
913 
915 {
916  return ff_refstruct_alloc_ext_c(desc->content_size, 0,
917  (FFRefStructOpaque){ .c = desc },
918  desc->content_type == CBS_CONTENT_TYPE_COMPLEX
919  ? desc->type.complex.content_free
921 }
922 
924  CodedBitstreamUnit *unit)
925 {
927 
928  av_assert0(!unit->content && !unit->content_ref);
929 
931  if (!desc)
932  return AVERROR(ENOSYS);
933 
935  if (!unit->content_ref)
936  return AVERROR(ENOMEM);
937  unit->content = unit->content_ref;
938 
939  return 0;
940 }
941 
942 static int cbs_clone_noncomplex_unit_content(void **clonep,
943  const CodedBitstreamUnit *unit,
945 {
946  const uint8_t *src;
947  uint8_t *copy;
948  int err, i;
949 
950  av_assert0(unit->content);
951  src = unit->content;
952 
954  if (!copy)
955  return AVERROR(ENOMEM);
956  memcpy(copy, src, desc->content_size);
957  for (int i = 0; i < desc->type.ref.nb_offsets; i++) {
958  void **ptr = (void**)(copy + desc->type.ref.offsets[i]);
959  /* Zero all the AVBufferRefs as they are owned by src. */
960  *(ptr + 1) = NULL;
961  }
962 
963  for (i = 0; i < desc->type.ref.nb_offsets; i++) {
964  const uint8_t *const *src_ptr = (const uint8_t* const*)(src + desc->type.ref.offsets[i]);
965  const AVBufferRef *src_buf = *(AVBufferRef**)(src_ptr + 1);
966  uint8_t **copy_ptr = (uint8_t**)(copy + desc->type.ref.offsets[i]);
967  AVBufferRef **copy_buf = (AVBufferRef**)(copy_ptr + 1);
968 
969  if (!*src_ptr) {
970  av_assert0(!src_buf);
971  continue;
972  }
973  if (!src_buf) {
974  // We can't handle a non-refcounted pointer here - we don't
975  // have enough information to handle whatever structure lies
976  // at the other end of it.
977  err = AVERROR(EINVAL);
978  goto fail;
979  }
980 
981  *copy_buf = av_buffer_ref(src_buf);
982  if (!*copy_buf) {
983  err = AVERROR(ENOMEM);
984  goto fail;
985  }
986  }
987  *clonep = copy;
988 
989  return 0;
990 
991 fail:
993  return err;
994 }
995 
996 /*
997  * On success, unit->content and unit->content_ref are updated with
998  * the new content; unit is untouched on failure.
999  * Any old content_ref is simply overwritten and not freed.
1000  */
1002  CodedBitstreamUnit *unit)
1003 {
1005  void *new_content;
1006  int err;
1007 
1008  desc = cbs_find_unit_type_desc(ctx, unit);
1009  if (!desc)
1010  return AVERROR(ENOSYS);
1011 
1012  switch (desc->content_type) {
1014  err = cbs_clone_noncomplex_unit_content(&new_content, unit, desc);
1015  break;
1016 
1018  if (!desc->type.complex.content_clone)
1019  return AVERROR_PATCHWELCOME;
1020  err = desc->type.complex.content_clone(&new_content, unit);
1021  break;
1022 
1023  default:
1024  av_assert0(0 && "Invalid content type.");
1025  }
1026 
1027  if (err < 0)
1028  return err;
1029 
1030  unit->content_ref = new_content;
1031  unit->content = new_content;
1032  return 0;
1033 }
1034 
1036  CodedBitstreamUnit *unit)
1037 {
1038  av_assert0(unit->content);
1039  if (unit->content_ref)
1040  return 0;
1041  return cbs_clone_unit_content(ctx, unit);
1042 }
1043 
1045  CodedBitstreamUnit *unit)
1046 {
1047  void *ref = unit->content_ref;
1048  int err;
1049 
1050  av_assert0(unit->content);
1051  if (ref && ff_refstruct_exclusive(ref))
1052  return 0;
1053 
1054  err = cbs_clone_unit_content(ctx, unit);
1055  if (err < 0)
1056  return err;
1058  return 0;
1059 }
1060 
1062  CodedBitstreamFragment *frag,
1063  enum AVDiscard skip,
1064  int flags)
1065 {
1066  if (!ctx->codec->discarded_unit)
1067  return;
1068 
1069  for (int i = frag->nb_units - 1; i >= 0; i--) {
1070  if (ctx->codec->discarded_unit(ctx, &frag->units[i], skip)) {
1071  // discard all units
1072  if (!(flags & DISCARD_FLAG_KEEP_NON_VCL)) {
1073  ff_cbs_fragment_free(frag);
1074  return;
1075  }
1076 
1077  ff_cbs_delete_unit(frag, i);
1078  }
1079  }
1080 }
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
CodedBitstreamUnit::content_ref
void * content_ref
If content is reference counted, a RefStruct reference backing content.
Definition: cbs.h:112
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1654
ff_refstruct_ref
void * ff_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
AVERROR
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
opt.h
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ff_cbs_fragment_free
av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:186
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ff_cbs_read_extradata
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:286
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:107
cbs_fill_fragment_data
static int cbs_fill_fragment_data(CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Definition: cbs.c:237
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
ff_cbs_read_packet_side_data
int ff_cbs_read_packet_side_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Definition: cbs.c:312
cbs_read_data
static int cbs_read_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, AVBufferRef *buf, const uint8_t *data, size_t size, int header)
Definition: cbs.c:257
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
ff_cbs_type_vp9
const CodedBitstreamType ff_cbs_type_vp9
Definition: cbs_vp9.c:602
ff_cbs_fragment_reset
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
Definition: cbs.c:172
AVPacket::data
uint8_t * data
Definition: packet.h:524
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
data
const char data[16]
Definition: mxf.c:148
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
cbs.h
ff_refstruct_alloc_ext_c
void * ff_refstruct_alloc_ext_c(size_t size, unsigned flags, FFRefStructOpaque opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
Allocate a refcounted object of usable size size managed via the RefStruct API.
Definition: refstruct.c:102
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:70
ff_cbs_close
av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:142
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
ff_cbs_write_unsigned
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:647
DISCARD_FLAG_KEEP_NON_VCL
@ DISCARD_FLAG_KEEP_NON_VCL
keep non-vcl units even if the picture has been dropped.
Definition: cbs.h:507
ff_cbs_trace_header
void ff_cbs_trace_header(CodedBitstreamContext *ctx, const char *name)
Definition: cbs.c:499
fail
#define fail()
Definition: checkasm.h:182
GetBitContext
Definition: get_bits.h:108
ff_cbs_read
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:325
ff_cbs_trace_read_log
void ff_cbs_trace_read_log(void *trace_context, GetBitContext *gbc, int length, const char *str, const int *subscripts, int64_t value)
Helper function for read tracing which formats the syntax element and logs the result.
Definition: cbs.c:508
CBS_CONTENT_TYPE_INTERNAL_REFS
@ CBS_CONTENT_TYPE_INTERNAL_REFS
Definition: cbs_internal.h:38
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:125
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1925
ff_cbs_type_av1
const CodedBitstreamType ff_cbs_type_av1
Definition: cbs_av1.c:1285
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
CodedBitstreamUnit::data
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:81
cbs_write_unit_data
static int cbs_write_unit_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:355
ff_cbs_write_extradata
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:445
ff_cbs_make_unit_writable
int ff_cbs_make_unit_writable(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Make the content of a unit writable so that internal fields can be modified.
Definition: cbs.c:1044
refstruct.h
ff_refstruct_exclusive
int ff_refstruct_exclusive(const void *obj)
Check whether the reference count of an object managed via this API is 1.
Definition: refstruct.c:174
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:168
avassert.h
CodedBitstreamUnitTypeDescriptor
Definition: cbs_internal.h:56
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_cbs_type_mpeg2
const CodedBitstreamType ff_cbs_type_mpeg2
Definition: cbs_mpeg2.c:427
cbs_unit_uninit
static void cbs_unit_uninit(CodedBitstreamUnit *unit)
Definition: cbs.c:161
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:122
cbs_alloc_content
static void * cbs_alloc_content(const CodedBitstreamUnitTypeDescriptor *desc)
Definition: cbs.c:914
width
#define width
ff_cbs_write_packet
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:474
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:135
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
cbs_insert_unit_data
static int cbs_insert_unit_data(CodedBitstreamFragment *frag, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf, int position)
Definition: cbs.c:813
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_cbs_append_unit_data
int ff_cbs_append_unit_data(CodedBitstreamFragment *frag, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Add a new unit to a fragment with the given data bitstream.
Definition: cbs.c:850
cbs_internal.h
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:392
CodedBitstreamFragment::data_bit_padding
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:139
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:196
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
PutBitContext
Definition: put_bits.h:50
CBS_TRACE_WRITE_END
#define CBS_TRACE_WRITE_END()
Definition: cbs_internal.h:254
cbs_type_table
static const CodedBitstreamType *const cbs_type_table[]
Definition: cbs.c:35
ff_cbs_trace_write_log
void ff_cbs_trace_write_log(void *trace_context, PutBitContext *pbc, int length, const char *str, const int *subscripts, int64_t value)
Helper function for write tracing which formats the syntax element and logs the result.
Definition: cbs.c:566
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:507
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:53
CBS_UNIT_TYPE_RANGE
@ CBS_UNIT_TYPE_RANGE
Definition: cbs_internal.h:53
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_buffer_unref
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:139
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
AV_CODEC_ID_H266
#define AV_CODEC_ID_H266
Definition: codec_id.h:251
ff_cbs_all_codec_ids
enum AVCodecID ff_cbs_all_codec_ids[]
Table of all supported codec IDs.
Definition: cbs.c:62
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
CodedBitstreamUnit::data_size
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:86
cbs_clone_unit_content
static int cbs_clone_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:1001
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:368
ff_cbs_read_simple_unsigned
int ff_cbs_read_simple_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, uint32_t *write_to)
Definition: cbs.c:640
cbs_find_unit_type_desc
static const CodedBitstreamUnitTypeDescriptor * cbs_find_unit_type_desc(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs.c:887
cbs_default_free_unit_content
static void cbs_default_free_unit_content(FFRefStructOpaque opaque, void *content)
Definition: cbs.c:876
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVPacket::size
int size
Definition: packet.h:525
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
size
int size
Definition: twinvq_data.h:10344
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:128
av_reallocp
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:188
CodedBitstreamUnit::data_bit_padding
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:92
ff_cbs_type_jpeg
const CodedBitstreamType ff_cbs_type_jpeg
Definition: cbs_jpeg.c:436
CBS_CONTENT_TYPE_COMPLEX
@ CBS_CONTENT_TYPE_COMPLEX
Definition: cbs_internal.h:41
header
static const uint8_t header[24]
Definition: sdr2.c:68
buffer.h
ff_cbs_write_signed
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:715
CodedBitstreamType
Definition: cbs_internal.h:102
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
ff_cbs_read_signed
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:683
ff_cbs_discard_units
void ff_cbs_discard_units(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, enum AVDiscard skip, int flags)
Discard units accroding to 'skip'.
Definition: cbs.c:1061
ff_cbs_read_extradata_from_codec
int ff_cbs_read_extradata_from_codec(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecContext *avctx)
Definition: cbs.c:295
cbs_clone_noncomplex_unit_content
static int cbs_clone_noncomplex_unit_content(void **clonep, const CodedBitstreamUnit *unit, const CodedBitstreamUnitTypeDescriptor *desc)
Definition: cbs.c:942
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
CodedBitstreamUnit::data_ref
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:98
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
av_always_inline
#define av_always_inline
Definition: attributes.h:49
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
ff_cbs_type_vp8
const CodedBitstreamType ff_cbs_type_vp8
Definition: cbs_vp8.c:374
ff_cbs_make_unit_refcounted
int ff_cbs_make_unit_refcounted(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Make the content of a unit refcounted.
Definition: cbs.c:1035
ff_cbs_read_unsigned
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:631
ff_cbs_write_fragment_data
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:409
cbs_insert_unit
static int cbs_insert_unit(CodedBitstreamFragment *frag, int position)
Definition: cbs.c:745
CodedBitstreamFragment::nb_units_allocated
int nb_units_allocated
Number of allocated units.
Definition: cbs.h:160
avcodec.h
ret
ret
Definition: filter_design.txt:187
ff_cbs_alloc_unit_content
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Allocate a new internal content buffer matching the type of the unit.
Definition: cbs.c:923
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AVCodecContext
main external API structure.
Definition: avcodec.h:445
ff_cbs_write_simple_unsigned
int ff_cbs_write_simple_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, uint32_t value)
Definition: cbs.c:676
CodedBitstreamUnitType
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:47
cbs_alloc_unit_data
static int cbs_alloc_unit_data(CodedBitstreamUnit *unit, size_t size)
Allocate a new internal data buffer of the given size in the unit.
Definition: cbs.c:338
AV_CODEC_ID_H265
#define AV_CODEC_ID_H265
Definition: codec_id.h:227
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ff_cbs_read_packet
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:304
desc
const char * desc
Definition: libsvtav1.c:79
mem.h
FFRefStructOpaque::c
const void * c
Definition: refstruct.h:60
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
ff_cbs_init
av_cold 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:90
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
ff_cbs_type_h266
const CodedBitstreamType ff_cbs_type_h266
Definition: cbs_h2645.c:2072
AVPacket
This structure stores compressed data.
Definition: packet.h:501
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
int32_t
int32_t
Definition: audioconvert.c:56
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_cbs_type_h264
const CodedBitstreamType ff_cbs_type_h264
Definition: cbs_h2645.c:2038
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
CodedBitstreamFragment::data_ref
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:145
cbs_read_fragment_content
static int cbs_read_fragment_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs.c:194
ff_cbs_flush
av_cold void ff_cbs_flush(CodedBitstreamContext *ctx)
Reset all internal state in a context.
Definition: cbs.c:136
AVDiscard
AVDiscard
Definition: defs.h:210
get_sbits_long
static int get_sbits_long(GetBitContext *s, int n)
Read 0-32 bits as a signed integer.
Definition: get_bits.h:471
ff_cbs_type_h265
const CodedBitstreamType ff_cbs_type_h265
Definition: cbs_h2645.c:2055
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
CBS_TRACE_READ_START
#define CBS_TRACE_READ_START()
Definition: cbs_internal.h:208
snprintf
#define snprintf
Definition: snprintf.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:153
ff_cbs_delete_unit
void ff_cbs_delete_unit(CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:860
cbs_read_unsigned
static av_always_inline int 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:596
CBS_TRACE_READ_END
#define CBS_TRACE_READ_END()
Definition: cbs_internal.h:216
CBS_TRACE_WRITE_START
#define CBS_TRACE_WRITE_START()
Definition: cbs_internal.h:246