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 
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  // Last byte in the packet.
420  superframe_header = frag->data[frag->data_size - 1];
421 
422  if ((superframe_header & 0xe0) == 0xc0) {
424  GetBitContext gbc;
425  size_t index_size, pos;
426  int i;
427 
428  index_size = 2 + (((superframe_header & 0x18) >> 3) + 1) *
429  ((superframe_header & 0x07) + 1);
430 
431  err = init_get_bits(&gbc, frag->data + frag->data_size - index_size,
432  8 * index_size);
433  if (err < 0)
434  return err;
435 
436  err = cbs_vp9_read_superframe_index(ctx, &gbc, &sfi);
437  if (err < 0)
438  return err;
439 
440  pos = 0;
441  for (i = 0; i <= sfi.frames_in_superframe_minus_1; i++) {
442  if (pos + sfi.frame_sizes[i] + index_size > frag->data_size) {
443  av_log(ctx->log_ctx, AV_LOG_ERROR, "Frame %d too large "
444  "in superframe: %"PRIu32" bytes.\n",
445  i, sfi.frame_sizes[i]);
446  return AVERROR_INVALIDDATA;
447  }
448 
449  err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
450  frag->data + pos,
451  sfi.frame_sizes[i],
452  frag->data_ref);
453  if (err < 0)
454  return err;
455 
456  pos += sfi.frame_sizes[i];
457  }
458  if (pos + index_size != frag->data_size) {
459  av_log(ctx->log_ctx, AV_LOG_WARNING, "Extra padding at "
460  "end of superframe: %"SIZE_SPECIFIER" bytes.\n",
461  frag->data_size - (pos + index_size));
462  }
463 
464  return 0;
465 
466  } else {
467  err = ff_cbs_insert_unit_data(ctx, frag, -1, 0,
468  frag->data, frag->data_size,
469  frag->data_ref);
470  if (err < 0)
471  return err;
472  }
473 
474  return 0;
475 }
476 
477 static void cbs_vp9_free_frame(void *opaque, uint8_t *content)
478 {
479  VP9RawFrame *frame = (VP9RawFrame*)content;
480  av_buffer_unref(&frame->data_ref);
481  av_freep(&frame);
482 }
483 
485  CodedBitstreamUnit *unit)
486 {
488  GetBitContext gbc;
489  int err, pos;
490 
491  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
492  if (err < 0)
493  return err;
494 
495  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*frame),
497  if (err < 0)
498  return err;
499  frame = unit->content;
500 
501  err = cbs_vp9_read_frame(ctx, &gbc, frame);
502  if (err < 0)
503  return err;
504 
505  pos = get_bits_count(&gbc);
506  av_assert0(pos % 8 == 0);
507  pos /= 8;
508  av_assert0(pos <= unit->data_size);
509 
510  if (pos == unit->data_size) {
511  // No data (e.g. a show-existing-frame frame).
512  } else {
513  frame->data_ref = av_buffer_ref(unit->data_ref);
514  if (!frame->data_ref)
515  return AVERROR(ENOMEM);
516 
517  frame->data = unit->data + pos;
518  frame->data_size = unit->data_size - pos;
519  }
520 
521  return 0;
522 }
523 
525  CodedBitstreamUnit *unit)
526 {
527  CodedBitstreamVP9Context *priv = ctx->priv_data;
528  VP9RawFrame *frame = unit->content;
529  PutBitContext pbc;
530  int err;
531 
532  if (!priv->write_buffer) {
533  // Initial write buffer size is 1MB.
534  priv->write_buffer_size = 1024 * 1024;
535 
536  reallocate_and_try_again:
537  err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
538  if (err < 0) {
539  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
540  "sufficiently large write buffer (last attempt "
541  "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
542  return err;
543  }
544  }
545 
546  init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
547 
548  err = cbs_vp9_write_frame(ctx, &pbc, frame);
549  if (err == AVERROR(ENOSPC)) {
550  priv->write_buffer_size *= 2;
551  goto reallocate_and_try_again;
552  }
553  if (err < 0)
554  return err;
555 
556  // Frame must be byte-aligned.
557  av_assert0(put_bits_count(&pbc) % 8 == 0);
558 
559  unit->data_size = put_bits_count(&pbc) / 8;
560  unit->data_bit_padding = 0;
561  flush_put_bits(&pbc);
562 
563  if (frame->data) {
564  if (unit->data_size + frame->data_size >
565  priv->write_buffer_size) {
566  priv->write_buffer_size *= 2;
567  goto reallocate_and_try_again;
568  }
569 
570  memcpy(priv->write_buffer + unit->data_size,
571  frame->data, frame->data_size);
572  unit->data_size += frame->data_size;
573  }
574 
575  err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
576  if (err < 0)
577  return err;
578 
579  memcpy(unit->data, priv->write_buffer, unit->data_size);
580 
581  return 0;
582 }
583 
586 {
587  int err;
588 
589  if (frag->nb_units == 1) {
590  // Output is just the content of the single frame.
591 
592  CodedBitstreamUnit *frame = &frag->units[0];
593 
594  frag->data_ref = av_buffer_ref(frame->data_ref);
595  if (!frag->data_ref)
596  return AVERROR(ENOMEM);
597 
598  frag->data = frame->data;
599  frag->data_size = frame->data_size;
600 
601  } else {
602  // Build superframe out of frames.
603 
605  PutBitContext pbc;
606  AVBufferRef *ref;
607  uint8_t *data;
608  size_t size, max, pos;
609  int i, size_len;
610 
611  if (frag->nb_units > 8) {
612  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many frames to "
613  "make superframe: %d.\n", frag->nb_units);
614  return AVERROR(EINVAL);
615  }
616 
617  max = 0;
618  for (i = 0; i < frag->nb_units; i++)
619  if (max < frag->units[i].data_size)
620  max = frag->units[i].data_size;
621 
622  if (max < 2)
623  size_len = 1;
624  else
625  size_len = av_log2(max) / 8 + 1;
626  av_assert0(size_len <= 4);
627 
629  sfi.bytes_per_framesize_minus_1 = size_len - 1;
630  sfi.frames_in_superframe_minus_1 = frag->nb_units - 1;
631 
632  size = 2;
633  for (i = 0; i < frag->nb_units; i++) {
634  size += size_len + frag->units[i].data_size;
635  sfi.frame_sizes[i] = frag->units[i].data_size;
636  }
637 
639  if (!ref)
640  return AVERROR(ENOMEM);
641  data = ref->data;
642  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
643 
644  pos = 0;
645  for (i = 0; i < frag->nb_units; i++) {
646  av_assert0(size - pos > frag->units[i].data_size);
647  memcpy(data + pos, frag->units[i].data,
648  frag->units[i].data_size);
649  pos += frag->units[i].data_size;
650  }
651  av_assert0(size - pos == 2 + frag->nb_units * size_len);
652 
653  init_put_bits(&pbc, data + pos, size - pos);
654 
655  err = cbs_vp9_write_superframe_index(ctx, &pbc, &sfi);
656  if (err < 0) {
657  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to write "
658  "superframe index.\n");
659  av_buffer_unref(&ref);
660  return err;
661  }
662 
663  av_assert0(put_bits_left(&pbc) == 0);
664  flush_put_bits(&pbc);
665 
666  frag->data_ref = ref;
667  frag->data = data;
668  frag->data_size = size;
669  }
670 
671  return 0;
672 }
673 
675 {
676  CodedBitstreamVP9Context *priv = ctx->priv_data;
677 
678  av_freep(&priv->write_buffer);
679 }
680 
683 
684  .priv_data_size = sizeof(CodedBitstreamVP9Context),
685 
686  .split_fragment = &cbs_vp9_split_fragment,
687  .read_unit = &cbs_vp9_read_unit,
688  .write_unit = &cbs_vp9_write_unit,
689  .assemble_fragment = &cbs_vp9_assemble_fragment,
690 
691  .close = &cbs_vp9_close,
692 };
#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
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:584
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:588
AVBufferRef * data_ref
Definition: cbs_vp9.h:169
int av_log2(unsigned v)
Definition: intmath.c:26
static void cbs_vp9_close(CodedBitstreamContext *ctx)
Definition: cbs_vp9.c:674
#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
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:86
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:609
#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:703
#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 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:477
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
#define b
Definition: input.c:41
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
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: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
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:681
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:189
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:791
int len
#define av_freep(p)
static int cbs_vp9_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_vp9.c:484
static int cbs_vp9_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_vp9.c:524
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:379
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