FFmpeg
cbs_av1.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 #include "libavutil/pixfmt.h"
21 
22 #include "cbs.h"
23 #include "cbs_internal.h"
24 #include "cbs_av1.h"
25 #include "internal.h"
26 
27 
29  const char *name, uint32_t *write_to,
30  uint32_t range_min, uint32_t range_max)
31 {
32  uint32_t zeroes, bits_value, value;
33  int position;
34 
35  if (ctx->trace_enable)
36  position = get_bits_count(gbc);
37 
38  zeroes = 0;
39  while (1) {
40  if (get_bits_left(gbc) < 1) {
41  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid uvlc code at "
42  "%s: bitstream ended.\n", name);
43  return AVERROR_INVALIDDATA;
44  }
45 
46  if (get_bits1(gbc))
47  break;
48  ++zeroes;
49  }
50 
51  if (zeroes >= 32) {
52  value = MAX_UINT_BITS(32);
53  } else {
54  if (get_bits_left(gbc) < zeroes) {
55  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid uvlc code at "
56  "%s: bitstream ended.\n", name);
57  return AVERROR_INVALIDDATA;
58  }
59 
60  bits_value = get_bits_long(gbc, zeroes);
61  value = bits_value + (UINT32_C(1) << zeroes) - 1;
62  }
63 
64  if (ctx->trace_enable) {
65  char bits[65];
66  int i, j, k;
67 
68  if (zeroes >= 32) {
69  while (zeroes > 32) {
70  k = FFMIN(zeroes - 32, 32);
71  for (i = 0; i < k; i++)
72  bits[i] = '0';
73  bits[i] = 0;
74  ff_cbs_trace_syntax_element(ctx, position, name,
75  NULL, bits, 0);
76  zeroes -= k;
77  position += k;
78  }
79  }
80 
81  for (i = 0; i < zeroes; i++)
82  bits[i] = '0';
83  bits[i++] = '1';
84 
85  if (zeroes < 32) {
86  for (j = 0; j < zeroes; j++)
87  bits[i++] = (bits_value >> (zeroes - j - 1) & 1) ? '1' : '0';
88  }
89 
90  bits[i] = 0;
91  ff_cbs_trace_syntax_element(ctx, position, name,
92  NULL, bits, value);
93  }
94 
95  if (value < range_min || value > range_max) {
96  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
97  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
98  name, value, range_min, range_max);
99  return AVERROR_INVALIDDATA;
100  }
101 
102  *write_to = value;
103  return 0;
104 }
105 
107  const char *name, uint32_t value,
108  uint32_t range_min, uint32_t range_max)
109 {
110  uint32_t v;
111  int position, zeroes;
112 
113  if (value < range_min || value > range_max) {
114  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
115  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
116  name, value, range_min, range_max);
117  return AVERROR_INVALIDDATA;
118  }
119 
120  if (ctx->trace_enable)
121  position = put_bits_count(pbc);
122 
123  zeroes = av_log2(value + 1);
124  v = value - (1U << zeroes) + 1;
125  put_bits(pbc, zeroes, 0);
126  put_bits(pbc, 1, 1);
127  put_bits(pbc, zeroes, v);
128 
129  if (ctx->trace_enable) {
130  char bits[65];
131  int i, j;
132  i = 0;
133  for (j = 0; j < zeroes; j++)
134  bits[i++] = '0';
135  bits[i++] = '1';
136  for (j = 0; j < zeroes; j++)
137  bits[i++] = (v >> (zeroes - j - 1) & 1) ? '1' : '0';
138  bits[i++] = 0;
139  ff_cbs_trace_syntax_element(ctx, position, name, NULL,
140  bits, value);
141  }
142 
143  return 0;
144 }
145 
147  const char *name, uint64_t *write_to)
148 {
149  uint64_t value;
150  int position, err, i;
151 
152  if (ctx->trace_enable)
153  position = get_bits_count(gbc);
154 
155  value = 0;
156  for (i = 0; i < 8; i++) {
157  int subscript[2] = { 1, i };
158  uint32_t byte;
159  err = ff_cbs_read_unsigned(ctx, gbc, 8, "leb128_byte[i]", subscript,
160  &byte, 0x00, 0xff);
161  if (err < 0)
162  return err;
163 
164  value |= (uint64_t)(byte & 0x7f) << (i * 7);
165  if (!(byte & 0x80))
166  break;
167  }
168 
169  if (value > UINT32_MAX)
170  return AVERROR_INVALIDDATA;
171 
172  if (ctx->trace_enable)
173  ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);
174 
175  *write_to = value;
176  return 0;
177 }
178 
180  const char *name, uint64_t value)
181 {
182  int position, err, len, i;
183  uint8_t byte;
184 
185  len = (av_log2(value) + 7) / 7;
186 
187  if (ctx->trace_enable)
188  position = put_bits_count(pbc);
189 
190  for (i = 0; i < len; i++) {
191  int subscript[2] = { 1, i };
192 
193  byte = value >> (7 * i) & 0x7f;
194  if (i < len - 1)
195  byte |= 0x80;
196 
197  err = ff_cbs_write_unsigned(ctx, pbc, 8, "leb128_byte[i]", subscript,
198  byte, 0x00, 0xff);
199  if (err < 0)
200  return err;
201  }
202 
203  if (ctx->trace_enable)
204  ff_cbs_trace_syntax_element(ctx, position, name, NULL, "", value);
205 
206  return 0;
207 }
208 
210  uint32_t n, const char *name,
211  const int *subscripts, uint32_t *write_to)
212 {
213  uint32_t m, v, extra_bit, value;
214  int position, w;
215 
216  av_assert0(n > 0);
217 
218  if (ctx->trace_enable)
219  position = get_bits_count(gbc);
220 
221  w = av_log2(n) + 1;
222  m = (1 << w) - n;
223 
224  if (get_bits_left(gbc) < w) {
225  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid non-symmetric value at "
226  "%s: bitstream ended.\n", name);
227  return AVERROR_INVALIDDATA;
228  }
229 
230  if (w - 1 > 0)
231  v = get_bits(gbc, w - 1);
232  else
233  v = 0;
234 
235  if (v < m) {
236  value = v;
237  } else {
238  extra_bit = get_bits1(gbc);
239  value = (v << 1) - m + extra_bit;
240  }
241 
242  if (ctx->trace_enable) {
243  char bits[33];
244  int i;
245  for (i = 0; i < w - 1; i++)
246  bits[i] = (v >> i & 1) ? '1' : '0';
247  if (v >= m)
248  bits[i++] = extra_bit ? '1' : '0';
249  bits[i] = 0;
250 
251  ff_cbs_trace_syntax_element(ctx, position,
252  name, subscripts, bits, value);
253  }
254 
255  *write_to = value;
256  return 0;
257 }
258 
260  uint32_t n, const char *name,
261  const int *subscripts, uint32_t value)
262 {
263  uint32_t w, m, v, extra_bit;
264  int position;
265 
266  if (value > n) {
267  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
268  "%"PRIu32", but must be in [0,%"PRIu32"].\n",
269  name, value, n);
270  return AVERROR_INVALIDDATA;
271  }
272 
273  if (ctx->trace_enable)
274  position = put_bits_count(pbc);
275 
276  w = av_log2(n) + 1;
277  m = (1 << w) - n;
278 
279  if (put_bits_left(pbc) < w)
280  return AVERROR(ENOSPC);
281 
282  if (value < m) {
283  v = value;
284  put_bits(pbc, w - 1, v);
285  } else {
286  v = m + ((value - m) >> 1);
287  extra_bit = (value - m) & 1;
288  put_bits(pbc, w - 1, v);
289  put_bits(pbc, 1, extra_bit);
290  }
291 
292  if (ctx->trace_enable) {
293  char bits[33];
294  int i;
295  for (i = 0; i < w - 1; i++)
296  bits[i] = (v >> i & 1) ? '1' : '0';
297  if (value >= m)
298  bits[i++] = extra_bit ? '1' : '0';
299  bits[i] = 0;
300 
301  ff_cbs_trace_syntax_element(ctx, position,
302  name, subscripts, bits, value);
303  }
304 
305  return 0;
306 }
307 
309  uint32_t range_min, uint32_t range_max,
310  const char *name, uint32_t *write_to)
311 {
312  uint32_t value;
313  int position, i;
314  char bits[33];
315 
316  av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
317  if (ctx->trace_enable)
318  position = get_bits_count(gbc);
319 
320  for (i = 0, value = range_min; value < range_max;) {
321  if (get_bits_left(gbc) < 1) {
322  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
323  "%s: bitstream ended.\n", name);
324  return AVERROR_INVALIDDATA;
325  }
326  if (get_bits1(gbc)) {
327  bits[i++] = '1';
328  ++value;
329  } else {
330  bits[i++] = '0';
331  break;
332  }
333  }
334 
335  if (ctx->trace_enable) {
336  bits[i] = 0;
337  ff_cbs_trace_syntax_element(ctx, position,
338  name, NULL, bits, value);
339  }
340 
341  *write_to = value;
342  return 0;
343 }
344 
346  uint32_t range_min, uint32_t range_max,
347  const char *name, uint32_t value)
348 {
349  int len;
350 
351  av_assert0(range_min <= range_max && range_max - range_min < 32);
352  if (value < range_min || value > range_max) {
353  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
354  "%"PRIu32", but must be in [%"PRIu32",%"PRIu32"].\n",
355  name, value, range_min, range_max);
356  return AVERROR_INVALIDDATA;
357  }
358 
359  if (value == range_max)
360  len = range_max - range_min;
361  else
362  len = value - range_min + 1;
363  if (put_bits_left(pbc) < len)
364  return AVERROR(ENOSPC);
365 
366  if (ctx->trace_enable) {
367  char bits[33];
368  int i;
369  for (i = 0; i < len; i++) {
370  if (range_min + i == value)
371  bits[i] = '0';
372  else
373  bits[i] = '1';
374  }
375  bits[i] = 0;
377  name, NULL, bits, value);
378  }
379 
380  if (len > 0)
381  put_bits(pbc, len, (1 << len) - 1 - (value != range_max));
382 
383  return 0;
384 }
385 
387  uint32_t range_max, const char *name,
388  const int *subscripts, uint32_t *write_to)
389 {
390  uint32_t value;
391  int position, err;
392  uint32_t max_len, len, range_offset, range_bits;
393 
394  if (ctx->trace_enable)
395  position = get_bits_count(gbc);
396 
397  av_assert0(range_max > 0);
398  max_len = av_log2(range_max - 1) - 3;
399 
400  err = cbs_av1_read_increment(ctx, gbc, 0, max_len,
401  "subexp_more_bits", &len);
402  if (err < 0)
403  return err;
404 
405  if (len) {
406  range_bits = 2 + len;
407  range_offset = 1 << range_bits;
408  } else {
409  range_bits = 3;
410  range_offset = 0;
411  }
412 
413  if (len < max_len) {
414  err = ff_cbs_read_unsigned(ctx, gbc, range_bits,
415  "subexp_bits", NULL, &value,
416  0, MAX_UINT_BITS(range_bits));
417  if (err < 0)
418  return err;
419 
420  } else {
421  err = cbs_av1_read_ns(ctx, gbc, range_max - range_offset,
422  "subexp_final_bits", NULL, &value);
423  if (err < 0)
424  return err;
425  }
426  value += range_offset;
427 
428  if (ctx->trace_enable)
429  ff_cbs_trace_syntax_element(ctx, position,
430  name, subscripts, "", value);
431 
432  *write_to = value;
433  return err;
434 }
435 
437  uint32_t range_max, const char *name,
438  const int *subscripts, uint32_t value)
439 {
440  int position, err;
441  uint32_t max_len, len, range_offset, range_bits;
442 
443  if (value > range_max) {
444  av_log(ctx->log_ctx, AV_LOG_ERROR, "%s out of range: "
445  "%"PRIu32", but must be in [0,%"PRIu32"].\n",
446  name, value, range_max);
447  return AVERROR_INVALIDDATA;
448  }
449 
450  if (ctx->trace_enable)
451  position = put_bits_count(pbc);
452 
453  av_assert0(range_max > 0);
454  max_len = av_log2(range_max - 1) - 3;
455 
456  if (value < 8) {
457  range_bits = 3;
458  range_offset = 0;
459  len = 0;
460  } else {
461  range_bits = av_log2(value);
462  len = range_bits - 2;
463  if (len > max_len) {
464  // The top bin is combined with the one below it.
465  av_assert0(len == max_len + 1);
466  --range_bits;
467  len = max_len;
468  }
469  range_offset = 1 << range_bits;
470  }
471 
472  err = cbs_av1_write_increment(ctx, pbc, 0, max_len,
473  "subexp_more_bits", len);
474  if (err < 0)
475  return err;
476 
477  if (len < max_len) {
478  err = ff_cbs_write_unsigned(ctx, pbc, range_bits,
479  "subexp_bits", NULL,
480  value - range_offset,
481  0, MAX_UINT_BITS(range_bits));
482  if (err < 0)
483  return err;
484 
485  } else {
486  err = cbs_av1_write_ns(ctx, pbc, range_max - range_offset,
487  "subexp_final_bits", NULL,
488  value - range_offset);
489  if (err < 0)
490  return err;
491  }
492 
493  if (ctx->trace_enable)
494  ff_cbs_trace_syntax_element(ctx, position,
495  name, subscripts, "", value);
496 
497  return err;
498 }
499 
500 
501 static int cbs_av1_tile_log2(int blksize, int target)
502 {
503  int k;
504  for (k = 0; (blksize << k) < target; k++);
505  return k;
506 }
507 
509  unsigned int a, unsigned int b)
510 {
511  unsigned int diff, m;
512  if (!seq->enable_order_hint)
513  return 0;
514  diff = a - b;
515  m = 1 << seq->order_hint_bits_minus_1;
516  diff = (diff & (m - 1)) - (diff & m);
517  return diff;
518 }
519 
521 {
522  GetBitContext tmp = *gbc;
523  size_t size = 0;
524  for (int i = 0; get_bits_left(&tmp) >= 8; i++) {
525  if (get_bits(&tmp, 8))
526  size = i;
527  }
528  return size;
529 }
530 
531 
532 #define HEADER(name) do { \
533  ff_cbs_trace_header(ctx, name); \
534  } while (0)
535 
536 #define CHECK(call) do { \
537  err = (call); \
538  if (err < 0) \
539  return err; \
540  } while (0)
541 
542 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
543 #define FUNC_AV1(rw, name) FUNC_NAME(rw, av1, name)
544 #define FUNC(name) FUNC_AV1(READWRITE, name)
545 
546 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
547 
548 #define fb(width, name) \
549  xf(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )
550 #define fc(width, name, range_min, range_max) \
551  xf(width, name, current->name, range_min, range_max, 0, )
552 #define flag(name) fb(1, name)
553 #define su(width, name) \
554  xsu(width, name, current->name, 0, )
555 
556 #define fbs(width, name, subs, ...) \
557  xf(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
558 #define fcs(width, name, range_min, range_max, subs, ...) \
559  xf(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
560 #define flags(name, subs, ...) \
561  xf(1, name, current->name, 0, 1, subs, __VA_ARGS__)
562 #define sus(width, name, subs, ...) \
563  xsu(width, name, current->name, subs, __VA_ARGS__)
564 
565 #define fixed(width, name, value) do { \
566  av_unused uint32_t fixed_value = value; \
567  xf(width, name, fixed_value, value, value, 0, ); \
568  } while (0)
569 
570 
571 #define READ
572 #define READWRITE read
573 #define RWContext GetBitContext
574 
575 #define xf(width, name, var, range_min, range_max, subs, ...) do { \
576  uint32_t value; \
577  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
578  SUBSCRIPTS(subs, __VA_ARGS__), \
579  &value, range_min, range_max)); \
580  var = value; \
581  } while (0)
582 
583 #define xsu(width, name, var, subs, ...) do { \
584  int32_t value; \
585  CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
586  SUBSCRIPTS(subs, __VA_ARGS__), &value, \
587  MIN_INT_BITS(width), \
588  MAX_INT_BITS(width))); \
589  var = value; \
590  } while (0)
591 
592 #define uvlc(name, range_min, range_max) do { \
593  uint32_t value; \
594  CHECK(cbs_av1_read_uvlc(ctx, rw, #name, \
595  &value, range_min, range_max)); \
596  current->name = value; \
597  } while (0)
598 
599 #define ns(max_value, name, subs, ...) do { \
600  uint32_t value; \
601  CHECK(cbs_av1_read_ns(ctx, rw, max_value, #name, \
602  SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
603  current->name = value; \
604  } while (0)
605 
606 #define increment(name, min, max) do { \
607  uint32_t value; \
608  CHECK(cbs_av1_read_increment(ctx, rw, min, max, #name, &value)); \
609  current->name = value; \
610  } while (0)
611 
612 #define subexp(name, max, subs, ...) do { \
613  uint32_t value; \
614  CHECK(cbs_av1_read_subexp(ctx, rw, max, #name, \
615  SUBSCRIPTS(subs, __VA_ARGS__), &value)); \
616  current->name = value; \
617  } while (0)
618 
619 #define delta_q(name) do { \
620  uint8_t delta_coded; \
621  int8_t delta_q; \
622  xf(1, name.delta_coded, delta_coded, 0, 1, 0, ); \
623  if (delta_coded) \
624  xsu(1 + 6, name.delta_q, delta_q, 0, ); \
625  else \
626  delta_q = 0; \
627  current->name = delta_q; \
628  } while (0)
629 
630 #define leb128(name) do { \
631  uint64_t value; \
632  CHECK(cbs_av1_read_leb128(ctx, rw, #name, &value)); \
633  current->name = value; \
634  } while (0)
635 
636 #define infer(name, value) do { \
637  current->name = value; \
638  } while (0)
639 
640 #define byte_alignment(rw) (get_bits_count(rw) % 8)
641 
642 #include "cbs_av1_syntax_template.c"
643 
644 #undef READ
645 #undef READWRITE
646 #undef RWContext
647 #undef xf
648 #undef xsu
649 #undef uvlc
650 #undef ns
651 #undef increment
652 #undef subexp
653 #undef delta_q
654 #undef leb128
655 #undef infer
656 #undef byte_alignment
657 
658 
659 #define WRITE
660 #define READWRITE write
661 #define RWContext PutBitContext
662 
663 #define xf(width, name, var, range_min, range_max, subs, ...) do { \
664  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
665  SUBSCRIPTS(subs, __VA_ARGS__), \
666  var, range_min, range_max)); \
667  } while (0)
668 
669 #define xsu(width, name, var, subs, ...) do { \
670  CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
671  SUBSCRIPTS(subs, __VA_ARGS__), var, \
672  MIN_INT_BITS(width), \
673  MAX_INT_BITS(width))); \
674  } while (0)
675 
676 #define uvlc(name, range_min, range_max) do { \
677  CHECK(cbs_av1_write_uvlc(ctx, rw, #name, current->name, \
678  range_min, range_max)); \
679  } while (0)
680 
681 #define ns(max_value, name, subs, ...) do { \
682  CHECK(cbs_av1_write_ns(ctx, rw, max_value, #name, \
683  SUBSCRIPTS(subs, __VA_ARGS__), \
684  current->name)); \
685  } while (0)
686 
687 #define increment(name, min, max) do { \
688  CHECK(cbs_av1_write_increment(ctx, rw, min, max, #name, \
689  current->name)); \
690  } while (0)
691 
692 #define subexp(name, max, subs, ...) do { \
693  CHECK(cbs_av1_write_subexp(ctx, rw, max, #name, \
694  SUBSCRIPTS(subs, __VA_ARGS__), \
695  current->name)); \
696  } while (0)
697 
698 #define delta_q(name) do { \
699  xf(1, name.delta_coded, current->name != 0, 0, 1, 0, ); \
700  if (current->name) \
701  xsu(1 + 6, name.delta_q, current->name, 0, ); \
702  } while (0)
703 
704 #define leb128(name) do { \
705  CHECK(cbs_av1_write_leb128(ctx, rw, #name, current->name)); \
706  } while (0)
707 
708 #define infer(name, value) do { \
709  if (current->name != (value)) { \
710  av_log(ctx->log_ctx, AV_LOG_ERROR, \
711  "%s does not match inferred value: " \
712  "%"PRId64", but should be %"PRId64".\n", \
713  #name, (int64_t)current->name, (int64_t)(value)); \
714  return AVERROR_INVALIDDATA; \
715  } \
716  } while (0)
717 
718 #define byte_alignment(rw) (put_bits_count(rw) % 8)
719 
720 #include "cbs_av1_syntax_template.c"
721 
722 #undef WRITE
723 #undef READWRITE
724 #undef RWContext
725 #undef xf
726 #undef xsu
727 #undef uvlc
728 #undef ns
729 #undef increment
730 #undef subexp
731 #undef delta_q
732 #undef leb128
733 #undef infer
734 #undef byte_alignment
735 
736 
739  int header)
740 {
741  GetBitContext gbc;
742  uint8_t *data;
743  size_t size;
744  uint64_t obu_length;
745  int pos, err, trace;
746 
747  // Don't include this parsing in trace output.
748  trace = ctx->trace_enable;
749  ctx->trace_enable = 0;
750 
751  data = frag->data;
752  size = frag->data_size;
753 
754  if (INT_MAX / 8 < size) {
755  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid fragment: "
756  "too large (%"SIZE_SPECIFIER" bytes).\n", size);
757  err = AVERROR_INVALIDDATA;
758  goto fail;
759  }
760 
761  while (size > 0) {
763  uint64_t obu_size;
764 
765  init_get_bits(&gbc, data, 8 * size);
766 
767  err = cbs_av1_read_obu_header(ctx, &gbc, &header);
768  if (err < 0)
769  goto fail;
770 
771  if (header.obu_has_size_field) {
772  if (get_bits_left(&gbc) < 8) {
773  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU: fragment "
774  "too short (%"SIZE_SPECIFIER" bytes).\n", size);
775  err = AVERROR_INVALIDDATA;
776  goto fail;
777  }
778  err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
779  if (err < 0)
780  goto fail;
781  } else
782  obu_size = size - 1 - header.obu_extension_flag;
783 
784  pos = get_bits_count(&gbc);
785  av_assert0(pos % 8 == 0 && pos / 8 <= size);
786 
787  obu_length = pos / 8 + obu_size;
788 
789  if (size < obu_length) {
790  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "
791  "%"PRIu64", but only %"SIZE_SPECIFIER" bytes remaining in fragment.\n",
792  obu_length, size);
793  err = AVERROR_INVALIDDATA;
794  goto fail;
795  }
796 
797  err = ff_cbs_insert_unit_data(frag, -1, header.obu_type,
798  data, obu_length, frag->data_ref);
799  if (err < 0)
800  goto fail;
801 
802  data += obu_length;
803  size -= obu_length;
804  }
805 
806  err = 0;
807 fail:
808  ctx->trace_enable = trace;
809  return err;
810 }
811 
813 {
815 }
816 
818 {
820 }
821 
823 {
824  switch (md->metadata_type) {
827  break;
828  }
829 }
830 
831 static void cbs_av1_free_obu(void *opaque, uint8_t *content)
832 {
833  AV1RawOBU *obu = (AV1RawOBU*)content;
834 
835  switch (obu->header.obu_type) {
836  case AV1_OBU_TILE_GROUP:
838  break;
839  case AV1_OBU_FRAME:
841  break;
842  case AV1_OBU_TILE_LIST:
844  break;
845  case AV1_OBU_METADATA:
847  break;
848  case AV1_OBU_PADDING:
850  break;
851  }
852 
853  av_freep(&obu);
854 }
855 
857  CodedBitstreamUnit *unit,
858  GetBitContext *gbc,
860 {
861  int pos;
862 
863  pos = get_bits_count(gbc);
864  if (pos >= 8 * unit->data_size) {
865  av_log(ctx->log_ctx, AV_LOG_ERROR, "Bitstream ended before "
866  "any data in tile group (%d bits read).\n", pos);
867  return AVERROR_INVALIDDATA;
868  }
869  // Must be byte-aligned at this point.
870  av_assert0(pos % 8 == 0);
871 
872  td->data_ref = av_buffer_ref(unit->data_ref);
873  if (!td->data_ref)
874  return AVERROR(ENOMEM);
875 
876  td->data = unit->data + pos / 8;
877  td->data_size = unit->data_size - pos / 8;
878 
879  return 0;
880 }
881 
883  CodedBitstreamUnit *unit)
884 {
885  CodedBitstreamAV1Context *priv = ctx->priv_data;
886  AV1RawOBU *obu;
887  GetBitContext gbc;
888  int err, start_pos, end_pos;
889 
890  err = ff_cbs_alloc_unit_content(unit, sizeof(*obu),
892  if (err < 0)
893  return err;
894  obu = unit->content;
895 
896  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
897  if (err < 0)
898  return err;
899 
900  err = cbs_av1_read_obu_header(ctx, &gbc, &obu->header);
901  if (err < 0)
902  return err;
903  av_assert0(obu->header.obu_type == unit->type);
904 
905  if (obu->header.obu_has_size_field) {
906  uint64_t obu_size;
907  err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
908  if (err < 0)
909  return err;
910  obu->obu_size = obu_size;
911  } else {
912  if (unit->data_size < 1 + obu->header.obu_extension_flag) {
913  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "
914  "unit too short (%"SIZE_SPECIFIER").\n", unit->data_size);
915  return AVERROR_INVALIDDATA;
916  }
917  obu->obu_size = unit->data_size - 1 - obu->header.obu_extension_flag;
918  }
919 
920  start_pos = get_bits_count(&gbc);
921 
922  if (obu->header.obu_extension_flag) {
923  priv->temporal_id = obu->header.temporal_id;
924  priv->spatial_id = obu->header.spatial_id;
925 
928  priv->operating_point_idc) {
929  int in_temporal_layer =
930  (priv->operating_point_idc >> priv->temporal_id ) & 1;
931  int in_spatial_layer =
932  (priv->operating_point_idc >> (priv->spatial_id + 8)) & 1;
933  if (!in_temporal_layer || !in_spatial_layer) {
934  // Decoding will drop this OBU at this operating point.
935  }
936  }
937  } else {
938  priv->temporal_id = 0;
939  priv->spatial_id = 0;
940  }
941 
942  switch (obu->header.obu_type) {
944  {
945  err = cbs_av1_read_sequence_header_obu(ctx, &gbc,
946  &obu->obu.sequence_header);
947  if (err < 0)
948  return err;
949 
951  priv->sequence_header = NULL;
952 
954  if (!priv->sequence_header_ref)
955  return AVERROR(ENOMEM);
956  priv->sequence_header = &obu->obu.sequence_header;
957  }
958  break;
960  {
961  err = cbs_av1_read_temporal_delimiter_obu(ctx, &gbc);
962  if (err < 0)
963  return err;
964  }
965  break;
968  {
969  err = cbs_av1_read_frame_header_obu(ctx, &gbc,
970  &obu->obu.frame_header,
971  obu->header.obu_type ==
973  unit->data_ref);
974  if (err < 0)
975  return err;
976  }
977  break;
978  case AV1_OBU_TILE_GROUP:
979  {
980  err = cbs_av1_read_tile_group_obu(ctx, &gbc,
981  &obu->obu.tile_group);
982  if (err < 0)
983  return err;
984 
985  err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
986  &obu->obu.tile_group.tile_data);
987  if (err < 0)
988  return err;
989  }
990  break;
991  case AV1_OBU_FRAME:
992  {
993  err = cbs_av1_read_frame_obu(ctx, &gbc, &obu->obu.frame,
994  unit->data_ref);
995  if (err < 0)
996  return err;
997 
998  err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
999  &obu->obu.frame.tile_group.tile_data);
1000  if (err < 0)
1001  return err;
1002  }
1003  break;
1004  case AV1_OBU_TILE_LIST:
1005  {
1006  err = cbs_av1_read_tile_list_obu(ctx, &gbc,
1007  &obu->obu.tile_list);
1008  if (err < 0)
1009  return err;
1010 
1011  err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
1012  &obu->obu.tile_list.tile_data);
1013  if (err < 0)
1014  return err;
1015  }
1016  break;
1017  case AV1_OBU_METADATA:
1018  {
1019  err = cbs_av1_read_metadata_obu(ctx, &gbc, &obu->obu.metadata);
1020  if (err < 0)
1021  return err;
1022  }
1023  break;
1024  case AV1_OBU_PADDING:
1025  {
1026  err = cbs_av1_read_padding_obu(ctx, &gbc, &obu->obu.padding);
1027  if (err < 0)
1028  return err;
1029  }
1030  break;
1031  default:
1032  return AVERROR(ENOSYS);
1033  }
1034 
1035  end_pos = get_bits_count(&gbc);
1036  av_assert0(end_pos <= unit->data_size * 8);
1037 
1038  if (obu->obu_size > 0 &&
1040  obu->header.obu_type != AV1_OBU_TILE_LIST &&
1041  obu->header.obu_type != AV1_OBU_FRAME) {
1042  int nb_bits = obu->obu_size * 8 + start_pos - end_pos;
1043 
1044  if (nb_bits <= 0)
1045  return AVERROR_INVALIDDATA;
1046 
1047  err = cbs_av1_read_trailing_bits(ctx, &gbc, nb_bits);
1048  if (err < 0)
1049  return err;
1050  }
1051 
1052  return 0;
1053 }
1054 
1056  CodedBitstreamUnit *unit,
1057  PutBitContext *pbc)
1058 {
1059  CodedBitstreamAV1Context *priv = ctx->priv_data;
1060  AV1RawOBU *obu = unit->content;
1061  PutBitContext pbc_tmp;
1062  AV1RawTileData *td;
1063  size_t header_size;
1064  int err, start_pos, end_pos, data_pos;
1065 
1066  // OBUs in the normal bitstream format must contain a size field
1067  // in every OBU (in annex B it is optional, but we don't support
1068  // writing that).
1069  obu->header.obu_has_size_field = 1;
1070 
1071  err = cbs_av1_write_obu_header(ctx, pbc, &obu->header);
1072  if (err < 0)
1073  return err;
1074 
1075  if (obu->header.obu_has_size_field) {
1076  pbc_tmp = *pbc;
1077  // Add space for the size field to fill later.
1078  put_bits32(pbc, 0);
1079  put_bits32(pbc, 0);
1080  }
1081 
1082  td = NULL;
1083  start_pos = put_bits_count(pbc);
1084 
1085  switch (obu->header.obu_type) {
1087  {
1088  err = cbs_av1_write_sequence_header_obu(ctx, pbc,
1089  &obu->obu.sequence_header);
1090  if (err < 0)
1091  return err;
1092 
1094  priv->sequence_header = NULL;
1095 
1097  if (!priv->sequence_header_ref)
1098  return AVERROR(ENOMEM);
1099  priv->sequence_header = &obu->obu.sequence_header;
1100  }
1101  break;
1103  {
1104  err = cbs_av1_write_temporal_delimiter_obu(ctx, pbc);
1105  if (err < 0)
1106  return err;
1107  }
1108  break;
1109  case AV1_OBU_FRAME_HEADER:
1111  {
1112  err = cbs_av1_write_frame_header_obu(ctx, pbc,
1113  &obu->obu.frame_header,
1114  obu->header.obu_type ==
1116  NULL);
1117  if (err < 0)
1118  return err;
1119  }
1120  break;
1121  case AV1_OBU_TILE_GROUP:
1122  {
1123  err = cbs_av1_write_tile_group_obu(ctx, pbc,
1124  &obu->obu.tile_group);
1125  if (err < 0)
1126  return err;
1127 
1128  td = &obu->obu.tile_group.tile_data;
1129  }
1130  break;
1131  case AV1_OBU_FRAME:
1132  {
1133  err = cbs_av1_write_frame_obu(ctx, pbc, &obu->obu.frame, NULL);
1134  if (err < 0)
1135  return err;
1136 
1137  td = &obu->obu.frame.tile_group.tile_data;
1138  }
1139  break;
1140  case AV1_OBU_TILE_LIST:
1141  {
1142  err = cbs_av1_write_tile_list_obu(ctx, pbc, &obu->obu.tile_list);
1143  if (err < 0)
1144  return err;
1145 
1146  td = &obu->obu.tile_list.tile_data;
1147  }
1148  break;
1149  case AV1_OBU_METADATA:
1150  {
1151  err = cbs_av1_write_metadata_obu(ctx, pbc, &obu->obu.metadata);
1152  if (err < 0)
1153  return err;
1154  }
1155  break;
1156  case AV1_OBU_PADDING:
1157  {
1158  err = cbs_av1_write_padding_obu(ctx, pbc, &obu->obu.padding);
1159  if (err < 0)
1160  return err;
1161  }
1162  break;
1163  default:
1164  return AVERROR(ENOSYS);
1165  }
1166 
1167  end_pos = put_bits_count(pbc);
1168  header_size = (end_pos - start_pos + 7) / 8;
1169  if (td) {
1170  obu->obu_size = header_size + td->data_size;
1171  } else if (header_size > 0) {
1172  // Add trailing bits and recalculate.
1173  err = cbs_av1_write_trailing_bits(ctx, pbc, 8 - end_pos % 8);
1174  if (err < 0)
1175  return err;
1176  end_pos = put_bits_count(pbc);
1177  obu->obu_size = header_size = (end_pos - start_pos + 7) / 8;
1178  } else {
1179  // Empty OBU.
1180  obu->obu_size = 0;
1181  }
1182 
1183  end_pos = put_bits_count(pbc);
1184  // Must now be byte-aligned.
1185  av_assert0(end_pos % 8 == 0);
1186  flush_put_bits(pbc);
1187  start_pos /= 8;
1188  end_pos /= 8;
1189 
1190  *pbc = pbc_tmp;
1191  err = cbs_av1_write_leb128(ctx, pbc, "obu_size", obu->obu_size);
1192  if (err < 0)
1193  return err;
1194 
1195  data_pos = put_bits_count(pbc) / 8;
1196  flush_put_bits(pbc);
1197  av_assert0(data_pos <= start_pos);
1198 
1199  if (8 * obu->obu_size > put_bits_left(pbc))
1200  return AVERROR(ENOSPC);
1201 
1202  if (obu->obu_size > 0) {
1203  memmove(pbc->buf + data_pos,
1204  pbc->buf + start_pos, header_size);
1205  skip_put_bytes(pbc, header_size);
1206 
1207  if (td) {
1208  memcpy(pbc->buf + data_pos + header_size,
1209  td->data, td->data_size);
1210  skip_put_bytes(pbc, td->data_size);
1211  }
1212  }
1213 
1214  // OBU data must be byte-aligned.
1215  av_assert0(put_bits_count(pbc) % 8 == 0);
1216 
1217  return 0;
1218 }
1219 
1221  CodedBitstreamFragment *frag)
1222 {
1223  size_t size, pos;
1224  int i;
1225 
1226  size = 0;
1227  for (i = 0; i < frag->nb_units; i++)
1228  size += frag->units[i].data_size;
1229 
1231  if (!frag->data_ref)
1232  return AVERROR(ENOMEM);
1233  frag->data = frag->data_ref->data;
1234  memset(frag->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1235 
1236  pos = 0;
1237  for (i = 0; i < frag->nb_units; i++) {
1238  memcpy(frag->data + pos, frag->units[i].data,
1239  frag->units[i].data_size);
1240  pos += frag->units[i].data_size;
1241  }
1242  av_assert0(pos == size);
1243  frag->data_size = size;
1244 
1245  return 0;
1246 }
1247 
1249 {
1250  CodedBitstreamAV1Context *priv = ctx->priv_data;
1251 
1254 }
1255 
1258 
1259  .priv_data_size = sizeof(CodedBitstreamAV1Context),
1260 
1265 
1266  .close = &cbs_av1_close,
1267 };
AV1RawMetadata metadata
Definition: cbs_av1.h:398
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:268
#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
size_t obu_size
Definition: cbs_av1.h:390
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
AV1RawTileList tile_list
Definition: cbs_av1.h:397
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:211
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AVBufferRef * payload_ref
Definition: cbs_av1.h:350
static void cbs_av1_free_metadata(AV1RawMetadata *md)
Definition: cbs_av1.c:822
AVBufferRef * sequence_header_ref
Definition: cbs_av1.h:420
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
static int cbs_av1_read_uvlc(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, uint32_t *write_to, uint32_t range_min, uint32_t range_max)
Definition: cbs_av1.c:28
static void cbs_av1_close(CodedBitstreamContext *ctx)
Definition: cbs_av1.c:1248
int av_log2(unsigned v)
Definition: intmath.c:26
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc, int width, const char *name, const int *subscripts, uint32_t value, uint32_t range_min, uint32_t range_max)
Definition: cbs.c:524
static int cbs_av1_write_increment(CodedBitstreamContext *ctx, PutBitContext *pbc, uint32_t range_min, uint32_t range_max, const char *name, uint32_t value)
Definition: cbs_av1.c:345
int ff_cbs_insert_unit_data(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:751
static void cbs_av1_free_obu(void *opaque, uint8_t *content)
Definition: cbs_av1.c:831
#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
AV1RawTileData tile_data
Definition: cbs_av1.h:309
static int cbs_av1_write_uvlc(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, uint32_t value, uint32_t range_min, uint32_t range_max)
Definition: cbs_av1.c:106
int(* assemble_fragment)(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_internal.h:55
uint8_t
uint8_t * data
Definition: cbs_av1.h:286
static int cbs_av1_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_av1.c:882
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:98
int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc, int width, const char *name, const int *subscripts, uint32_t *write_to, uint32_t range_min, uint32_t range_max)
Definition: cbs.c:481
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
Coded bitstream unit structure.
Definition: cbs.h:64
ptrdiff_t size
Definition: opengl_enc.c:100
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 void cbs_av1_free_padding(AV1RawPadding *pd)
Definition: cbs_av1.c:817
#define av_log(a,...)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
static int cbs_av1_read_ns(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t n, const char *name, const int *subscripts, uint32_t *write_to)
Definition: cbs_av1.c:209
int(* write_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_internal.h:49
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static void cbs_av1_free_tile_data(AV1RawTileData *td)
Definition: cbs_av1.c:812
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define td
Definition: regdef.h:70
void(* close)(CodedBitstreamContext *ctx)
Definition: cbs_internal.h:59
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:107
AV1RawTileData tile_data
Definition: cbs_av1.h:296
uint8_t temporal_id
Definition: cbs_av1.h:36
AVBufferRef * frame_header_ref
Definition: cbs_av1.h:423
AV1RawFrame frame
Definition: cbs_av1.h:395
unsigned int pos
Definition: spdifenc.c:410
static int cbs_av1_read_subexp(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t range_max, const char *name, const int *subscripts, uint32_t *write_to)
Definition: cbs_av1.c:386
uint8_t * buf
Definition: put_bits.h:52
simple assert() macros that are a bit more flexible than ISO C assert().
union AV1RawOBU::@25 obu
uint8_t bits
Definition: vp3data.h:202
int ff_cbs_alloc_unit_content(CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:640
#define fail()
Definition: checkasm.h:123
static int cbs_av1_tile_log2(int blksize, int target)
Definition: cbs_av1.c:501
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:81
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:173
const CodedBitstreamType ff_cbs_type_av1
Definition: cbs_av1.c:1256
uint8_t obu_extension_flag
Definition: cbs_av1.h:32
AVBufferRef * payload_ref
Definition: cbs_av1.h:383
#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:356
#define md
#define FFMIN(a, b)
Definition: common.h:96
static int cbs_av1_write_obu(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_av1.c:1055
static int cbs_av1_write_leb128(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, uint64_t value)
Definition: cbs_av1.c:179
static int cbs_av1_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_av1.c:1220
uint8_t w
Definition: llviddspenc.c:38
AV1RawOBUHeader header
Definition: cbs_av1.h:388
AVFormatContext * ctx
Definition: movenc.c:48
static int cbs_av1_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_av1.c:737
static int cbs_av1_ref_tile_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, GetBitContext *gbc, AV1RawTileData *td)
Definition: cbs_av1.c:856
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
size_t data_size
Definition: cbs_av1.h:287
union AV1RawMetadata::@24 metadata
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
uint8_t * data
The data buffer.
Definition: buffer.h:89
static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)
Definition: cbs_av1.c:520
uint8_t enable_order_hint
Definition: cbs_av1.h:113
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
Context structure for coded bitstream operations.
Definition: cbs.h:168
static int cbs_av1_write_subexp(CodedBitstreamContext *ctx, PutBitContext *pbc, uint32_t range_max, const char *name, const int *subscripts, uint32_t value)
Definition: cbs_av1.c:436
AVBufferRef * content_ref
If content is reference counted, a reference to the buffer containing content.
Definition: cbs.h:106
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
AV1RawTileGroup tile_group
Definition: cbs_av1.h:301
uint8_t obu_type
Definition: cbs_av1.h:31
enum AVCodecID codec_id
Definition: cbs_internal.h:29
AV1RawSequenceHeader * sequence_header
Definition: cbs_av1.h:419
uint8_t spatial_id
Definition: cbs_av1.h:37
int(* read_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_internal.h:44
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static int cbs_av1_write_ns(CodedBitstreamContext *ctx, PutBitContext *pbc, uint32_t n, const char *name, const int *subscripts, uint32_t value)
Definition: cbs_av1.c:259
AV1RawSequenceHeader sequence_header
Definition: cbs_av1.h:393
#define SIZE_SPECIFIER
Definition: internal.h:229
AVBufferRef * data_ref
Definition: cbs_av1.h:288
void * priv_data
Internal codec-specific data.
Definition: cbs.h:189
AV1RawMetadataITUTT35 itut_t35
Definition: cbs_av1.h:375
AV1RawPadding padding
Definition: cbs_av1.h:399
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:115
int(* split_fragment)(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_internal.h:38
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
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
static av_always_inline int diff(const uint32_t a, const uint32_t b)
pixel format definitions
uint64_t metadata_type
Definition: cbs_av1.h:370
int len
uint8_t obu_has_size_field
Definition: cbs_av1.h:33
AV1RawTileGroup tile_group
Definition: cbs_av1.h:396
static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc, uint32_t range_min, uint32_t range_max, const char *name, uint32_t *write_to)
Definition: cbs_av1.c:308
AV1RawFrameHeader frame_header
Definition: cbs_av1.h:394
#define av_freep(p)
static int cbs_av1_read_leb128(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, uint64_t *write_to)
Definition: cbs_av1.c:146
static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: cbs_av1.c:508
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:431
int i
Definition: input.c:407
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 uint8_t tmp[11]
Definition: aes_ctr.c:26