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  CodedBitstreamUnit *unit,
814  GetBitContext *gbc,
816 {
817  int pos;
818 
819  pos = get_bits_count(gbc);
820  if (pos >= 8 * unit->data_size) {
821  av_log(ctx->log_ctx, AV_LOG_ERROR, "Bitstream ended before "
822  "any data in tile group (%d bits read).\n", pos);
823  return AVERROR_INVALIDDATA;
824  }
825  // Must be byte-aligned at this point.
826  av_assert0(pos % 8 == 0);
827 
828  td->data_ref = av_buffer_ref(unit->data_ref);
829  if (!td->data_ref)
830  return AVERROR(ENOMEM);
831 
832  td->data = unit->data + pos / 8;
833  td->data_size = unit->data_size - pos / 8;
834 
835  return 0;
836 }
837 
839  CodedBitstreamUnit *unit)
840 {
841  CodedBitstreamAV1Context *priv = ctx->priv_data;
842  AV1RawOBU *obu;
843  GetBitContext gbc;
844  int err, start_pos, end_pos;
845 
846  err = ff_cbs_alloc_unit_content2(ctx, unit);
847  if (err < 0)
848  return err;
849  obu = unit->content;
850 
851  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
852  if (err < 0)
853  return err;
854 
855  err = cbs_av1_read_obu_header(ctx, &gbc, &obu->header);
856  if (err < 0)
857  return err;
858  av_assert0(obu->header.obu_type == unit->type);
859 
860  if (obu->header.obu_has_size_field) {
861  uint64_t obu_size;
862  err = cbs_av1_read_leb128(ctx, &gbc, "obu_size", &obu_size);
863  if (err < 0)
864  return err;
865  obu->obu_size = obu_size;
866  } else {
867  if (unit->data_size < 1 + obu->header.obu_extension_flag) {
868  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid OBU length: "
869  "unit too short (%"SIZE_SPECIFIER").\n", unit->data_size);
870  return AVERROR_INVALIDDATA;
871  }
872  obu->obu_size = unit->data_size - 1 - obu->header.obu_extension_flag;
873  }
874 
875  start_pos = get_bits_count(&gbc);
876 
877  if (obu->header.obu_extension_flag) {
880  priv->operating_point_idc) {
881  int in_temporal_layer =
882  (priv->operating_point_idc >> priv->temporal_id ) & 1;
883  int in_spatial_layer =
884  (priv->operating_point_idc >> (priv->spatial_id + 8)) & 1;
885  if (!in_temporal_layer || !in_spatial_layer) {
886  // Decoding will drop this OBU at this operating point.
887  }
888  }
889  }
890 
891  switch (obu->header.obu_type) {
893  {
894  err = cbs_av1_read_sequence_header_obu(ctx, &gbc,
895  &obu->obu.sequence_header);
896  if (err < 0)
897  return err;
898 
900  priv->sequence_header = NULL;
901 
903  if (!priv->sequence_header_ref)
904  return AVERROR(ENOMEM);
905  priv->sequence_header = &obu->obu.sequence_header;
906  }
907  break;
909  {
910  err = cbs_av1_read_temporal_delimiter_obu(ctx, &gbc);
911  if (err < 0)
912  return err;
913  }
914  break;
917  {
918  err = cbs_av1_read_frame_header_obu(ctx, &gbc,
919  &obu->obu.frame_header,
920  obu->header.obu_type ==
922  unit->data_ref);
923  if (err < 0)
924  return err;
925  }
926  break;
927  case AV1_OBU_TILE_GROUP:
928  {
929  err = cbs_av1_read_tile_group_obu(ctx, &gbc,
930  &obu->obu.tile_group);
931  if (err < 0)
932  return err;
933 
934  err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
935  &obu->obu.tile_group.tile_data);
936  if (err < 0)
937  return err;
938  }
939  break;
940  case AV1_OBU_FRAME:
941  {
942  err = cbs_av1_read_frame_obu(ctx, &gbc, &obu->obu.frame,
943  unit->data_ref);
944  if (err < 0)
945  return err;
946 
947  err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
948  &obu->obu.frame.tile_group.tile_data);
949  if (err < 0)
950  return err;
951  }
952  break;
953  case AV1_OBU_TILE_LIST:
954  {
955  err = cbs_av1_read_tile_list_obu(ctx, &gbc,
956  &obu->obu.tile_list);
957  if (err < 0)
958  return err;
959 
960  err = cbs_av1_ref_tile_data(ctx, unit, &gbc,
961  &obu->obu.tile_list.tile_data);
962  if (err < 0)
963  return err;
964  }
965  break;
966  case AV1_OBU_METADATA:
967  {
968  err = cbs_av1_read_metadata_obu(ctx, &gbc, &obu->obu.metadata);
969  if (err < 0)
970  return err;
971  }
972  break;
973  case AV1_OBU_PADDING:
974  {
975  err = cbs_av1_read_padding_obu(ctx, &gbc, &obu->obu.padding);
976  if (err < 0)
977  return err;
978  }
979  break;
980  default:
981  return AVERROR(ENOSYS);
982  }
983 
984  end_pos = get_bits_count(&gbc);
985  av_assert0(end_pos <= unit->data_size * 8);
986 
987  if (obu->obu_size > 0 &&
990  obu->header.obu_type != AV1_OBU_FRAME) {
991  int nb_bits = obu->obu_size * 8 + start_pos - end_pos;
992 
993  if (nb_bits <= 0)
994  return AVERROR_INVALIDDATA;
995 
996  err = cbs_av1_read_trailing_bits(ctx, &gbc, nb_bits);
997  if (err < 0)
998  return err;
999  }
1000 
1001  return 0;
1002 }
1003 
1005  CodedBitstreamUnit *unit,
1006  PutBitContext *pbc)
1007 {
1008  CodedBitstreamAV1Context *priv = ctx->priv_data;
1009  AV1RawOBU *obu = unit->content;
1010  PutBitContext pbc_tmp;
1011  AV1RawTileData *td;
1012  size_t header_size;
1013  int err, start_pos, end_pos, data_pos;
1014 
1015  // OBUs in the normal bitstream format must contain a size field
1016  // in every OBU (in annex B it is optional, but we don't support
1017  // writing that).
1018  obu->header.obu_has_size_field = 1;
1019 
1020  err = cbs_av1_write_obu_header(ctx, pbc, &obu->header);
1021  if (err < 0)
1022  return err;
1023 
1024  if (obu->header.obu_has_size_field) {
1025  pbc_tmp = *pbc;
1026  // Add space for the size field to fill later.
1027  put_bits32(pbc, 0);
1028  put_bits32(pbc, 0);
1029  }
1030 
1031  td = NULL;
1032  start_pos = put_bits_count(pbc);
1033 
1034  switch (obu->header.obu_type) {
1036  {
1037  err = cbs_av1_write_sequence_header_obu(ctx, pbc,
1038  &obu->obu.sequence_header);
1039  if (err < 0)
1040  return err;
1041 
1043  priv->sequence_header = NULL;
1044 
1046  if (!priv->sequence_header_ref)
1047  return AVERROR(ENOMEM);
1048  priv->sequence_header = &obu->obu.sequence_header;
1049  }
1050  break;
1052  {
1053  err = cbs_av1_write_temporal_delimiter_obu(ctx, pbc);
1054  if (err < 0)
1055  return err;
1056  }
1057  break;
1058  case AV1_OBU_FRAME_HEADER:
1060  {
1061  err = cbs_av1_write_frame_header_obu(ctx, pbc,
1062  &obu->obu.frame_header,
1063  obu->header.obu_type ==
1065  NULL);
1066  if (err < 0)
1067  return err;
1068  }
1069  break;
1070  case AV1_OBU_TILE_GROUP:
1071  {
1072  err = cbs_av1_write_tile_group_obu(ctx, pbc,
1073  &obu->obu.tile_group);
1074  if (err < 0)
1075  return err;
1076 
1077  td = &obu->obu.tile_group.tile_data;
1078  }
1079  break;
1080  case AV1_OBU_FRAME:
1081  {
1082  err = cbs_av1_write_frame_obu(ctx, pbc, &obu->obu.frame, NULL);
1083  if (err < 0)
1084  return err;
1085 
1086  td = &obu->obu.frame.tile_group.tile_data;
1087  }
1088  break;
1089  case AV1_OBU_TILE_LIST:
1090  {
1091  err = cbs_av1_write_tile_list_obu(ctx, pbc, &obu->obu.tile_list);
1092  if (err < 0)
1093  return err;
1094 
1095  td = &obu->obu.tile_list.tile_data;
1096  }
1097  break;
1098  case AV1_OBU_METADATA:
1099  {
1100  err = cbs_av1_write_metadata_obu(ctx, pbc, &obu->obu.metadata);
1101  if (err < 0)
1102  return err;
1103  }
1104  break;
1105  case AV1_OBU_PADDING:
1106  {
1107  err = cbs_av1_write_padding_obu(ctx, pbc, &obu->obu.padding);
1108  if (err < 0)
1109  return err;
1110  }
1111  break;
1112  default:
1113  return AVERROR(ENOSYS);
1114  }
1115 
1116  end_pos = put_bits_count(pbc);
1117  header_size = (end_pos - start_pos + 7) / 8;
1118  if (td) {
1119  obu->obu_size = header_size + td->data_size;
1120  } else if (header_size > 0) {
1121  // Add trailing bits and recalculate.
1122  err = cbs_av1_write_trailing_bits(ctx, pbc, 8 - end_pos % 8);
1123  if (err < 0)
1124  return err;
1125  end_pos = put_bits_count(pbc);
1126  obu->obu_size = header_size = (end_pos - start_pos + 7) / 8;
1127  } else {
1128  // Empty OBU.
1129  obu->obu_size = 0;
1130  }
1131 
1132  end_pos = put_bits_count(pbc);
1133  // Must now be byte-aligned.
1134  av_assert0(end_pos % 8 == 0);
1135  flush_put_bits(pbc);
1136  start_pos /= 8;
1137  end_pos /= 8;
1138 
1139  *pbc = pbc_tmp;
1140  err = cbs_av1_write_leb128(ctx, pbc, "obu_size", obu->obu_size);
1141  if (err < 0)
1142  return err;
1143 
1144  data_pos = put_bits_count(pbc) / 8;
1145  flush_put_bits(pbc);
1146  av_assert0(data_pos <= start_pos);
1147 
1148  if (8 * obu->obu_size > put_bits_left(pbc))
1149  return AVERROR(ENOSPC);
1150 
1151  if (obu->obu_size > 0) {
1152  memmove(pbc->buf + data_pos,
1153  pbc->buf + start_pos, header_size);
1154  skip_put_bytes(pbc, header_size);
1155 
1156  if (td) {
1157  memcpy(pbc->buf + data_pos + header_size,
1158  td->data, td->data_size);
1159  skip_put_bytes(pbc, td->data_size);
1160  }
1161  }
1162 
1163  // OBU data must be byte-aligned.
1164  av_assert0(put_bits_count(pbc) % 8 == 0);
1165 
1166  return 0;
1167 }
1168 
1170  CodedBitstreamFragment *frag)
1171 {
1172  size_t size, pos;
1173  int i;
1174 
1175  size = 0;
1176  for (i = 0; i < frag->nb_units; i++)
1177  size += frag->units[i].data_size;
1178 
1180  if (!frag->data_ref)
1181  return AVERROR(ENOMEM);
1182  frag->data = frag->data_ref->data;
1183  memset(frag->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1184 
1185  pos = 0;
1186  for (i = 0; i < frag->nb_units; i++) {
1187  memcpy(frag->data + pos, frag->units[i].data,
1188  frag->units[i].data_size);
1189  pos += frag->units[i].data_size;
1190  }
1191  av_assert0(pos == size);
1192  frag->data_size = size;
1193 
1194  return 0;
1195 }
1196 
1198 {
1199  CodedBitstreamAV1Context *priv = ctx->priv_data;
1200 
1203 }
1204 
1205 static void cbs_av1_free_metadata(void *unit, uint8_t *content)
1206 {
1207  AV1RawOBU *obu = (AV1RawOBU*)content;
1208  AV1RawMetadata *md;
1209 
1211  md = &obu->obu.metadata;
1212 
1213  switch (md->metadata_type) {
1216  break;
1217  }
1218 }
1219 
1225 
1227  obu.tile_group.tile_data.data),
1231  obu.tile_list.tile_data.data),
1233  obu.padding.payload),
1234 
1237 
1239 };
1240 
1243 
1244  .priv_data_size = sizeof(CodedBitstreamAV1Context),
1245 
1246  .unit_types = cbs_av1_unit_types,
1247 
1252 
1253  .close = &cbs_av1_close,
1254 };
int ff_cbs_alloc_unit_content2(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Allocate a new internal content buffer matching the type of the unit.
Definition: cbs.c:847
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:149
#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:218
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:349
AVBufferRef * sequence_header_ref
Definition: cbs_av1.h:420
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:70
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:1197
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
#define CBS_UNIT_TYPE_COMPLEX(type, structure, free_func)
Definition: cbs_internal.h:185
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
#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:208
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:117
uint8_t
uint8_t * data
Definition: cbs_av1.h:286
static int cbs_av1_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_av1.c:838
static void cbs_av1_free_metadata(void *unit, uint8_t *content)
Definition: cbs_av1.c:1205
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:160
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
const CodedBitstreamUnitTypeDescriptor * unit_types
Definition: cbs_internal.h:93
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define CBS_UNIT_TYPE_INTERNAL_REF(type, structure, ref_field)
Definition: cbs_internal.h:177
Coded bitstream unit structure.
Definition: cbs.h:66
ptrdiff_t size
Definition: opengl_enc.c:100
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:103
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:164
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:77
#define av_log(a,...)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:131
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:111
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#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:121
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:107
AV1RawTileData tile_data
Definition: cbs_av1.h:296
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().
uint8_t bits
Definition: vp3data.h:202
union AV1RawOBU::@26 obu
#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:175
const CodedBitstreamType ff_cbs_type_av1
Definition: cbs_av1.c:1241
uint8_t obu_extension_flag
Definition: cbs_av1.h:32
#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
#define CBS_UNIT_TYPE_POD(type, structure)
Definition: cbs_internal.h:171
static int cbs_av1_write_obu(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_av1.c:1004
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:1169
uint8_t w
Definition: llviddspenc.c:38
union AV1RawMetadata::@25 metadata
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:812
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:124
size_t data_size
Definition: cbs_av1.h:288
#define CBS_UNIT_TYPE_END_OF_LIST
Definition: cbs_internal.h:192
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:118
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:170
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:108
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:87
AV1RawSequenceHeader * sequence_header
Definition: cbs_av1.h:419
int(* read_unit)(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_internal.h:106
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:287
void * priv_data
Internal codec-specific data.
Definition: cbs.h:191
AV1RawMetadataITUTT35 itut_t35
Definition: cbs_av1.h:375
uint8_t * payload
Definition: cbs_av1.h:381
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:100
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:94
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
static const CodedBitstreamUnitTypeDescriptor cbs_av1_unit_types[]
Definition: cbs_av1.c:1220
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
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:141
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:82
const char * name
Definition: opengl_enc.c:102
static uint8_t tmp[11]
Definition: aes_ctr.c:26