FFmpeg  4.2.3
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; \
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; \
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; \
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; \
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 WRITE
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  PutBitContext *pbc)
533 {
534  VP9RawFrame *frame = unit->content;
535  int err;
536 
537  err = cbs_vp9_write_frame(ctx, pbc, frame);
538  if (err < 0)
539  return err;
540 
541  // Frame must be byte-aligned.
542  av_assert0(put_bits_count(pbc) % 8 == 0);
543 
544  if (frame->data) {
545  if (frame->data_size > put_bits_left(pbc) / 8)
546  return AVERROR(ENOSPC);
547 
548  flush_put_bits(pbc);
549  memcpy(put_bits_ptr(pbc), frame->data, frame->data_size);
550  skip_put_bytes(pbc, frame->data_size);
551  }
552 
553  return 0;
554 }
555 
558 {
559  int err;
560 
561  if (frag->nb_units == 1) {
562  // Output is just the content of the single frame.
563 
564  CodedBitstreamUnit *frame = &frag->units[0];
565 
566  frag->data_ref = av_buffer_ref(frame->data_ref);
567  if (!frag->data_ref)
568  return AVERROR(ENOMEM);
569 
570  frag->data = frame->data;
571  frag->data_size = frame->data_size;
572 
573  } else {
574  // Build superframe out of frames.
575 
577  PutBitContext pbc;
578  AVBufferRef *ref;
579  uint8_t *data;
580  size_t size, max, pos;
581  int i, size_len;
582 
583  if (frag->nb_units > 8) {
584  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
585  "make superframe: %d.\n", frag->nb_units);
586  return AVERROR(EINVAL);
587  }
588 
589  max = 0;
590  for (i = 0; i < frag->nb_units; i++)
591  if (max < frag->units[i].data_size)
592  max = frag->units[i].data_size;
593 
594  if (max < 2)
595  size_len = 1;
596  else
597  size_len = av_log2(max) / 8 + 1;
598  av_assert0(size_len <= 4);
599 
601  sfi.bytes_per_framesize_minus_1 = size_len - 1;
602  sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
603 
604  size = 2;
605  for (i = 0; i < frag->nb_units; i++) {
606  size += size_len + frag->units[i].data_size;
607  sfi.frame_sizes[i] = frag->units[i].data_size;
608  }
609 
611  if (!ref)
612  return AVERROR(ENOMEM);
613  data = ref->data;
614  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
615 
616  pos = 0;
617  for (i = 0; i < frag->nb_units; i++) {
618  av_assert0(size - pos > frag->units[i].data_size);
619  memcpy(data + pos, frag->units[i].data,
620  frag->units[i].data_size);
621  pos += frag->units[i].data_size;
622  }
623  av_assert0(size - pos == 2 + frag->nb_units * size_len);
624 
625  init_put_bits(&pbc, data + pos, size - pos);
626 
627  err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
628  if (err < 0) {
629  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
630  "superframe index.\n");
631  av_buffer_unref(&ref);
632  return err;
633  }
634 
635  av_assert0(put_bits_left(&pbc) == 0);
636  flush_put_bits(&pbc);
637 
638  frag->data_ref = ref;
639  frag->data = data;
640  frag->data_size = size;
641  }
642 
643  return 0;
644 }
645 
648 
649  .priv_data_size = sizeof(CodedBitstreamVP9Context),
650 
651  .split_fragment = &cbs_vp9_split_fragment,
652  .read_unit = &cbs_vp9_read_unit,
653  .write_unit = &cbs_vp9_write_unit,
654  .assemble_fragment = &cbs_vp9_assemble_fragment,
655 };
const char * name
Definition: avisynth_c.h:867
#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:379
#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:556
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:644
AVBufferRef * data_ref
Definition: cbs_vp9.h:169
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int trace_enable
Enable trace output during read/write operations.
Definition: cbs.h:206
uint8_t
static int cbs_vp9_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_vp9.c:530
static AVFrame * frame
const char data[16]
Definition: mxf.c:91
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define max(a, b)
Definition: cuda_runtime.h:33
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_allocated.
Definition: cbs.h:162
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:759
#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:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:324
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().
uint8_t bits
Definition: vp3data.h:202
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:173
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
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:333
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
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:498
double value
Definition: eval.c:98
Context structure for coded bitstream operations.
Definition: cbs.h:168
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
enum AVCodecID codec_id
Definition: cbs_internal.h:29
const CodedBitstreamType ff_cbs_type_vp9
Definition: cbs_vp9.c:646
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
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:790
int len
#define av_freep(p)
static int cbs_vp9_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_vp9.c:490
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:435
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