FFmpeg
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 #define READ
265 #define READWRITE read
266 #define RWContext GetBitContext
267 
268 #define xf(width, name, var, subs, ...) do { \
269  uint32_t value; \
270  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
271  SUBSCRIPTS(subs, __VA_ARGS__), \
272  &value, 0, (1 << width) - 1)); \
273  var = value; \
274  } while (0)
275 #define xs(width, name, var, subs, ...) do { \
276  int32_t value; \
277  CHECK(cbs_vp9_read_s(ctx, rw, width, #name, \
278  SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
279  var = value; \
280  } while (0)
281 
282 
283 #define increment(name, min, max) do { \
284  uint32_t value; \
285  CHECK(cbs_vp9_read_increment(ctx, rw, min, max, #name, &value)); \
286  current->name = value; \
287  } while (0)
288 
289 #define fle(width, name, subs, ...) do { \
290  CHECK(cbs_vp9_read_le(ctx, rw, width, #name, \
291  SUBSCRIPTS(subs, __VA_ARGS__), &current->name)); \
292  } while (0)
293 
294 #define delta_q(name) do { \
295  uint8_t delta_coded; \
296  int8_t delta_q; \
297  xf(1, name.delta_coded, delta_coded, 0, ); \
298  if (delta_coded) \
299  xs(4, name.delta_q, delta_q, 0, ); \
300  else \
301  delta_q = 0; \
302  current->name = delta_q; \
303  } while (0)
304 
305 #define prob(name, subs, ...) do { \
306  uint8_t prob_coded; \
307  uint8_t prob; \
308  xf(1, name.prob_coded, prob_coded, subs, __VA_ARGS__); \
309  if (prob_coded) \
310  xf(8, name.prob, prob, subs, __VA_ARGS__); \
311  else \
312  prob = 255; \
313  current->name = prob; \
314  } while (0)
315 
316 #define fixed(width, name, value) do { \
317  av_unused uint32_t fixed_value; \
318  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
319  0, &fixed_value, value, value)); \
320  } while (0)
321 
322 #define infer(name, value) do { \
323  current->name = value; \
324  } while (0)
325 
326 #define byte_alignment(rw) (get_bits_count(rw) % 8)
327 
328 #include "cbs_vp9_syntax_template.c"
329 
330 #undef READ
331 #undef READWRITE
332 #undef RWContext
333 #undef xf
334 #undef xs
335 #undef increment
336 #undef fle
337 #undef delta_q
338 #undef prob
339 #undef fixed
340 #undef infer
341 #undef byte_alignment
342 
343 
344 #define WRITE
345 #define READWRITE write
346 #define RWContext PutBitContext
347 
348 #define xf(width, name, var, subs, ...) do { \
349  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
350  SUBSCRIPTS(subs, __VA_ARGS__), \
351  var, 0, (1 << width) - 1)); \
352  } while (0)
353 #define xs(width, name, var, subs, ...) do { \
354  CHECK(cbs_vp9_write_s(ctx, rw, width, #name, \
355  SUBSCRIPTS(subs, __VA_ARGS__), var)); \
356  } while (0)
357 
358 #define increment(name, min, max) do { \
359  CHECK(cbs_vp9_write_increment(ctx, rw, min, max, #name, current->name)); \
360  } while (0)
361 
362 #define fle(width, name, subs, ...) do { \
363  CHECK(cbs_vp9_write_le(ctx, rw, width, #name, \
364  SUBSCRIPTS(subs, __VA_ARGS__), current->name)); \
365  } while (0)
366 
367 #define delta_q(name) do { \
368  xf(1, name.delta_coded, !!current->name, 0, ); \
369  if (current->name) \
370  xs(4, name.delta_q, current->name, 0, ); \
371  } while (0)
372 
373 #define prob(name, subs, ...) do { \
374  xf(1, name.prob_coded, current->name != 255, subs, __VA_ARGS__); \
375  if (current->name != 255) \
376  xf(8, name.prob, current->name, subs, __VA_ARGS__); \
377  } while (0)
378 
379 #define fixed(width, name, value) do { \
380  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
381  0, value, value, value)); \
382  } while (0)
383 
384 #define infer(name, value) do { \
385  if (current->name != (value)) { \
386  av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
387  "%s does not match inferred value: " \
388  "%"PRId64", but should be %"PRId64".\n", \
389  #name, (int64_t)current->name, (int64_t)(value)); \
390  } \
391  } while (0)
392 
393 #define byte_alignment(rw) (put_bits_count(rw) % 8)
394 
395 #include "cbs_vp9_syntax_template.c"
396 
397 #undef WRITE
398 #undef READWRITE
399 #undef RWContext
400 #undef xf
401 #undef xs
402 #undef increment
403 #undef fle
404 #undef delta_q
405 #undef prob
406 #undef fixed
407 #undef infer
408 #undef byte_alignment
409 
410 
413  int header)
414 {
415  uint8_t superframe_header;
416  int err;
417 
418  if (frag->data_size == 0)
419  return AVERROR_INVALIDDATA;
420 
421  // Last byte in the packet.
422  superframe_header = frag->data[frag->data_size - 1];
423 
424  if ((superframe_header & 0xe0) == 0xc0) {
426  GetBitContext gbc;
427  size_t index_size, pos;
428  int i;
429 
430  index_size = 2 + (((superframe_header & 0x18) >> 3) + 1) *
431  ((superframe_header & 0x07) + 1);
432 
433  if (index_size > frag->data_size)
434  return AVERROR_INVALIDDATA;
435 
436  err = init_get_bits(&gbc, frag->data + frag->data_size - index_size,
437  8 * index_size);
438  if (err < 0)
439  return err;
440 
441  err = cbs_vp9_read_superframe_index(ctx, &gbc, &sfi);
442  if (err < 0)
443  return err;
444 
445  pos = 0;
446  for (i = 0; i <= sfi.frames_in_superframe_minus_1; i++) {
447  if (pos + sfi.frame_sizes[i] + index_size > frag->data_size) {
448  av_log(ctx->log_ctx, AV_LOG_ERROR, "Frame %d too large "
449  "in superframe: %"PRIu32" bytes.\n",
450  i, sfi.frame_sizes[i]);
451  return AVERROR_INVALIDDATA;
452  }
453 
454  err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
455  frag->data + pos,
456  sfi.frame_sizes[i],
457  frag->data_ref);
458  if (err < 0)
459  return err;
460 
461  pos += sfi.frame_sizes[i];
462  }
463  if (pos + index_size != frag->data_size) {
464  av_log(ctx->log_ctx, AV_LOG_WARNING, "Extra padding at "
465  "end of superframe: %"SIZE_SPECIFIER" bytes.\n",
466  frag->data_size - (pos + index_size));
467  }
468 
469  return 0;
470 
471  } else {
472  err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
473  frag->data, frag->data_size,
474  frag->data_ref);
475  if (err < 0)
476  return err;
477  }
478 
479  return 0;
480 }
481 
482 static void cbs_vp9_free_frame(void *opaque, uint8_t *content)
483 {
484  VP9RawFrame *frame = (VP9RawFrame*)content;
485  av_buffer_unref(&frame->data_ref);
486  av_freep(&frame);
487 }
488 
490  CodedBitstreamUnit *unit)
491 {
493  GetBitContext gbc;
494  int err, pos;
495 
496  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
497  if (err < 0)
498  return err;
499 
500  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*frame),
502  if (err < 0)
503  return err;
504  frame = unit->content;
505 
506  err = cbs_vp9_read_frame(ctx, &gbc, frame);
507  if (err < 0)
508  return err;
509 
510  pos = get_bits_count(&gbc);
511  av_assert0(pos % 8 == 0);
512  pos /= 8;
513  av_assert0(pos <= unit->data_size);
514 
515  if (pos == unit->data_size) {
516  // No data (e.g. a show-existing-frame frame).
517  } else {
518  frame->data_ref = av_buffer_ref(unit->data_ref);
519  if (!frame->data_ref)
520  return AVERROR(ENOMEM);
521 
522  frame->data = unit->data + pos;
523  frame->data_size = unit->data_size - pos;
524  }
525 
526  return 0;
527 }
528 
530  CodedBitstreamUnit *unit,
531  PutBitContext *pbc)
532 {
533  VP9RawFrame *frame = unit->content;
534  int err;
535 
536  err = cbs_vp9_write_frame(ctx, pbc, frame);
537  if (err < 0)
538  return err;
539 
540  // Frame must be byte-aligned.
541  av_assert0(put_bits_count(pbc) % 8 == 0);
542 
543  if (frame->data) {
544  if (frame->data_size > put_bits_left(pbc) / 8)
545  return AVERROR(ENOSPC);
546 
547  flush_put_bits(pbc);
548  memcpy(put_bits_ptr(pbc), frame->data, frame->data_size);
549  skip_put_bytes(pbc, frame->data_size);
550  }
551 
552  return 0;
553 }
554 
557 {
558  int err;
559 
560  if (frag->nb_units == 1) {
561  // Output is just the content of the single frame.
562 
563  CodedBitstreamUnit *frame = &frag->units[0];
564 
565  frag->data_ref = av_buffer_ref(frame->data_ref);
566  if (!frag->data_ref)
567  return AVERROR(ENOMEM);
568 
569  frag->data = frame->data;
570  frag->data_size = frame->data_size;
571 
572  } else {
573  // Build superframe out of frames.
574 
576  PutBitContext pbc;
577  AVBufferRef *ref;
578  uint8_t *data;
579  size_t size, max, pos;
580  int i, size_len;
581 
582  if (frag->nb_units > 8) {
583  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
584  "make superframe: %d.\n", frag->nb_units);
585  return AVERROR(EINVAL);
586  }
587 
588  max = 0;
589  for (i = 0; i < frag->nb_units; i++)
590  if (max < frag->units[i].data_size)
591  max = frag->units[i].data_size;
592 
593  if (max < 2)
594  size_len = 1;
595  else
596  size_len = av_log2(max) / 8 + 1;
597  av_assert0(size_len <= 4);
598 
600  sfi.bytes_per_framesize_minus_1 = size_len - 1;
601  sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
602 
603  size = 2;
604  for (i = 0; i < frag->nb_units; i++) {
605  size += size_len + frag->units[i].data_size;
606  sfi.frame_sizes[i] = frag->units[i].data_size;
607  }
608 
610  if (!ref)
611  return AVERROR(ENOMEM);
612  data = ref->data;
613  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
614 
615  pos = 0;
616  for (i = 0; i < frag->nb_units; i++) {
617  av_assert0(size - pos > frag->units[i].data_size);
618  memcpy(data + pos, frag->units[i].data,
619  frag->units[i].data_size);
620  pos += frag->units[i].data_size;
621  }
622  av_assert0(size - pos == 2 + frag->nb_units * size_len);
623 
624  init_put_bits(&pbc, data + pos, size - pos);
625 
626  err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
627  if (err < 0) {
628  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
629  "superframe index.\n");
630  av_buffer_unref(&ref);
631  return err;
632  }
633 
634  av_assert0(put_bits_left(&pbc) == 0);
635  flush_put_bits(&pbc);
636 
637  frag->data_ref = ref;
638  frag->data = data;
639  frag->data_size = size;
640  }
641 
642  return 0;
643 }
644 
647 
648  .priv_data_size = sizeof(CodedBitstreamVP9Context),
649 
650  .split_fragment = &cbs_vp9_split_fragment,
651  .read_unit = &cbs_vp9_read_unit,
652  .write_unit = &cbs_vp9_write_unit,
653  .assemble_fragment = &cbs_vp9_assemble_fragment,
654 };
#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:126
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:555
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
int av_log2(unsigned v)
Definition: intmath.c:26
#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
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
static int cbs_vp9_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_vp9.c:529
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
ptrdiff_t size
Definition: opengl_enc.c:100
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:411
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#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
static void cbs_vp9_free_frame(void *opaque, uint8_t *content)
Definition: cbs_vp9.c:482
unsigned int pos
Definition: spdifenc.c:410
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:67
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
#define b
Definition: input.c:41
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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
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:68
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
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:645
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:94
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:214
int len
#define av_freep(p)
static int cbs_vp9_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_vp9.c:489
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:139
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
const char * name
Definition: opengl_enc.c:102
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