FFmpeg  4.1.5
cbs_vp9.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 "libavutil/avassert.h"
20 
21 #include "cbs.h"
22 #include "cbs_internal.h"
23 #include "cbs_vp9.h"
24 #include "internal.h"
25 
26 
28  int width, const char *name,
29  const int *subscripts, int32_t *write_to)
30 {
31  uint32_t magnitude;
32  int position, sign;
33  int32_t value;
34 
35  if (ctx->trace_enable)
36  position = get_bits_count(gbc);
37 
38  if (get_bits_left(gbc) < width + 1) {
39  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid signed value at "
40  "%s: bitstream ended.\n", name);
41  return AVERROR_INVALIDDATA;
42  }
43 
44  magnitude = get_bits(gbc, width);
45  sign = get_bits1(gbc);
46  value = sign ? -(int32_t)magnitude : magnitude;
47 
48  if (ctx->trace_enable) {
49  char bits[33];
50  int i;
51  for (i = 0; i < width; i++)
52  bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
53  bits[i] = sign ? '1' : '0';
54  bits[i + 1] = 0;
55 
56  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
57  bits, value);
58  }
59 
60  *write_to = value;
61  return 0;
62 }
63 
65  int width, const char *name,
66  const int *subscripts, int32_t value)
67 {
68  uint32_t magnitude;
69  int sign;
70 
71  if (put_bits_left(pbc) < width + 1)
72  return AVERROR(ENOSPC);
73 
74  sign = value < 0;
75  magnitude = sign ? -value : value;
76 
77  if (ctx->trace_enable) {
78  char bits[33];
79  int i;
80  for (i = 0; i < width; i++)
81  bits[i] = magnitude >> (width - i - 1) & 1 ? '1' : '0';
82  bits[i] = sign ? '1' : '0';
83  bits[i + 1] = 0;
84 
86  name, subscripts, bits, value);
87  }
88 
89  put_bits(pbc, width, magnitude);
90  put_bits(pbc, 1, sign);
91 
92  return 0;
93 }
94 
96  uint32_t range_min, uint32_t range_max,
97  const char *name, uint32_t *write_to)
98 {
99  uint32_t value;
100  int position, i;
101  char bits[8];
102 
103  av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
104  if (ctx->trace_enable)
105  position = get_bits_count(gbc);
106 
107  for (i = 0, value = range_min; value < range_max;) {
108  if (get_bits_left(gbc) < 1) {
109  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
110  "%s: bitstream ended.\n", name);
111  return AVERROR_INVALIDDATA;
112  }
113  if (get_bits1(gbc)) {
114  bits[i++] = '1';
115  ++value;
116  } else {
117  bits[i++] = '0';
118  break;
119  }
120  }
121 
122  if (ctx->trace_enable) {
123  bits[i] = 0;
124  ff_cbs_trace_syntax_element(ctx, position, name, NULL, bits, value);
125  }
126 
127  *write_to = value;
128  return 0;
129 }
130 
132  uint32_t range_min, uint32_t range_max,
133  const char *name, uint32_t value)
134 {
135  int len;
136 
137  av_assert0(range_min <= range_max && range_max - range_min < 8);
138  if (value < range_min || value > range_max) {
139  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
140  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
141  name, value, range_min, range_max);
142  return AVERROR_INVALIDDATA;
143  }
144 
145  if (value == range_max)
146  len = range_max - range_min;
147  else
148  len = value - range_min + 1;
149  if (put_bits_left(pbc) < len)
150  return AVERROR(ENOSPC);
151 
152  if (ctx->trace_enable) {
153  char bits[8];
154  int i;
155  for (i = 0; i < len; i++) {
156  if (range_min + i == value)
157  bits[i] = '0';
158  else
159  bits[i] = '1';
160  }
161  bits[i] = 0;
163  name, NULL, bits, value);
164  }
165 
166  if (len > 0)
167  put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
168 
169  return 0;
170 }
171 
173  int width, const char *name,
174  const int *subscripts, uint32_t *write_to)
175 {
176  uint32_t value;
177  int position, b;
178 
179  av_assert0(width % 8 == 0);
180 
181  if (ctx->trace_enable)
182  position = get_bits_count(gbc);
183 
184  if (get_bits_left(gbc) < width) {
185  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid le value at "
186  "%s: bitstream ended.\n", name);
187  return AVERROR_INVALIDDATA;
188  }
189 
190  value = 0;
191  for (b = 0; b < width; b += 8)
192  value |= get_bits(gbc, 8) << b;
193 
194  if (ctx->trace_enable) {
195  char bits[33];
196  int i;
197  for (b = 0; b < width; b += 8)
198  for (i = 0; i < 8; i++)
199  bits[b + i] = value >> (b + i) & 1 ? '1' : '0';
200  bits[b] = 0;
201 
202  ff_cbs_trace_syntax_element(ctx, position, name, subscripts,
203  bits, value);
204  }
205 
206  *write_to = value;
207  return 0;
208 }
209 
211  int width, const char *name,
212  const int *subscripts, uint32_t value)
213 {
214  int b;
215 
216  av_assert0(width % 8 == 0);
217 
218  if (put_bits_left(pbc) < width)
219  return AVERROR(ENOSPC);
220 
221  if (ctx->trace_enable) {
222  char bits[33];
223  int i;
224  for (b = 0; b < width; b += 8)
225  for (i = 0; i < 8; i++)
226  bits[b + i] = value >> (b + i) & 1 ? '1' : '0';
227  bits[b] = 0;
228 
230  name, subscripts, bits, value);
231  }
232 
233  for (b = 0; b < width; b += 8)
234  put_bits(pbc, 8, value >> b & 0xff);
235 
236  return 0;
237 }
238 
239 #define HEADER(name) do { \
240  ff_cbs_trace_header(ctx, name); \
241  } while (0)
242 
243 #define CHECK(call) do { \
244  err = (call); \
245  if (err < 0) \
246  return err; \
247  } while (0)
248 
249 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
250 #define FUNC_VP9(rw, name) FUNC_NAME(rw, vp9, name)
251 #define FUNC(name) FUNC_VP9(READWRITE, name)
252 
253 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
254 
255 #define f(width, name) \
256  xf(width, name, current->name, 0)
257 #define s(width, name) \
258  xs(width, name, current->name, 0)
259 #define fs(width, name, subs, ...) \
260  xf(width, name, current->name, subs, __VA_ARGS__)
261 #define ss(width, name, subs, ...) \
262  xs(width, name, current->name, subs, __VA_ARGS__)
263 
264 
265 #define READ
266 #define READWRITE read
267 #define RWContext GetBitContext
268 
269 #define xf(width, name, var, subs, ...) do { \
270  uint32_t value = 0; \
271  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
272  SUBSCRIPTS(subs, __VA_ARGS__), \
273  &value, 0, (1 << width) - 1)); \
274  var = value; \
275  } while (0)
276 #define xs(width, name, var, subs, ...) do { \
277  int32_t value = 0; \
278  CHECK(cbs_vp9_read_s(ctx, rw, width, #name, \
279  SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
280  var = value; \
281  } while (0)
282 
283 
284 #define increment(name, min, max) do { \
285  uint32_t value = 0; \
286  CHECK(cbs_vp9_read_increment(ctx, rw, min, max, #name, &value)); \
287  current->name = value; \
288  } while (0)
289 
290 #define fle(width, name, subs, ...) do { \
291  CHECK(cbs_vp9_read_le(ctx, rw, width, #name, \
292  SUBSCRIPTS(subs, __VA_ARGS__), &current->name)); \
293  } while (0)
294 
295 #define delta_q(name) do { \
296  uint8_t delta_coded; \
297  int8_t delta_q; \
298  xf(1, name.delta_coded, delta_coded, 0); \
299  if (delta_coded) \
300  xs(4, name.delta_q, delta_q, 0); \
301  else \
302  delta_q = 0; \
303  current->name = delta_q; \
304  } while (0)
305 
306 #define prob(name, subs, ...) do { \
307  uint8_t prob_coded; \
308  uint8_t prob; \
309  xf(1, name.prob_coded, prob_coded, subs, __VA_ARGS__); \
310  if (prob_coded) \
311  xf(8, name.prob, prob, subs, __VA_ARGS__); \
312  else \
313  prob = 255; \
314  current->name = prob; \
315  } while (0)
316 
317 #define fixed(width, name, value) do { \
318  av_unused uint32_t fixed_value = value; \
319  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
320  0, &fixed_value, value, value)); \
321  } while (0)
322 
323 #define infer(name, value) do { \
324  current->name = value; \
325  } while (0)
326 
327 #define byte_alignment(rw) (get_bits_count(rw) % 8)
328 
329 #include "cbs_vp9_syntax_template.c"
330 
331 #undef READ
332 #undef READWRITE
333 #undef RWContext
334 #undef xf
335 #undef xs
336 #undef increment
337 #undef fle
338 #undef delta_q
339 #undef prob
340 #undef fixed
341 #undef infer
342 #undef byte_alignment
343 
344 
345 #define WRITE
346 #define READWRITE write
347 #define RWContext PutBitContext
348 
349 #define xf(width, name, var, subs, ...) do { \
350  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
351  SUBSCRIPTS(subs, __VA_ARGS__), \
352  var, 0, (1 << width) - 1)); \
353  } while (0)
354 #define xs(width, name, var, subs, ...) do { \
355  CHECK(cbs_vp9_write_s(ctx, rw, width, #name, \
356  SUBSCRIPTS(subs, __VA_ARGS__), var)); \
357  } while (0)
358 
359 #define increment(name, min, max) do { \
360  CHECK(cbs_vp9_write_increment(ctx, rw, min, max, #name, current->name)); \
361  } while (0)
362 
363 #define fle(width, name, subs, ...) do { \
364  CHECK(cbs_vp9_write_le(ctx, rw, width, #name, \
365  SUBSCRIPTS(subs, __VA_ARGS__), current->name)); \
366  } while (0)
367 
368 #define delta_q(name) do { \
369  xf(1, name.delta_coded, !!current->name, 0); \
370  if (current->name) \
371  xs(4, name.delta_q, current->name, 0); \
372  } while (0)
373 
374 #define prob(name, subs, ...) do { \
375  xf(1, name.prob_coded, current->name != 255, subs, __VA_ARGS__); \
376  if (current->name != 255) \
377  xf(8, name.prob, current->name, subs, __VA_ARGS__); \
378  } while (0)
379 
380 #define fixed(width, name, value) do { \
381  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
382  0, value, value, value)); \
383  } while (0)
384 
385 #define infer(name, value) do { \
386  if (current->name != (value)) { \
387  av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
388  "%s does not match inferred value: " \
389  "%"PRId64", but should be %"PRId64".\n", \
390  #name, (int64_t)current->name, (int64_t)(value)); \
391  } \
392  } while (0)
393 
394 #define byte_alignment(rw) (put_bits_count(rw) % 8)
395 
396 #include "cbs_vp9_syntax_template.c"
397 
398 #undef READ
399 #undef READWRITE
400 #undef RWContext
401 #undef xf
402 #undef xs
403 #undef increment
404 #undef fle
405 #undef delta_q
406 #undef prob
407 #undef fixed
408 #undef infer
409 #undef byte_alignment
410 
411 
414  int header)
415 {
416  uint8_t superframe_header;
417  int err;
418 
419  if (frag->data_size == 0)
420  return AVERROR_INVALIDDATA;
421 
422  // Last byte in the packet.
423  superframe_header = frag->data[frag->data_size - 1];
424 
425  if ((superframe_header & 0xe0) == 0xc0) {
427  GetBitContext gbc;
428  size_t index_size, pos;
429  int i;
430 
431  index_size = 2 + (((superframe_header & 0x18) >> 3) + 1) *
432  ((superframe_header & 0x07) + 1);
433 
434  if (index_size > frag->data_size)
435  return AVERROR_INVALIDDATA;
436 
437  err = init_get_bits(&gbc, frag->data + frag->data_size - index_size,
438  8 * index_size);
439  if (err < 0)
440  return err;
441 
442  err = cbs_vp9_read_superframe_index(ctx, &gbc, &sfi);
443  if (err < 0)
444  return err;
445 
446  pos = 0;
447  for (i = 0; i <= sfi.frames_in_superframe_minus_1; i++) {
448  if (pos + sfi.frame_sizes[i] + index_size > frag->data_size) {
449  av_log(ctx->log_ctx, AV_LOG_ERROR, "Frame %d too large "
450  "in superframe: %"PRIu32" bytes.\n",
451  i, sfi.frame_sizes[i]);
452  return AVERROR_INVALIDDATA;
453  }
454 
455  err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
456  frag->data + pos,
457  sfi.frame_sizes[i],
458  frag->data_ref);
459  if (err < 0)
460  return err;
461 
462  pos += sfi.frame_sizes[i];
463  }
464  if (pos + index_size != frag->data_size) {
465  av_log(ctx->log_ctx, AV_LOG_WARNING, "Extra padding at "
466  "end of superframe: %"SIZE_SPECIFIER" bytes.\n",
467  frag->data_size - (pos + index_size));
468  }
469 
470  return 0;
471 
472  } else {
473  err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
474  frag->data, frag->data_size,
475  frag->data_ref);
476  if (err < 0)
477  return err;
478  }
479 
480  return 0;
481 }
482 
483 static void cbs_vp9_free_frame(void *unit, uint8_t *content)
484 {
485  VP9RawFrame *frame = (VP9RawFrame*)content;
486  av_buffer_unref(&frame->data_ref);
487  av_freep(&frame);
488 }
489 
491  CodedBitstreamUnit *unit)
492 {
494  GetBitContext gbc;
495  int err, pos;
496 
497  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
498  if (err < 0)
499  return err;
500 
501  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*frame),
503  if (err < 0)
504  return err;
505  frame = unit->content;
506 
507  err = cbs_vp9_read_frame(ctx, &gbc, frame);
508  if (err < 0)
509  return err;
510 
511  pos = get_bits_count(&gbc);
512  av_assert0(pos % 8 == 0);
513  pos /= 8;
514  av_assert0(pos <= unit->data_size);
515 
516  if (pos == unit->data_size) {
517  // No data (e.g. a show-existing-frame frame).
518  } else {
519  frame->data_ref = av_buffer_ref(unit->data_ref);
520  if (!frame->data_ref)
521  return AVERROR(ENOMEM);
522 
523  frame->data = unit->data + pos;
524  frame->data_size = unit->data_size - pos;
525  }
526 
527  return 0;
528 }
529 
531  CodedBitstreamUnit *unit)
532 {
533  CodedBitstreamVP9Context *priv = ctx->priv_data;
534  VP9RawFrame *frame = unit->content;
535  PutBitContext pbc;
536  int err;
537 
538  if (!priv->write_buffer) {
539  // Initial write buffer size is 1MB.
540  priv->write_buffer_size = 1024 * 1024;
541 
542  reallocate_and_try_again:
543  err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
544  if (err < 0) {
545  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
546  "sufficiently large write buffer (last attempt "
547  "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
548  return err;
549  }
550  }
551 
552  init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
553 
554  err = cbs_vp9_write_frame(ctx, &pbc, frame);
555  if (err == AVERROR(ENOSPC)) {
556  priv->write_buffer_size *= 2;
557  goto reallocate_and_try_again;
558  }
559  if (err < 0)
560  return err;
561 
562  // Frame must be byte-aligned.
563  av_assert0(put_bits_count(&pbc) % 8 == 0);
564 
565  unit->data_size = put_bits_count(&pbc) / 8;
566  unit->data_bit_padding = 0;
567  flush_put_bits(&pbc);
568 
569  if (frame->data) {
570  if (unit->data_size + frame->data_size >
571  priv->write_buffer_size) {
572  priv->write_buffer_size *= 2;
573  goto reallocate_and_try_again;
574  }
575 
576  memcpy(priv->write_buffer + unit->data_size,
577  frame->data, frame->data_size);
578  unit->data_size += frame->data_size;
579  }
580 
581  err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
582  if (err < 0)
583  return err;
584 
585  memcpy(unit->data, priv->write_buffer, unit->data_size);
586 
587  return 0;
588 }
589 
592 {
593  int err;
594 
595  if (frag->nb_units == 1) {
596  // Output is just the content of the single frame.
597 
598  CodedBitstreamUnit *frame = &frag->units[0];
599 
600  frag->data_ref = av_buffer_ref(frame->data_ref);
601  if (!frag->data_ref)
602  return AVERROR(ENOMEM);
603 
604  frag->data = frame->data;
605  frag->data_size = frame->data_size;
606 
607  } else {
608  // Build superframe out of frames.
609 
611  PutBitContext pbc;
612  AVBufferRef *ref;
613  uint8_t *data;
614  size_t size, max, pos;
615  int i, size_len;
616 
617  if (frag->nb_units > 8) {
618  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
619  "make superframe: %d.\n", frag->nb_units);
620  return AVERROR(EINVAL);
621  }
622 
623  max = 0;
624  for (i = 0; i < frag->nb_units; i++)
625  if (max < frag->units[i].data_size)
626  max = frag->units[i].data_size;
627 
628  if (max < 2)
629  size_len = 1;
630  else
631  size_len = av_log2(max) / 8 + 1;
632  av_assert0(size_len <= 4);
633 
635  sfi.bytes_per_framesize_minus_1 = size_len - 1;
636  sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
637 
638  size = 2;
639  for (i = 0; i < frag->nb_units; i++) {
640  size += size_len + frag->units[i].data_size;
641  sfi.frame_sizes[i] = frag->units[i].data_size;
642  }
643 
645  if (!ref)
646  return AVERROR(ENOMEM);
647  data = ref->data;
648  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
649 
650  pos = 0;
651  for (i = 0; i < frag->nb_units; i++) {
652  av_assert0(size - pos > frag->units[i].data_size);
653  memcpy(data + pos, frag->units[i].data,
654  frag->units[i].data_size);
655  pos += frag->units[i].data_size;
656  }
657  av_assert0(size - pos == 2 + frag->nb_units * size_len);
658 
659  init_put_bits(&pbc, data + pos, size - pos);
660 
661  err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
662  if (err < 0) {
663  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
664  "superframe index.\n");
665  av_buffer_unref(&ref);
666  return err;
667  }
668 
669  av_assert0(put_bits_left(&pbc) == 0);
670  flush_put_bits(&pbc);
671 
672  frag->data_ref = ref;
673  frag->data = data;
674  frag->data_size = size;
675  }
676 
677  return 0;
678 }
679 
681 {
682  CodedBitstreamVP9Context *priv = ctx->priv_data;
683 
684  av_freep(&priv->write_buffer);
685 }
686 
689 
690  .priv_data_size = sizeof(CodedBitstreamVP9Context),
691 
692  .split_fragment = &cbs_vp9_split_fragment,
693  .read_unit = &cbs_vp9_read_unit,
694  .write_unit = &cbs_vp9_write_unit,
695  .assemble_fragment = &cbs_vp9_assemble_fragment,
696 
697  .close = &cbs_vp9_close,
698 };
const char * name
Definition: avisynth_c.h:775
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
int size
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static int cbs_vp9_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_vp9.c:590
const char * b
Definition: vf_curves.c:116
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:585
AVBufferRef * data_ref
Definition: cbs_vp9.h:169
static void cbs_vp9_close(CodedBitstreamContext *ctx)
Definition: cbs_vp9.c:680
#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:197
uint8_t
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:86
static AVFrame * frame
const char data[16]
Definition: mxf.c:91
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
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:606
Coded bitstream unit structure.
Definition: cbs.h:64
static int cbs_vp9_read_le(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, uint32_t *write_to)
Definition: cbs_vp9.c:172
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
static const uint8_t header[24]
Definition: sdr2.c:67
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units.
Definition: cbs.h:153
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:75
static int cbs_vp9_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc, uint32_t range_min, uint32_t range_max, const char *name, uint32_t value)
Definition: cbs_vp9.c:131
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:686
#define av_log(a,...)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
static int cbs_vp9_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_vp9.c:412
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:814
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
#define AVERROR(e)
Definition: error.h:43
simple assert() macros that are a bit more flexible than ISO C assert().
static int cbs_vp9_write_s(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, const int *subscripts, int32_t value)
Definition: cbs_vp9.c:64
uint8_t superframe_marker
Definition: cbs_vp9.h:173
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
uint8_t bytes_per_framesize_minus_1
Definition: cbs_vp9.h:174
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:164
static int cbs_vp9_read_s(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, int32_t *write_to)
Definition: cbs_vp9.c:27
uint32_t frame_sizes[VP9_MAX_FRAMES_IN_SUPERFRAME]
Definition: cbs_vp9.h:176
#define width
size_t data_size
Definition: cbs_vp9.h:168
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define av_log2
Definition: intmath.h:83
static int cbs_vp9_write_le(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, const int *subscripts, uint32_t value)
Definition: cbs_vp9.c:210
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:163
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
uint8_t * data
The data buffer.
Definition: buffer.h:89
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
double value
Definition: eval.c:98
Context structure for coded bitstream operations.
Definition: cbs.h:159
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:615
uint8_t * write_buffer
Definition: cbs_vp9.h:212
enum AVCodecID codec_id
Definition: cbs_internal.h:29
const CodedBitstreamType ff_cbs_type_vp9
Definition: cbs_vp9.c:687
uint8_t * data
Definition: cbs_vp9.h:167
#define SIZE_SPECIFIER
Definition: internal.h:262
uint8_t frames_in_superframe_minus_1
Definition: cbs_vp9.h:175
void * priv_data
Internal codec-specific data.
Definition: cbs.h:180
A reference to a data buffer.
Definition: buffer.h:81
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:92
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:782
int len
#define av_freep(p)
static int cbs_vp9_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_vp9.c:490
static int cbs_vp9_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_vp9.c:530
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:139
static void cbs_vp9_free_frame(void *unit, uint8_t *content)
Definition: cbs_vp9.c:483
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:376
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:80
static int cbs_vp9_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t range_min, uint32_t range_max, const char *name, uint32_t *write_to)
Definition: cbs_vp9.c:95