FFmpeg  4.3
cbs_av1_syntax_template.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 
20  AV1RawOBUHeader *current)
21 {
22  int err;
23 
24  HEADER("OBU header");
25 
26  fc(1, obu_forbidden_bit, 0, 0);
27 
28  fc(4, obu_type, 0, AV1_OBU_PADDING);
29  flag(obu_extension_flag);
30  flag(obu_has_size_field);
31 
32  fc(1, obu_reserved_1bit, 0, 0);
33 
34  if (current->obu_extension_flag) {
35  fb(3, temporal_id);
36  fb(2, spatial_id);
37  fc(3, extension_header_reserved_3bits, 0, 0);
38  }
39 
40  return 0;
41 }
42 
43 static int FUNC(trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw, int nb_bits)
44 {
45  int err;
46 
47  av_assert0(nb_bits > 0);
48 
49  fixed(1, trailing_one_bit, 1);
50  --nb_bits;
51 
52  while (nb_bits > 0) {
53  fixed(1, trailing_zero_bit, 0);
54  --nb_bits;
55  }
56 
57  return 0;
58 }
59 
61 {
62  int err;
63 
64  while (byte_alignment(rw) != 0)
65  fixed(1, zero_bit, 0);
66 
67  return 0;
68 }
69 
71  AV1RawColorConfig *current, int seq_profile)
72 {
74  int err;
75 
76  flag(high_bitdepth);
77 
78  if (seq_profile == FF_PROFILE_AV1_PROFESSIONAL &&
79  current->high_bitdepth) {
80  flag(twelve_bit);
81  priv->bit_depth = current->twelve_bit ? 12 : 10;
82  } else {
83  priv->bit_depth = current->high_bitdepth ? 10 : 8;
84  }
85 
86  if (seq_profile == FF_PROFILE_AV1_HIGH)
87  infer(mono_chrome, 0);
88  else
89  flag(mono_chrome);
90  priv->num_planes = current->mono_chrome ? 1 : 3;
91 
92  flag(color_description_present_flag);
93  if (current->color_description_present_flag) {
94  fb(8, color_primaries);
96  fb(8, matrix_coefficients);
97  } else {
100  infer(matrix_coefficients, AVCOL_SPC_UNSPECIFIED);
101  }
102 
103  if (current->mono_chrome) {
104  flag(color_range);
105 
106  infer(subsampling_x, 1);
107  infer(subsampling_y, 1);
108  infer(chroma_sample_position, AV1_CSP_UNKNOWN);
109  infer(separate_uv_delta_q, 0);
110 
111  } else if (current->color_primaries == AVCOL_PRI_BT709 &&
112  current->transfer_characteristics == AVCOL_TRC_IEC61966_2_1 &&
113  current->matrix_coefficients == AVCOL_SPC_RGB) {
114  infer(color_range, 1);
115  infer(subsampling_x, 0);
116  infer(subsampling_y, 0);
117  flag(separate_uv_delta_q);
118 
119  } else {
120  flag(color_range);
121 
122  if (seq_profile == FF_PROFILE_AV1_MAIN) {
123  infer(subsampling_x, 1);
124  infer(subsampling_y, 1);
125  } else if (seq_profile == FF_PROFILE_AV1_HIGH) {
126  infer(subsampling_x, 0);
127  infer(subsampling_y, 0);
128  } else {
129  if (priv->bit_depth == 12) {
130  fb(1, subsampling_x);
131  if (current->subsampling_x)
132  fb(1, subsampling_y);
133  else
134  infer(subsampling_y, 0);
135  } else {
136  infer(subsampling_x, 1);
137  infer(subsampling_y, 0);
138  }
139  }
140  if (current->subsampling_x && current->subsampling_y) {
141  fc(2, chroma_sample_position, AV1_CSP_UNKNOWN,
143  }
144 
145  flag(separate_uv_delta_q);
146  }
147 
148  return 0;
149 }
150 
152  AV1RawTimingInfo *current)
153 {
154  int err;
155 
156  fc(32, num_units_in_display_tick, 1, MAX_UINT_BITS(32));
157  fc(32, time_scale, 1, MAX_UINT_BITS(32));
158 
159  flag(equal_picture_interval);
160  if (current->equal_picture_interval)
161  uvlc(num_ticks_per_picture_minus_1, 0, MAX_UINT_BITS(32) - 1);
162 
163  return 0;
164 }
165 
167  AV1RawDecoderModelInfo *current)
168 {
169  int err;
170 
171  fb(5, buffer_delay_length_minus_1);
172  fb(32, num_units_in_decoding_tick);
173  fb(5, buffer_removal_time_length_minus_1);
174  fb(5, frame_presentation_time_length_minus_1);
175 
176  return 0;
177 }
178 
180  AV1RawSequenceHeader *current)
181 {
182  int i, err;
183 
184  HEADER("Sequence Header");
185 
186  fc(3, seq_profile, FF_PROFILE_AV1_MAIN,
188  flag(still_picture);
189  flag(reduced_still_picture_header);
190 
191  if (current->reduced_still_picture_header) {
192  infer(timing_info_present_flag, 0);
193  infer(decoder_model_info_present_flag, 0);
194  infer(initial_display_delay_present_flag, 0);
195  infer(operating_points_cnt_minus_1, 0);
196  infer(operating_point_idc[0], 0);
197 
198  fb(5, seq_level_idx[0]);
199 
200  infer(seq_tier[0], 0);
201  infer(decoder_model_present_for_this_op[0], 0);
202  infer(initial_display_delay_present_for_this_op[0], 0);
203 
204  } else {
205  flag(timing_info_present_flag);
206  if (current->timing_info_present_flag) {
207  CHECK(FUNC(timing_info)(ctx, rw, &current->timing_info));
208 
209  flag(decoder_model_info_present_flag);
210  if (current->decoder_model_info_present_flag) {
212  (ctx, rw, &current->decoder_model_info));
213  }
214  } else {
215  infer(decoder_model_info_present_flag, 0);
216  }
217 
218  flag(initial_display_delay_present_flag);
219 
220  fb(5, operating_points_cnt_minus_1);
221  for (i = 0; i <= current->operating_points_cnt_minus_1; i++) {
222  fbs(12, operating_point_idc[i], 1, i);
223  fbs(5, seq_level_idx[i], 1, i);
224 
225  if (current->seq_level_idx[i] > 7)
226  flags(seq_tier[i], 1, i);
227  else
228  infer(seq_tier[i], 0);
229 
230  if (current->decoder_model_info_present_flag) {
231  flags(decoder_model_present_for_this_op[i], 1, i);
232  if (current->decoder_model_present_for_this_op[i]) {
233  int n = current->decoder_model_info.buffer_delay_length_minus_1 + 1;
234  fbs(n, decoder_buffer_delay[i], 1, i);
235  fbs(n, encoder_buffer_delay[i], 1, i);
236  flags(low_delay_mode_flag[i], 1, i);
237  }
238  } else {
239  infer(decoder_model_present_for_this_op[i], 0);
240  }
241 
242  if (current->initial_display_delay_present_flag) {
243  flags(initial_display_delay_present_for_this_op[i], 1, i);
244  if (current->initial_display_delay_present_for_this_op[i])
245  fbs(4, initial_display_delay_minus_1[i], 1, i);
246  }
247  }
248  }
249 
250  fb(4, frame_width_bits_minus_1);
251  fb(4, frame_height_bits_minus_1);
252 
253  fb(current->frame_width_bits_minus_1 + 1, max_frame_width_minus_1);
254  fb(current->frame_height_bits_minus_1 + 1, max_frame_height_minus_1);
255 
256  if (current->reduced_still_picture_header)
257  infer(frame_id_numbers_present_flag, 0);
258  else
259  flag(frame_id_numbers_present_flag);
260  if (current->frame_id_numbers_present_flag) {
261  fb(4, delta_frame_id_length_minus_2);
262  fb(3, additional_frame_id_length_minus_1);
263  }
264 
265  flag(use_128x128_superblock);
266  flag(enable_filter_intra);
267  flag(enable_intra_edge_filter);
268 
269  if (current->reduced_still_picture_header) {
270  infer(enable_interintra_compound, 0);
271  infer(enable_masked_compound, 0);
272  infer(enable_warped_motion, 0);
273  infer(enable_dual_filter, 0);
274  infer(enable_order_hint, 0);
275  infer(enable_jnt_comp, 0);
276  infer(enable_ref_frame_mvs, 0);
277 
278  infer(seq_force_screen_content_tools,
280  infer(seq_force_integer_mv,
282  } else {
283  flag(enable_interintra_compound);
284  flag(enable_masked_compound);
285  flag(enable_warped_motion);
286  flag(enable_dual_filter);
287 
288  flag(enable_order_hint);
289  if (current->enable_order_hint) {
290  flag(enable_jnt_comp);
291  flag(enable_ref_frame_mvs);
292  } else {
293  infer(enable_jnt_comp, 0);
294  infer(enable_ref_frame_mvs, 0);
295  }
296 
297  flag(seq_choose_screen_content_tools);
298  if (current->seq_choose_screen_content_tools)
299  infer(seq_force_screen_content_tools,
301  else
302  fb(1, seq_force_screen_content_tools);
303  if (current->seq_force_screen_content_tools > 0) {
304  flag(seq_choose_integer_mv);
305  if (current->seq_choose_integer_mv)
306  infer(seq_force_integer_mv,
308  else
309  fb(1, seq_force_integer_mv);
310  } else {
311  infer(seq_force_integer_mv, AV1_SELECT_INTEGER_MV);
312  }
313 
314  if (current->enable_order_hint)
315  fb(3, order_hint_bits_minus_1);
316  }
317 
318  flag(enable_superres);
319  flag(enable_cdef);
320  flag(enable_restoration);
321 
322  CHECK(FUNC(color_config)(ctx, rw, &current->color_config,
323  current->seq_profile));
324 
325  flag(film_grain_params_present);
326 
327  return 0;
328 }
329 
331 {
333 
334  HEADER("Temporal Delimiter");
335 
336  priv->seen_frame_header = 0;
337 
338  return 0;
339 }
340 
342  AV1RawFrameHeader *current)
343 {
345  const AV1RawSequenceHeader *seq = priv->sequence_header;
346  static const uint8_t ref_frame_list[AV1_NUM_REF_FRAMES - 2] = {
349  };
350  int8_t ref_frame_idx[AV1_REFS_PER_FRAME], used_frame[AV1_NUM_REF_FRAMES];
351  int8_t shifted_order_hints[AV1_NUM_REF_FRAMES];
352  int cur_frame_hint, latest_order_hint, earliest_order_hint, ref;
353  int i, j;
354 
355  for (i = 0; i < AV1_REFS_PER_FRAME; i++)
356  ref_frame_idx[i] = -1;
357  ref_frame_idx[AV1_REF_FRAME_LAST - AV1_REF_FRAME_LAST] = current->last_frame_idx;
358  ref_frame_idx[AV1_REF_FRAME_GOLDEN - AV1_REF_FRAME_LAST] = current->golden_frame_idx;
359 
360  for (i = 0; i < AV1_NUM_REF_FRAMES; i++)
361  used_frame[i] = 0;
362  used_frame[current->last_frame_idx] = 1;
363  used_frame[current->golden_frame_idx] = 1;
364 
365  cur_frame_hint = 1 << (seq->order_hint_bits_minus_1);
366  for (i = 0; i < AV1_NUM_REF_FRAMES; i++)
367  shifted_order_hints[i] = cur_frame_hint +
369  current->order_hint);
370 
371  latest_order_hint = shifted_order_hints[current->last_frame_idx];
372  earliest_order_hint = shifted_order_hints[current->golden_frame_idx];
373 
374  ref = -1;
375  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
376  int hint = shifted_order_hints[i];
377  if (!used_frame[i] && hint >= cur_frame_hint &&
378  (ref < 0 || hint >= latest_order_hint)) {
379  ref = i;
380  latest_order_hint = hint;
381  }
382  }
383  if (ref >= 0) {
384  ref_frame_idx[AV1_REF_FRAME_ALTREF - AV1_REF_FRAME_LAST] = ref;
385  used_frame[ref] = 1;
386  }
387 
388  ref = -1;
389  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
390  int hint = shifted_order_hints[i];
391  if (!used_frame[i] && hint >= cur_frame_hint &&
392  (ref < 0 || hint < earliest_order_hint)) {
393  ref = i;
394  earliest_order_hint = hint;
395  }
396  }
397  if (ref >= 0) {
398  ref_frame_idx[AV1_REF_FRAME_BWDREF - AV1_REF_FRAME_LAST] = ref;
399  used_frame[ref] = 1;
400  }
401 
402  ref = -1;
403  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
404  int hint = shifted_order_hints[i];
405  if (!used_frame[i] && hint >= cur_frame_hint &&
406  (ref < 0 || hint < earliest_order_hint)) {
407  ref = i;
408  earliest_order_hint = hint;
409  }
410  }
411  if (ref >= 0) {
412  ref_frame_idx[AV1_REF_FRAME_ALTREF2 - AV1_REF_FRAME_LAST] = ref;
413  used_frame[ref] = 1;
414  }
415 
416  for (i = 0; i < AV1_REFS_PER_FRAME - 2; i++) {
417  int ref_frame = ref_frame_list[i];
418  if (ref_frame_idx[ref_frame - AV1_REF_FRAME_LAST] < 0 ) {
419  ref = -1;
420  for (j = 0; j < AV1_NUM_REF_FRAMES; j++) {
421  int hint = shifted_order_hints[j];
422  if (!used_frame[j] && hint < cur_frame_hint &&
423  (ref < 0 || hint >= latest_order_hint)) {
424  ref = j;
425  latest_order_hint = hint;
426  }
427  }
428  if (ref >= 0) {
429  ref_frame_idx[ref_frame - AV1_REF_FRAME_LAST] = ref;
430  used_frame[ref] = 1;
431  }
432  }
433  }
434 
435  ref = -1;
436  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
437  int hint = shifted_order_hints[i];
438  if (ref < 0 || hint < earliest_order_hint) {
439  ref = i;
440  earliest_order_hint = hint;
441  }
442  }
443  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
444  if (ref_frame_idx[i] < 0)
445  ref_frame_idx[i] = ref;
446  infer(ref_frame_idx[i], ref_frame_idx[i]);
447  }
448 
449  return 0;
450 }
451 
453  AV1RawFrameHeader *current)
454 {
456  const AV1RawSequenceHeader *seq = priv->sequence_header;
457  int denom, err;
458 
459  if (seq->enable_superres)
460  flag(use_superres);
461  else
462  infer(use_superres, 0);
463 
464  if (current->use_superres) {
465  fb(3, coded_denom);
466  denom = current->coded_denom + AV1_SUPERRES_DENOM_MIN;
467  } else {
468  denom = AV1_SUPERRES_NUM;
469  }
470 
471  priv->upscaled_width = priv->frame_width;
472  priv->frame_width = (priv->upscaled_width * AV1_SUPERRES_NUM +
473  denom / 2) / denom;
474 
475  return 0;
476 }
477 
479  AV1RawFrameHeader *current)
480 {
482  const AV1RawSequenceHeader *seq = priv->sequence_header;
483  int err;
484 
485  if (current->frame_size_override_flag) {
486  fb(seq->frame_width_bits_minus_1 + 1, frame_width_minus_1);
487  fb(seq->frame_height_bits_minus_1 + 1, frame_height_minus_1);
488 
489  priv->frame_width = current->frame_width_minus_1 + 1;
490  priv->frame_height = current->frame_height_minus_1 + 1;
491  } else {
492  priv->frame_width = seq->max_frame_width_minus_1 + 1;
493  priv->frame_height = seq->max_frame_height_minus_1 + 1;
494  }
495 
496  CHECK(FUNC(superres_params)(ctx, rw, current));
497 
498  return 0;
499 }
500 
502  AV1RawFrameHeader *current)
503 {
505  int err;
506 
507  flag(render_and_frame_size_different);
508 
509  if (current->render_and_frame_size_different) {
510  fb(16, render_width_minus_1);
511  fb(16, render_height_minus_1);
512 
513  priv->render_width = current->render_width_minus_1 + 1;
514  priv->render_height = current->render_height_minus_1 + 1;
515  } else {
516  priv->render_width = priv->upscaled_width;
517  priv->render_height = priv->frame_height;
518  }
519 
520  return 0;
521 }
522 
524  AV1RawFrameHeader *current)
525 {
527  int i, err;
528 
529  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
530  flags(found_ref[i], 1, i);
531  if (current->found_ref[i]) {
533  &priv->ref[current->ref_frame_idx[i]];
534 
535  if (!ref->valid) {
536  av_log(ctx->log_ctx, AV_LOG_ERROR,
537  "Missing reference frame needed for frame size "
538  "(ref = %d, ref_frame_idx = %d).\n",
539  i, current->ref_frame_idx[i]);
540  return AVERROR_INVALIDDATA;
541  }
542 
543  priv->upscaled_width = ref->upscaled_width;
544  priv->frame_width = ref->frame_width;
545  priv->frame_height = ref->frame_height;
546  priv->render_width = ref->render_width;
547  priv->render_height = ref->render_height;
548  break;
549  }
550  }
551 
552  if (i >= AV1_REFS_PER_FRAME) {
553  CHECK(FUNC(frame_size)(ctx, rw, current));
554  CHECK(FUNC(render_size)(ctx, rw, current));
555  } else {
556  CHECK(FUNC(superres_params)(ctx, rw, current));
557  }
558 
559  return 0;
560 }
561 
563  AV1RawFrameHeader *current)
564 {
565  int err;
566 
567  flag(is_filter_switchable);
568  if (current->is_filter_switchable)
571  else
573 
574  return 0;
575 }
576 
578  AV1RawFrameHeader *current)
579 {
581  const AV1RawSequenceHeader *seq = priv->sequence_header;
582  int mi_cols, mi_rows, sb_cols, sb_rows, sb_shift, sb_size;
583  int max_tile_width_sb, max_tile_height_sb, max_tile_area_sb;
584  int min_log2_tile_cols, max_log2_tile_cols, max_log2_tile_rows;
585  int min_log2_tiles, min_log2_tile_rows;
586  int i, err;
587 
588  mi_cols = 2 * ((priv->frame_width + 7) >> 3);
589  mi_rows = 2 * ((priv->frame_height + 7) >> 3);
590 
591  sb_cols = seq->use_128x128_superblock ? ((mi_cols + 31) >> 5)
592  : ((mi_cols + 15) >> 4);
593  sb_rows = seq->use_128x128_superblock ? ((mi_rows + 31) >> 5)
594  : ((mi_rows + 15) >> 4);
595 
596  sb_shift = seq->use_128x128_superblock ? 5 : 4;
597  sb_size = sb_shift + 2;
598 
599  max_tile_width_sb = AV1_MAX_TILE_WIDTH >> sb_size;
600  max_tile_area_sb = AV1_MAX_TILE_AREA >> (2 * sb_size);
601 
602  min_log2_tile_cols = cbs_av1_tile_log2(max_tile_width_sb, sb_cols);
603  max_log2_tile_cols = cbs_av1_tile_log2(1, FFMIN(sb_cols, AV1_MAX_TILE_COLS));
604  max_log2_tile_rows = cbs_av1_tile_log2(1, FFMIN(sb_rows, AV1_MAX_TILE_ROWS));
605  min_log2_tiles = FFMAX(min_log2_tile_cols,
606  cbs_av1_tile_log2(max_tile_area_sb, sb_rows * sb_cols));
607 
608  flag(uniform_tile_spacing_flag);
609 
610  if (current->uniform_tile_spacing_flag) {
611  int tile_width_sb, tile_height_sb;
612 
613  increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
614 
615  tile_width_sb = (sb_cols + (1 << current->tile_cols_log2) - 1) >>
616  current->tile_cols_log2;
617  current->tile_cols = (sb_cols + tile_width_sb - 1) / tile_width_sb;
618 
619  min_log2_tile_rows = FFMAX(min_log2_tiles - current->tile_cols_log2, 0);
620 
621  increment(tile_rows_log2, min_log2_tile_rows, max_log2_tile_rows);
622 
623  tile_height_sb = (sb_rows + (1 << current->tile_rows_log2) - 1) >>
624  current->tile_rows_log2;
625  current->tile_rows = (sb_rows + tile_height_sb - 1) / tile_height_sb;
626 
627  } else {
628  int widest_tile_sb, start_sb, size_sb, max_width, max_height;
629 
630  widest_tile_sb = 0;
631 
632  start_sb = 0;
633  for (i = 0; start_sb < sb_cols && i < AV1_MAX_TILE_COLS; i++) {
634  max_width = FFMIN(sb_cols - start_sb, max_tile_width_sb);
635  ns(max_width, width_in_sbs_minus_1[i], 1, i);
636  size_sb = current->width_in_sbs_minus_1[i] + 1;
637  widest_tile_sb = FFMAX(size_sb, widest_tile_sb);
638  start_sb += size_sb;
639  }
640  current->tile_cols_log2 = cbs_av1_tile_log2(1, i);
641  current->tile_cols = i;
642 
643  if (min_log2_tiles > 0)
644  max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
645  else
646  max_tile_area_sb = sb_rows * sb_cols;
647  max_tile_height_sb = FFMAX(max_tile_area_sb / widest_tile_sb, 1);
648 
649  start_sb = 0;
650  for (i = 0; start_sb < sb_rows && i < AV1_MAX_TILE_ROWS; i++) {
651  max_height = FFMIN(sb_rows - start_sb, max_tile_height_sb);
652  ns(max_height, height_in_sbs_minus_1[i], 1, i);
653  size_sb = current->height_in_sbs_minus_1[i] + 1;
654  start_sb += size_sb;
655  }
656  current->tile_rows_log2 = cbs_av1_tile_log2(1, i);
657  current->tile_rows = i;
658  }
659 
660  if (current->tile_cols_log2 > 0 ||
661  current->tile_rows_log2 > 0) {
662  fb(current->tile_cols_log2 + current->tile_rows_log2,
663  context_update_tile_id);
664  fb(2, tile_size_bytes_minus1);
665  } else {
666  infer(context_update_tile_id, 0);
667  }
668 
669  priv->tile_cols = current->tile_cols;
670  priv->tile_rows = current->tile_rows;
671 
672  return 0;
673 }
674 
676  AV1RawFrameHeader *current)
677 {
679  const AV1RawSequenceHeader *seq = priv->sequence_header;
680  int err;
681 
682  fb(8, base_q_idx);
683 
684  delta_q(delta_q_y_dc);
685 
686  if (priv->num_planes > 1) {
688  flag(diff_uv_delta);
689  else
690  infer(diff_uv_delta, 0);
691 
692  delta_q(delta_q_u_dc);
693  delta_q(delta_q_u_ac);
694 
695  if (current->diff_uv_delta) {
696  delta_q(delta_q_v_dc);
697  delta_q(delta_q_v_ac);
698  } else {
699  infer(delta_q_v_dc, current->delta_q_u_dc);
700  infer(delta_q_v_ac, current->delta_q_u_ac);
701  }
702  } else {
703  infer(delta_q_u_dc, 0);
704  infer(delta_q_u_ac, 0);
705  infer(delta_q_v_dc, 0);
706  infer(delta_q_v_ac, 0);
707  }
708 
709  flag(using_qmatrix);
710  if (current->using_qmatrix) {
711  fb(4, qm_y);
712  fb(4, qm_u);
714  fb(4, qm_v);
715  else
716  infer(qm_v, current->qm_u);
717  }
718 
719  return 0;
720 }
721 
723  AV1RawFrameHeader *current)
724 {
725  static const uint8_t bits[AV1_SEG_LVL_MAX] = { 8, 6, 6, 6, 6, 3, 0, 0 };
726  static const uint8_t sign[AV1_SEG_LVL_MAX] = { 1, 1, 1, 1, 1, 0, 0, 0 };
727  int i, j, err;
728 
729  flag(segmentation_enabled);
730 
731  if (current->segmentation_enabled) {
732  if (current->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
733  infer(segmentation_update_map, 1);
734  infer(segmentation_temporal_update, 0);
735  infer(segmentation_update_data, 1);
736  } else {
737  flag(segmentation_update_map);
738  if (current->segmentation_update_map)
739  flag(segmentation_temporal_update);
740  else
741  infer(segmentation_temporal_update, 0);
742  flag(segmentation_update_data);
743  }
744 
745  if (current->segmentation_update_data) {
746  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
747  for (j = 0; j < AV1_SEG_LVL_MAX; j++) {
748  flags(feature_enabled[i][j], 2, i, j);
749 
750  if (current->feature_enabled[i][j] && bits[j] > 0) {
751  if (sign[j])
752  sus(1 + bits[j], feature_value[i][j], 2, i, j);
753  else
754  fbs(bits[j], feature_value[i][j], 2, i, j);
755  } else {
756  infer(feature_value[i][j], 0);
757  }
758  }
759  }
760  }
761  } else {
762  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
763  for (j = 0; j < AV1_SEG_LVL_MAX; j++) {
764  infer(feature_enabled[i][j], 0);
765  infer(feature_value[i][j], 0);
766  }
767  }
768  }
769 
770  return 0;
771 }
772 
774  AV1RawFrameHeader *current)
775 {
776  int err;
777 
778  if (current->base_q_idx > 0)
779  flag(delta_q_present);
780  else
781  infer(delta_q_present, 0);
782 
783  if (current->delta_q_present)
784  fb(2, delta_q_res);
785 
786  return 0;
787 }
788 
790  AV1RawFrameHeader *current)
791 {
792  int err;
793 
794  if (current->delta_q_present) {
795  if (!current->allow_intrabc)
796  flag(delta_lf_present);
797  else
798  infer(delta_lf_present, 0);
799  if (current->delta_lf_present) {
800  fb(2, delta_lf_res);
801  flag(delta_lf_multi);
802  } else {
803  infer(delta_lf_res, 0);
804  infer(delta_lf_multi, 0);
805  }
806  } else {
807  infer(delta_lf_present, 0);
808  infer(delta_lf_res, 0);
809  infer(delta_lf_multi, 0);
810  }
811 
812  return 0;
813 }
814 
816  AV1RawFrameHeader *current)
817 {
819  int i, err;
820 
821  if (priv->coded_lossless || current->allow_intrabc) {
822  infer(loop_filter_level[0], 0);
823  infer(loop_filter_level[1], 0);
824  infer(loop_filter_ref_deltas[AV1_REF_FRAME_INTRA], 1);
825  infer(loop_filter_ref_deltas[AV1_REF_FRAME_LAST], 0);
826  infer(loop_filter_ref_deltas[AV1_REF_FRAME_LAST2], 0);
827  infer(loop_filter_ref_deltas[AV1_REF_FRAME_LAST3], 0);
828  infer(loop_filter_ref_deltas[AV1_REF_FRAME_BWDREF], 0);
829  infer(loop_filter_ref_deltas[AV1_REF_FRAME_GOLDEN], -1);
830  infer(loop_filter_ref_deltas[AV1_REF_FRAME_ALTREF], -1);
831  infer(loop_filter_ref_deltas[AV1_REF_FRAME_ALTREF2], -1);
832  for (i = 0; i < 2; i++)
833  infer(loop_filter_mode_deltas[i], 0);
834  return 0;
835  }
836 
837  fb(6, loop_filter_level[0]);
838  fb(6, loop_filter_level[1]);
839 
840  if (priv->num_planes > 1) {
841  if (current->loop_filter_level[0] ||
842  current->loop_filter_level[1]) {
843  fb(6, loop_filter_level[2]);
844  fb(6, loop_filter_level[3]);
845  }
846  }
847 
848  fb(3, loop_filter_sharpness);
849 
850  flag(loop_filter_delta_enabled);
851  if (current->loop_filter_delta_enabled) {
852  flag(loop_filter_delta_update);
853  if (current->loop_filter_delta_update) {
854  for (i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) {
855  flags(update_ref_delta[i], 1, i);
856  if (current->update_ref_delta[i])
857  sus(1 + 6, loop_filter_ref_deltas[i], 1, i);
858  }
859  for (i = 0; i < 2; i++) {
860  flags(update_mode_delta[i], 1, i);
861  if (current->update_mode_delta[i])
862  sus(1 + 6, loop_filter_mode_deltas[i], 1, i);
863  }
864  }
865  }
866 
867  return 0;
868 }
869 
871  AV1RawFrameHeader *current)
872 {
874  const AV1RawSequenceHeader *seq = priv->sequence_header;
875  int i, err;
876 
877  if (priv->coded_lossless || current->allow_intrabc ||
878  !seq->enable_cdef) {
879  infer(cdef_damping_minus_3, 0);
880  infer(cdef_bits, 0);
881  infer(cdef_y_pri_strength[0], 0);
882  infer(cdef_y_sec_strength[0], 0);
883  infer(cdef_uv_pri_strength[0], 0);
884  infer(cdef_uv_sec_strength[0], 0);
885 
886  return 0;
887  }
888 
889  fb(2, cdef_damping_minus_3);
890  fb(2, cdef_bits);
891 
892  for (i = 0; i < (1 << current->cdef_bits); i++) {
893  fbs(4, cdef_y_pri_strength[i], 1, i);
894  fbs(2, cdef_y_sec_strength[i], 1, i);
895 
896  if (priv->num_planes > 1) {
897  fbs(4, cdef_uv_pri_strength[i], 1, i);
898  fbs(2, cdef_uv_sec_strength[i], 1, i);
899  }
900  }
901 
902  return 0;
903 }
904 
906  AV1RawFrameHeader *current)
907 {
909  const AV1RawSequenceHeader *seq = priv->sequence_header;
910  int uses_lr, uses_chroma_lr;
911  int i, err;
912 
913  if (priv->all_lossless || current->allow_intrabc ||
914  !seq->enable_restoration) {
915  return 0;
916  }
917 
918  uses_lr = uses_chroma_lr = 0;
919  for (i = 0; i < priv->num_planes; i++) {
920  fbs(2, lr_type[i], 1, i);
921 
922  if (current->lr_type[i] != 0) {
923  uses_lr = 1;
924  if (i > 0)
925  uses_chroma_lr = 1;
926  }
927  }
928 
929  if (uses_lr) {
930  if (seq->use_128x128_superblock)
931  increment(lr_unit_shift, 1, 2);
932  else
933  increment(lr_unit_shift, 0, 2);
934 
935  if(seq->color_config.subsampling_x &&
936  seq->color_config.subsampling_y && uses_chroma_lr) {
937  fb(1, lr_uv_shift);
938  } else {
939  infer(lr_uv_shift, 0);
940  }
941  }
942 
943  return 0;
944 }
945 
947  AV1RawFrameHeader *current)
948 {
950  int err;
951 
952  if (priv->coded_lossless)
953  infer(tx_mode, 0);
954  else
955  increment(tx_mode, 1, 2);
956 
957  return 0;
958 }
959 
961  AV1RawFrameHeader *current)
962 {
963  int err;
964 
965  if (current->frame_type == AV1_FRAME_INTRA_ONLY ||
966  current->frame_type == AV1_FRAME_KEY)
967  infer(reference_select, 0);
968  else
969  flag(reference_select);
970 
971  return 0;
972 }
973 
975  AV1RawFrameHeader *current)
976 {
978  const AV1RawSequenceHeader *seq = priv->sequence_header;
979  int skip_mode_allowed;
980  int err;
981 
982  if (current->frame_type == AV1_FRAME_KEY ||
983  current->frame_type == AV1_FRAME_INTRA_ONLY ||
984  !current->reference_select || !seq->enable_order_hint) {
985  skip_mode_allowed = 0;
986  } else {
987  int forward_idx, backward_idx;
988  int forward_hint, backward_hint;
989  int ref_hint, dist, i;
990 
991  forward_idx = -1;
992  backward_idx = -1;
993  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
994  ref_hint = priv->ref[current->ref_frame_idx[i]].order_hint;
995  dist = cbs_av1_get_relative_dist(seq, ref_hint,
996  current->order_hint);
997  if (dist < 0) {
998  if (forward_idx < 0 ||
999  cbs_av1_get_relative_dist(seq, ref_hint,
1000  forward_hint) > 0) {
1001  forward_idx = i;
1002  forward_hint = ref_hint;
1003  }
1004  } else if (dist > 0) {
1005  if (backward_idx < 0 ||
1006  cbs_av1_get_relative_dist(seq, ref_hint,
1007  backward_hint) < 0) {
1008  backward_idx = i;
1009  backward_hint = ref_hint;
1010  }
1011  }
1012  }
1013 
1014  if (forward_idx < 0) {
1015  skip_mode_allowed = 0;
1016  } else if (backward_idx >= 0) {
1017  skip_mode_allowed = 1;
1018  // Frames for skip mode are forward_idx and backward_idx.
1019  } else {
1020  int second_forward_idx;
1021  int second_forward_hint;
1022 
1023  second_forward_idx = -1;
1024  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
1025  ref_hint = priv->ref[current->ref_frame_idx[i]].order_hint;
1026  if (cbs_av1_get_relative_dist(seq, ref_hint,
1027  forward_hint) < 0) {
1028  if (second_forward_idx < 0 ||
1029  cbs_av1_get_relative_dist(seq, ref_hint,
1030  second_forward_hint) > 0) {
1031  second_forward_idx = i;
1032  second_forward_hint = ref_hint;
1033  }
1034  }
1035  }
1036 
1037  if (second_forward_idx < 0) {
1038  skip_mode_allowed = 0;
1039  } else {
1040  skip_mode_allowed = 1;
1041  // Frames for skip mode are forward_idx and second_forward_idx.
1042  }
1043  }
1044  }
1045 
1046  if (skip_mode_allowed)
1047  flag(skip_mode_present);
1048  else
1049  infer(skip_mode_present, 0);
1050 
1051  return 0;
1052 }
1053 
1055  AV1RawFrameHeader *current,
1056  int type, int ref, int idx)
1057 {
1058  uint32_t abs_bits, prec_bits, num_syms;
1059  int err;
1060 
1061  if (idx < 2) {
1063  abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS - !current->allow_high_precision_mv;
1064  prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS - !current->allow_high_precision_mv;
1065  } else {
1066  abs_bits = AV1_GM_ABS_TRANS_BITS;
1067  prec_bits = AV1_GM_TRANS_PREC_BITS;
1068  }
1069  } else {
1070  abs_bits = AV1_GM_ABS_ALPHA_BITS;
1071  prec_bits = AV1_GM_ALPHA_PREC_BITS;
1072  }
1073 
1074  num_syms = 2 * (1 << abs_bits) + 1;
1075  subexp(gm_params[ref][idx], num_syms, 2, ref, idx);
1076 
1077  // Actual gm_params value is not reconstructed here.
1078  (void)prec_bits;
1079 
1080  return 0;
1081 }
1082 
1084  AV1RawFrameHeader *current)
1085 {
1086  int ref, type;
1087  int err;
1088 
1089  if (current->frame_type == AV1_FRAME_KEY ||
1090  current->frame_type == AV1_FRAME_INTRA_ONLY)
1091  return 0;
1092 
1093  for (ref = AV1_REF_FRAME_LAST; ref <= AV1_REF_FRAME_ALTREF; ref++) {
1094  flags(is_global[ref], 1, ref);
1095  if (current->is_global[ref]) {
1096  flags(is_rot_zoom[ref], 1, ref);
1097  if (current->is_rot_zoom[ref]) {
1098  type = AV1_WARP_MODEL_ROTZOOM;
1099  } else {
1100  flags(is_translation[ref], 1, ref);
1101  type = current->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
1103  }
1104  } else {
1105  type = AV1_WARP_MODEL_IDENTITY;
1106  }
1107 
1108  if (type >= AV1_WARP_MODEL_ROTZOOM) {
1109  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 2));
1110  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 3));
1111  if (type == AV1_WARP_MODEL_AFFINE) {
1112  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 4));
1113  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 5));
1114  } else {
1115  // gm_params[ref][4] = -gm_params[ref][3]
1116  // gm_params[ref][5] = gm_params[ref][2]
1117  }
1118  }
1119  if (type >= AV1_WARP_MODEL_TRANSLATION) {
1120  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 0));
1121  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 1));
1122  }
1123  }
1124 
1125  return 0;
1126 }
1127 
1129  AV1RawFrameHeader *current)
1130 {
1132  const AV1RawSequenceHeader *seq = priv->sequence_header;
1133  int num_pos_luma, num_pos_chroma;
1134  int i, err;
1135 
1136  if (!seq->film_grain_params_present ||
1137  (!current->show_frame && !current->showable_frame))
1138  return 0;
1139 
1140  flag(apply_grain);
1141 
1142  if (!current->apply_grain)
1143  return 0;
1144 
1145  fb(16, grain_seed);
1146 
1147  if (current->frame_type == AV1_FRAME_INTER)
1148  flag(update_grain);
1149  else
1150  infer(update_grain, 1);
1151 
1152  if (!current->update_grain) {
1153  fb(3, film_grain_params_ref_idx);
1154  return 0;
1155  }
1156 
1157  fc(4, num_y_points, 0, 14);
1158  for (i = 0; i < current->num_y_points; i++) {
1159  fcs(8, point_y_value[i],
1160  i ? current->point_y_value[i - 1] + 1 : 0,
1161  MAX_UINT_BITS(8) - (current->num_y_points - i - 1),
1162  1, i);
1163  fbs(8, point_y_scaling[i], 1, i);
1164  }
1165 
1166  if (seq->color_config.mono_chrome)
1167  infer(chroma_scaling_from_luma, 0);
1168  else
1169  flag(chroma_scaling_from_luma);
1170 
1171  if (seq->color_config.mono_chrome ||
1172  current->chroma_scaling_from_luma ||
1173  (seq->color_config.subsampling_x == 1 &&
1174  seq->color_config.subsampling_y == 1 &&
1175  current->num_y_points == 0)) {
1176  infer(num_cb_points, 0);
1177  infer(num_cr_points, 0);
1178  } else {
1179  fc(4, num_cb_points, 0, 10);
1180  for (i = 0; i < current->num_cb_points; i++) {
1181  fcs(8, point_cb_value[i],
1182  i ? current->point_cb_value[i - 1] + 1 : 0,
1183  MAX_UINT_BITS(8) - (current->num_cb_points - i - 1),
1184  1, i);
1185  fbs(8, point_cb_scaling[i], 1, i);
1186  }
1187  fc(4, num_cr_points, 0, 10);
1188  for (i = 0; i < current->num_cr_points; i++) {
1189  fcs(8, point_cr_value[i],
1190  i ? current->point_cr_value[i - 1] + 1 : 0,
1191  MAX_UINT_BITS(8) - (current->num_cr_points - i - 1),
1192  1, i);
1193  fbs(8, point_cr_scaling[i], 1, i);
1194  }
1195  }
1196 
1197  fb(2, grain_scaling_minus_8);
1198  fb(2, ar_coeff_lag);
1199  num_pos_luma = 2 * current->ar_coeff_lag * (current->ar_coeff_lag + 1);
1200  if (current->num_y_points) {
1201  num_pos_chroma = num_pos_luma + 1;
1202  for (i = 0; i < num_pos_luma; i++)
1203  fbs(8, ar_coeffs_y_plus_128[i], 1, i);
1204  } else {
1205  num_pos_chroma = num_pos_luma;
1206  }
1207  if (current->chroma_scaling_from_luma || current->num_cb_points) {
1208  for (i = 0; i < num_pos_chroma; i++)
1209  fbs(8, ar_coeffs_cb_plus_128[i], 1, i);
1210  }
1211  if (current->chroma_scaling_from_luma || current->num_cr_points) {
1212  for (i = 0; i < num_pos_chroma; i++)
1213  fbs(8, ar_coeffs_cr_plus_128[i], 1, i);
1214  }
1215  fb(2, ar_coeff_shift_minus_6);
1216  fb(2, grain_scale_shift);
1217  if (current->num_cb_points) {
1218  fb(8, cb_mult);
1219  fb(8, cb_luma_mult);
1220  fb(9, cb_offset);
1221  }
1222  if (current->num_cr_points) {
1223  fb(8, cr_mult);
1224  fb(8, cr_luma_mult);
1225  fb(9, cr_offset);
1226  }
1227 
1228  flag(overlap_flag);
1229  flag(clip_to_restricted_range);
1230 
1231  return 0;
1232 }
1233 
1235  AV1RawFrameHeader *current)
1236 {
1238  const AV1RawSequenceHeader *seq;
1239  int id_len, diff_len, all_frames, frame_is_intra, order_hint_bits;
1240  int i, err;
1241 
1242  if (!priv->sequence_header) {
1243  av_log(ctx->log_ctx, AV_LOG_ERROR, "No sequence header available: "
1244  "unable to decode frame header.\n");
1245  return AVERROR_INVALIDDATA;
1246  }
1247  seq = priv->sequence_header;
1248 
1249  id_len = seq->additional_frame_id_length_minus_1 +
1251  all_frames = (1 << AV1_NUM_REF_FRAMES) - 1;
1252 
1253  if (seq->reduced_still_picture_header) {
1254  infer(show_existing_frame, 0);
1256  infer(show_frame, 1);
1257  infer(showable_frame, 0);
1258  frame_is_intra = 1;
1259 
1260  } else {
1261  flag(show_existing_frame);
1262 
1263  if (current->show_existing_frame) {
1265 
1266  fb(3, frame_to_show_map_idx);
1267  frame = &priv->ref[current->frame_to_show_map_idx];
1268 
1272  frame_presentation_time);
1273  }
1274 
1276  fb(id_len, display_frame_id);
1277 
1278  if (frame->frame_type == AV1_FRAME_KEY)
1279  infer(refresh_frame_flags, all_frames);
1280  else
1281  infer(refresh_frame_flags, 0);
1282 
1283  return 0;
1284  }
1285 
1286  fb(2, frame_type);
1287  frame_is_intra = (current->frame_type == AV1_FRAME_INTRA_ONLY ||
1288  current->frame_type == AV1_FRAME_KEY);
1289 
1290  flag(show_frame);
1291  if (current->show_frame &&
1295  frame_presentation_time);
1296  }
1297  if (current->show_frame)
1298  infer(showable_frame, current->frame_type != AV1_FRAME_KEY);
1299  else
1300  flag(showable_frame);
1301 
1302  if (current->frame_type == AV1_FRAME_SWITCH ||
1303  (current->frame_type == AV1_FRAME_KEY && current->show_frame))
1304  infer(error_resilient_mode, 1);
1305  else
1306  flag(error_resilient_mode);
1307  }
1308 
1309  if (current->frame_type == AV1_FRAME_KEY && current->show_frame) {
1310  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1311  priv->ref[i].valid = 0;
1312  priv->ref[i].order_hint = 0;
1313  }
1314  }
1315 
1316  flag(disable_cdf_update);
1317 
1318  if (seq->seq_force_screen_content_tools ==
1320  flag(allow_screen_content_tools);
1321  } else {
1322  infer(allow_screen_content_tools,
1324  }
1325  if (current->allow_screen_content_tools) {
1327  flag(force_integer_mv);
1328  else
1329  infer(force_integer_mv, seq->seq_force_integer_mv);
1330  } else {
1331  infer(force_integer_mv, 0);
1332  }
1333 
1334  if (seq->frame_id_numbers_present_flag) {
1335  fb(id_len, current_frame_id);
1336 
1337  diff_len = seq->delta_frame_id_length_minus_2 + 2;
1338  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1339  if (current->current_frame_id > (1 << diff_len)) {
1340  if (priv->ref[i].frame_id > current->current_frame_id ||
1341  priv->ref[i].frame_id < (current->current_frame_id -
1342  (1 << diff_len)))
1343  priv->ref[i].valid = 0;
1344  } else {
1345  if (priv->ref[i].frame_id > current->current_frame_id &&
1346  priv->ref[i].frame_id < ((1 << id_len) +
1347  current->current_frame_id -
1348  (1 << diff_len)))
1349  priv->ref[i].valid = 0;
1350  }
1351  }
1352  } else {
1353  infer(current_frame_id, 0);
1354  }
1355 
1356  if (current->frame_type == AV1_FRAME_SWITCH)
1357  infer(frame_size_override_flag, 1);
1358  else if(seq->reduced_still_picture_header)
1359  infer(frame_size_override_flag, 0);
1360  else
1361  flag(frame_size_override_flag);
1362 
1363  order_hint_bits =
1364  seq->enable_order_hint ? seq->order_hint_bits_minus_1 + 1 : 0;
1365  if (order_hint_bits > 0)
1366  fb(order_hint_bits, order_hint);
1367  else
1368  infer(order_hint, 0);
1369 
1370  if (frame_is_intra || current->error_resilient_mode)
1371  infer(primary_ref_frame, AV1_PRIMARY_REF_NONE);
1372  else
1373  fb(3, primary_ref_frame);
1374 
1376  flag(buffer_removal_time_present_flag);
1377  if (current->buffer_removal_time_present_flag) {
1378  for (i = 0; i <= seq->operating_points_cnt_minus_1; i++) {
1379  if (seq->decoder_model_present_for_this_op[i]) {
1380  int op_pt_idc = seq->operating_point_idc[i];
1381  int in_temporal_layer = (op_pt_idc >> priv->temporal_id ) & 1;
1382  int in_spatial_layer = (op_pt_idc >> (priv->spatial_id + 8)) & 1;
1383  if (seq->operating_point_idc[i] == 0 ||
1384  in_temporal_layer || in_spatial_layer) {
1386  buffer_removal_time[i], 1, i);
1387  }
1388  }
1389  }
1390  }
1391  }
1392 
1393  if (current->frame_type == AV1_FRAME_SWITCH ||
1394  (current->frame_type == AV1_FRAME_KEY && current->show_frame))
1395  infer(refresh_frame_flags, all_frames);
1396  else
1397  fb(8, refresh_frame_flags);
1398 
1399  if (!frame_is_intra || current->refresh_frame_flags != all_frames) {
1400  if (current->error_resilient_mode && seq->enable_order_hint) {
1401  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1402  fbs(order_hint_bits, ref_order_hint[i], 1, i);
1403  if (current->ref_order_hint[i] != priv->ref[i].order_hint)
1404  priv->ref[i].valid = 0;
1405  }
1406  }
1407  }
1408 
1409  if (current->frame_type == AV1_FRAME_KEY ||
1410  current->frame_type == AV1_FRAME_INTRA_ONLY) {
1411  CHECK(FUNC(frame_size)(ctx, rw, current));
1412  CHECK(FUNC(render_size)(ctx, rw, current));
1413 
1414  if (current->allow_screen_content_tools &&
1415  priv->upscaled_width == priv->frame_width)
1416  flag(allow_intrabc);
1417  else
1418  infer(allow_intrabc, 0);
1419 
1420  } else {
1421  if (!seq->enable_order_hint) {
1422  infer(frame_refs_short_signaling, 0);
1423  } else {
1424  flag(frame_refs_short_signaling);
1425  if (current->frame_refs_short_signaling) {
1426  fb(3, last_frame_idx);
1427  fb(3, golden_frame_idx);
1428  CHECK(FUNC(set_frame_refs)(ctx, rw, current));
1429  }
1430  }
1431 
1432  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
1433  if (!current->frame_refs_short_signaling)
1434  fbs(3, ref_frame_idx[i], 1, i);
1435  if (seq->frame_id_numbers_present_flag) {
1437  delta_frame_id_minus1[i], 1, i);
1438  }
1439  }
1440 
1441  if (current->frame_size_override_flag &&
1442  !current->error_resilient_mode) {
1443  CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
1444  } else {
1445  CHECK(FUNC(frame_size)(ctx, rw, current));
1446  CHECK(FUNC(render_size)(ctx, rw, current));
1447  }
1448 
1449  if (current->force_integer_mv)
1450  infer(allow_high_precision_mv, 0);
1451  else
1452  flag(allow_high_precision_mv);
1453 
1454  CHECK(FUNC(interpolation_filter)(ctx, rw, current));
1455 
1456  flag(is_motion_mode_switchable);
1457 
1458  if (current->error_resilient_mode ||
1459  !seq->enable_ref_frame_mvs)
1460  infer(use_ref_frame_mvs, 0);
1461  else
1462  flag(use_ref_frame_mvs);
1463 
1464  infer(allow_intrabc, 0);
1465  }
1466 
1467  if (!frame_is_intra) {
1468  // Derive reference frame sign biases.
1469  }
1470 
1471  if (seq->reduced_still_picture_header || current->disable_cdf_update)
1472  infer(disable_frame_end_update_cdf, 1);
1473  else
1474  flag(disable_frame_end_update_cdf);
1475 
1476  if (current->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
1477  // Init non-coeff CDFs.
1478  // Setup past independence.
1479  } else {
1480  // Load CDF tables from previous frame.
1481  // Load params from previous frame.
1482  }
1483 
1484  if (current->use_ref_frame_mvs) {
1485  // Perform motion field estimation process.
1486  }
1487 
1488  CHECK(FUNC(tile_info)(ctx, rw, current));
1489 
1490  CHECK(FUNC(quantization_params)(ctx, rw, current));
1491 
1492  CHECK(FUNC(segmentation_params)(ctx, rw, current));
1493 
1494  CHECK(FUNC(delta_q_params)(ctx, rw, current));
1495 
1496  CHECK(FUNC(delta_lf_params)(ctx, rw, current));
1497 
1498  // Init coeff CDFs / load previous segments.
1499 
1500  priv->coded_lossless = 1;
1501  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
1502  int qindex;
1503  if (current->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
1504  qindex = (current->base_q_idx +
1505  current->feature_value[i][AV1_SEG_LVL_ALT_Q]);
1506  } else {
1507  qindex = current->base_q_idx;
1508  }
1509  qindex = av_clip_uintp2(qindex, 8);
1510 
1511  if (qindex || current->delta_q_y_dc ||
1512  current->delta_q_u_ac || current->delta_q_u_dc ||
1513  current->delta_q_v_ac || current->delta_q_v_dc) {
1514  priv->coded_lossless = 0;
1515  }
1516  }
1517  priv->all_lossless = priv->coded_lossless &&
1518  priv->frame_width == priv->upscaled_width;
1519 
1520  CHECK(FUNC(loop_filter_params)(ctx, rw, current));
1521 
1522  CHECK(FUNC(cdef_params)(ctx, rw, current));
1523 
1524  CHECK(FUNC(lr_params)(ctx, rw, current));
1525 
1526  CHECK(FUNC(read_tx_mode)(ctx, rw, current));
1527 
1528  CHECK(FUNC(frame_reference_mode)(ctx, rw, current));
1529 
1530  CHECK(FUNC(skip_mode_params)(ctx, rw, current));
1531 
1532  if (frame_is_intra || current->error_resilient_mode ||
1533  !seq->enable_warped_motion)
1534  infer(allow_warped_motion, 0);
1535  else
1536  flag(allow_warped_motion);
1537 
1538  flag(reduced_tx_set);
1539 
1540  CHECK(FUNC(global_motion_params)(ctx, rw, current));
1541 
1542  CHECK(FUNC(film_grain_params)(ctx, rw, current));
1543 
1544  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1545  if (current->refresh_frame_flags & (1 << i)) {
1546  priv->ref[i] = (AV1ReferenceFrameState) {
1547  .valid = 1,
1548  .frame_id = current->current_frame_id,
1549  .upscaled_width = priv->upscaled_width,
1550  .frame_width = priv->frame_width,
1551  .frame_height = priv->frame_height,
1552  .render_width = priv->render_width,
1553  .render_height = priv->render_height,
1554  .frame_type = current->frame_type,
1555  .subsampling_x = seq->color_config.subsampling_x,
1556  .subsampling_y = seq->color_config.subsampling_y,
1557  .bit_depth = priv->bit_depth,
1558  .order_hint = current->order_hint,
1559  };
1560  }
1561  }
1562 
1563  av_log(ctx->log_ctx, AV_LOG_DEBUG, "Frame %d: size %dx%d "
1564  "upscaled %d render %dx%d subsample %dx%d "
1565  "bitdepth %d tiles %dx%d.\n", current->order_hint,
1566  priv->frame_width, priv->frame_height, priv->upscaled_width,
1567  priv->render_width, priv->render_height,
1568  seq->color_config.subsampling_x + 1,
1569  seq->color_config.subsampling_y + 1, priv->bit_depth,
1570  priv->tile_rows, priv->tile_cols);
1571 
1572  return 0;
1573 }
1574 
1576  AV1RawFrameHeader *current, int redundant,
1577  AVBufferRef *rw_buffer_ref)
1578 {
1580  int start_pos, fh_bits, fh_bytes, err;
1581  uint8_t *fh_start;
1582 
1583  if (priv->seen_frame_header) {
1584  if (!redundant) {
1585  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid repeated "
1586  "frame header OBU.\n");
1587  return AVERROR_INVALIDDATA;
1588  } else {
1589  GetBitContext fh;
1590  size_t i, b;
1591  uint32_t val;
1592 
1593  HEADER("Redundant Frame Header");
1594 
1595  av_assert0(priv->frame_header_ref && priv->frame_header);
1596 
1597  init_get_bits(&fh, priv->frame_header,
1598  priv->frame_header_size);
1599  for (i = 0; i < priv->frame_header_size; i += 8) {
1600  b = FFMIN(priv->frame_header_size - i, 8);
1601  val = get_bits(&fh, b);
1602  xf(b, frame_header_copy[i],
1603  val, val, val, 1, i / 8);
1604  }
1605  }
1606  } else {
1607  if (redundant)
1608  HEADER("Redundant Frame Header (used as Frame Header)");
1609  else
1610  HEADER("Frame Header");
1611 
1612 #ifdef READ
1613  start_pos = get_bits_count(rw);
1614 #else
1615  start_pos = put_bits_count(rw);
1616 #endif
1617 
1618  CHECK(FUNC(uncompressed_header)(ctx, rw, current));
1619 
1620  if (current->show_existing_frame) {
1621  priv->seen_frame_header = 0;
1622  } else {
1623  priv->seen_frame_header = 1;
1624 
1626 
1627 #ifdef READ
1628  fh_bits = get_bits_count(rw) - start_pos;
1629  fh_start = (uint8_t*)rw->buffer + start_pos / 8;
1630 #else
1631  // Need to flush the bitwriter so that we can copy its output,
1632  // but use a copy so we don't affect the caller's structure.
1633  {
1634  PutBitContext tmp = *rw;
1635  flush_put_bits(&tmp);
1636  }
1637 
1638  fh_bits = put_bits_count(rw) - start_pos;
1639  fh_start = rw->buf + start_pos / 8;
1640 #endif
1641  fh_bytes = (fh_bits + 7) / 8;
1642 
1643  priv->frame_header_size = fh_bits;
1644 
1645  if (rw_buffer_ref) {
1646  priv->frame_header_ref = av_buffer_ref(rw_buffer_ref);
1647  if (!priv->frame_header_ref)
1648  return AVERROR(ENOMEM);
1649  priv->frame_header = fh_start;
1650  } else {
1651  priv->frame_header_ref =
1653  if (!priv->frame_header_ref)
1654  return AVERROR(ENOMEM);
1655  priv->frame_header = priv->frame_header_ref->data;
1656  memcpy(priv->frame_header, fh_start, fh_bytes);
1657  }
1658  }
1659  }
1660 
1661  return 0;
1662 }
1663 
1665  AV1RawTileGroup *current)
1666 {
1668  int num_tiles, tile_bits;
1669  int err;
1670 
1671  HEADER("Tile Group");
1672 
1673  num_tiles = priv->tile_cols * priv->tile_rows;
1674  if (num_tiles > 1)
1675  flag(tile_start_and_end_present_flag);
1676  else
1677  infer(tile_start_and_end_present_flag, 0);
1678 
1679  if (num_tiles == 1 || !current->tile_start_and_end_present_flag) {
1680  infer(tg_start, 0);
1681  infer(tg_end, num_tiles - 1);
1682  } else {
1683  tile_bits = cbs_av1_tile_log2(1, priv->tile_cols) +
1684  cbs_av1_tile_log2(1, priv->tile_rows);
1685  fb(tile_bits, tg_start);
1686  fb(tile_bits, tg_end);
1687  }
1688 
1689  CHECK(FUNC(byte_alignment)(ctx, rw));
1690 
1691  // Reset header for next frame.
1692  if (current->tg_end == num_tiles - 1)
1693  priv->seen_frame_header = 0;
1694 
1695  // Tile data follows.
1696 
1697  return 0;
1698 }
1699 
1701  AV1RawFrame *current,
1702  AVBufferRef *rw_buffer_ref)
1703 {
1704  int err;
1705 
1706  CHECK(FUNC(frame_header_obu)(ctx, rw, &current->header,
1707  0, rw_buffer_ref));
1708 
1709  CHECK(FUNC(byte_alignment)(ctx, rw));
1710 
1711  CHECK(FUNC(tile_group_obu)(ctx, rw, &current->tile_group));
1712 
1713  return 0;
1714 }
1715 
1717  AV1RawTileList *current)
1718 {
1719  int err;
1720 
1721  fb(8, output_frame_width_in_tiles_minus_1);
1722  fb(8, output_frame_height_in_tiles_minus_1);
1723 
1724  fb(16, tile_count_minus_1);
1725 
1726  // Tile data follows.
1727 
1728  return 0;
1729 }
1730 
1732  AV1RawMetadataHDRCLL *current)
1733 {
1734  int err;
1735 
1736  fb(16, max_cll);
1737  fb(16, max_fall);
1738 
1739  return 0;
1740 }
1741 
1743  AV1RawMetadataHDRMDCV *current)
1744 {
1745  int err, i;
1746 
1747  for (i = 0; i < 3; i++) {
1748  fbs(16, primary_chromaticity_x[i], 1, i);
1749  fbs(16, primary_chromaticity_y[i], 1, i);
1750  }
1751 
1752  fb(16, white_point_chromaticity_x);
1753  fb(16, white_point_chromaticity_y);
1754 
1755  fc(32, luminance_max, 1, MAX_UINT_BITS(32));
1756  // luminance_min must be lower than luminance_max. Convert luminance_max from
1757  // 24.8 fixed point to 18.14 fixed point in order to compare them.
1758  fc(32, luminance_min, 0, FFMIN(((uint64_t)current->luminance_max << 6) - 1,
1759  MAX_UINT_BITS(32)));
1760 
1761  return 0;
1762 }
1763 
1765  AV1RawMetadataScalability *current)
1766 {
1768  const AV1RawSequenceHeader *seq;
1769  int err, i, j;
1770 
1771  if (!priv->sequence_header) {
1772  av_log(ctx->log_ctx, AV_LOG_ERROR, "No sequence header available: "
1773  "unable to parse scalability metadata.\n");
1774  return AVERROR_INVALIDDATA;
1775  }
1776  seq = priv->sequence_header;
1777 
1778  fb(2, spatial_layers_cnt_minus_1);
1779  flag(spatial_layer_dimensions_present_flag);
1780  flag(spatial_layer_description_present_flag);
1781  flag(temporal_group_description_present_flag);
1782  fc(3, scalability_structure_reserved_3bits, 0, 0);
1783  if (current->spatial_layer_dimensions_present_flag) {
1784  for (i = 0; i <= current->spatial_layers_cnt_minus_1; i++) {
1785  fcs(16, spatial_layer_max_width[i],
1786  0, seq->max_frame_width_minus_1 + 1, 1, i);
1787  fcs(16, spatial_layer_max_height[i],
1788  0, seq->max_frame_height_minus_1 + 1, 1, i);
1789  }
1790  }
1791  if (current->spatial_layer_description_present_flag) {
1792  for (i = 0; i <= current->spatial_layers_cnt_minus_1; i++)
1793  fbs(8, spatial_layer_ref_id[i], 1, i);
1794  }
1795  if (current->temporal_group_description_present_flag) {
1796  fb(8, temporal_group_size);
1797  for (i = 0; i < current->temporal_group_size; i++) {
1798  fbs(3, temporal_group_temporal_id[i], 1, i);
1799  flags(temporal_group_temporal_switching_up_point_flag[i], 1, i);
1800  flags(temporal_group_spatial_switching_up_point_flag[i], 1, i);
1801  fbs(3, temporal_group_ref_cnt[i], 1, i);
1802  for (j = 0; j < current->temporal_group_ref_cnt[i]; j++) {
1803  fbs(8, temporal_group_ref_pic_diff[i][j], 2, i, j);
1804  }
1805  }
1806  }
1807 
1808  return 0;
1809 }
1810 
1812  AV1RawMetadataScalability *current)
1813 {
1814  int err;
1815 
1816  fb(8, scalability_mode_idc);
1817 
1818  if (current->scalability_mode_idc == AV1_SCALABILITY_SS)
1819  CHECK(FUNC(scalability_structure)(ctx, rw, current));
1820 
1821  return 0;
1822 }
1823 
1825  AV1RawMetadataITUTT35 *current)
1826 {
1827  int err;
1828  size_t i;
1829 
1830  fb(8, itu_t_t35_country_code);
1831  if (current->itu_t_t35_country_code == 0xff)
1832  fb(8, itu_t_t35_country_code_extension_byte);
1833 
1834 #ifdef READ
1835  // The payload runs up to the start of the trailing bits, but there might
1836  // be arbitrarily many trailing zeroes so we need to read through twice.
1837  current->payload_size = cbs_av1_get_payload_bytes_left(rw);
1838 
1839  current->payload_ref = av_buffer_alloc(current->payload_size);
1840  if (!current->payload_ref)
1841  return AVERROR(ENOMEM);
1842  current->payload = current->payload_ref->data;
1843 #endif
1844 
1845  for (i = 0; i < current->payload_size; i++)
1846  xf(8, itu_t_t35_payload_bytes[i], current->payload[i],
1847  0x00, 0xff, 1, i);
1848 
1849  return 0;
1850 }
1851 
1853  AV1RawMetadataTimecode *current)
1854 {
1855  int err;
1856 
1857  fb(5, counting_type);
1858  flag(full_timestamp_flag);
1859  flag(discontinuity_flag);
1860  flag(cnt_dropped_flag);
1861  fb(9, n_frames);
1862 
1863  if (current->full_timestamp_flag) {
1864  fc(6, seconds_value, 0, 59);
1865  fc(6, minutes_value, 0, 59);
1866  fc(5, hours_value, 0, 23);
1867  } else {
1868  flag(seconds_flag);
1869  if (current->seconds_flag) {
1870  fc(6, seconds_value, 0, 59);
1871  flag(minutes_flag);
1872  if (current->minutes_flag) {
1873  fc(6, minutes_value, 0, 59);
1874  flag(hours_flag);
1875  if (current->hours_flag)
1876  fc(5, hours_value, 0, 23);
1877  }
1878  }
1879  }
1880 
1881  fb(5, time_offset_length);
1882  if (current->time_offset_length > 0)
1883  fb(current->time_offset_length, time_offset_value);
1884  else
1885  infer(time_offset_length, 0);
1886 
1887  return 0;
1888 }
1889 
1891  AV1RawMetadata *current)
1892 {
1893  int err;
1894 
1895  leb128(metadata_type);
1896 
1897  switch (current->metadata_type) {
1899  CHECK(FUNC(metadata_hdr_cll)(ctx, rw, &current->metadata.hdr_cll));
1900  break;
1902  CHECK(FUNC(metadata_hdr_mdcv)(ctx, rw, &current->metadata.hdr_mdcv));
1903  break;
1905  CHECK(FUNC(metadata_scalability)(ctx, rw, &current->metadata.scalability));
1906  break;
1908  CHECK(FUNC(metadata_itut_t35)(ctx, rw, &current->metadata.itut_t35));
1909  break;
1911  CHECK(FUNC(metadata_timecode)(ctx, rw, &current->metadata.timecode));
1912  break;
1913  default:
1914  // Unknown metadata type.
1915  return AVERROR_PATCHWELCOME;
1916  }
1917 
1918  return 0;
1919 }
1920 
1922  AV1RawPadding *current)
1923 {
1924  int i, err;
1925 
1926  HEADER("Padding");
1927 
1928 #ifdef READ
1929  // The payload runs up to the start of the trailing bits, but there might
1930  // be arbitrarily many trailing zeroes so we need to read through twice.
1931  current->payload_size = cbs_av1_get_payload_bytes_left(rw);
1932 
1933  current->payload_ref = av_buffer_alloc(current->payload_size);
1934  if (!current->payload_ref)
1935  return AVERROR(ENOMEM);
1936  current->payload = current->payload_ref->data;
1937 #endif
1938 
1939  for (i = 0; i < current->payload_size; i++)
1940  xf(8, obu_padding_byte[i], current->payload[i], 0x00, 0xff, 1, i);
1941 
1942  return 0;
1943 }
static int FUNC() tile_group_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileGroup *current)
static int FUNC() trailing_bits(CodedBitstreamContext *ctx, RWContext *rw, int nb_bits)
#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
uint8_t frame_width_bits_minus_1
Definition: cbs_av1.h:96
uint8_t enable_superres
Definition: cbs_av1.h:124
#define fixed(width, name, value)
Definition: cbs_av1.c:569
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
uint8_t mono_chrome
Definition: cbs_av1.h:44
#define RWContext
Definition: cbs_av1.c:665
static int FUNC() tile_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
const char * b
Definition: vf_curves.c:116
uint8_t additional_frame_id_length_minus_1
Definition: cbs_av1.h:103
static int FUNC() tile_list_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileList *current)
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
static int FUNC() interpolation_filter(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
color_range
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2128
uint8_t operating_points_cnt_minus_1
Definition: cbs_av1.h:81
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:510
static int FUNC() uncompressed_header(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
frame_type
uint8_t reduced_still_picture_header
Definition: cbs_av1.h:76
static int FUNC() decoder_model_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawDecoderModelInfo *current)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define leb128(name)
Definition: cbs_av1.c:708
uint8_t
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
static int FUNC() loop_filter_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:98
#define HEADER(name)
Definition: cbs_av1.c:536
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:98
static int FUNC() delta_lf_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define subexp(name, max, subs,...)
Definition: cbs_av1.c:696
static AVFrame * frame
static int FUNC() superres_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
uint8_t enable_warped_motion
Definition: cbs_av1.h:110
static int FUNC() render_size(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define av_log(a,...)
uint8_t enable_ref_frame_mvs
Definition: cbs_av1.h:115
uint8_t frame_presentation_time_length_minus_1
Definition: cbs_av1.h:70
uint8_t * frame_header
Definition: cbs_av1.h:424
static int FUNC() read_tx_mode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() lr_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() scalability_structure(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataScalability *current)
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:554
uint16_t operating_point_idc[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:86
uint8_t seq_force_integer_mv
Definition: cbs_av1.h:120
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
static int FUNC() metadata_itut_t35(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataITUTT35 *current)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
static int FUNC() frame_reference_mode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define fcs(width, name, range_min, range_max, subs,...)
Definition: cbs_av1.c:562
uint8_t separate_uv_delta_q
Definition: cbs_av1.h:55
#define FUNC(a)
AVBufferRef * frame_header_ref
Definition: cbs_av1.h:423
#define AVERROR(e)
Definition: error.h:43
static int FUNC() obu_header(CodedBitstreamContext *ctx, RWContext *rw, AV1RawOBUHeader *current)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:457
static int FUNC() global_motion_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
uint8_t bits
Definition: vp3data.h:202
static int FUNC() skip_mode_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() metadata_scalability(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataScalability *current)
#define FFMAX(a, b)
Definition: common.h:94
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
static int cbs_av1_tile_log2(int blksize, int target)
Definition: cbs_av1.c:505
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
static int FUNC() color_config(CodedBitstreamContext *ctx, RWContext *rw, AV1RawColorConfig *current, int seq_profile)
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
static int FUNC() metadata_hdr_cll(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataHDRCLL *current)
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
#define FFMIN(a, b)
Definition: common.h:96
#define fb(width, name)
Definition: cbs_av1.c:552
uint8_t use_128x128_superblock
Definition: cbs_av1.h:105
AV1ReferenceFrameState * ref
Definition: cbs_av1.h:444
uint8_t enable_restoration
Definition: cbs_av1.h:126
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t enable_cdef
Definition: cbs_av1.h:125
#define increment(name, min, max)
Definition: cbs_av1.c:691
static int FUNC() frame_size_with_refs(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() sequence_header_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawSequenceHeader *current)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define fbs(width, name, subs,...)
Definition: cbs_av1.c:560
uint8_t subsampling_y
Definition: cbs_av1.h:53
uint8_t decoder_model_info_present_flag
Definition: cbs_av1.h:79
#define delta_q(name)
Definition: cbs_av1.c:702
uint16_t max_frame_height_minus_1
Definition: cbs_av1.h:99
typedef void(RENAME(mix_any_func_type))
static int FUNC() frame_size(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
uint8_t delta_frame_id_length_minus_2
Definition: cbs_av1.h:102
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
uint8_t subsampling_x
Definition: cbs_av1.h:52
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:524
uint8_t enable_order_hint
Definition: cbs_av1.h:113
static int FUNC() metadata_hdr_mdcv(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataHDRMDCV *current)
#define uvlc(name, range_min, range_max)
Definition: cbs_av1.c:680
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:1954
Context structure for coded bitstream operations.
Definition: cbs.h:168
static int FUNC() global_motion_param(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current, int type, int ref, int idx)
static int FUNC() temporal_delimiter_obu(CodedBitstreamContext *ctx, RWContext *rw)
uint8_t decoder_model_present_for_this_op[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:89
static int FUNC() delta_q_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:1952
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
cl_device_type type
AV1RawDecoderModelInfo decoder_model_info
Definition: cbs_av1.h:84
static int FUNC() set_frame_refs(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
AV1RawSequenceHeader * sequence_header
Definition: cbs_av1.h:419
static int FUNC() metadata_timecode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataTimecode *current)
static int FUNC() frame_header_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current, int redundant, AVBufferRef *rw_buffer_ref)
static int FUNC() cdef_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
uint8_t equal_picture_interval
Definition: cbs_av1.h:62
#define flags(name, subs,...)
Definition: cbs_av1.c:564
static int FUNC() metadata_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadata *current)
static int FUNC() timing_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTimingInfo *current)
uint8_t frame_id_numbers_present_flag
Definition: cbs_av1.h:101
#define ns(max_value, name, subs,...)
Definition: cbs_av1.c:685
A reference to a data buffer.
Definition: buffer.h:81
uint8_t frame_height_bits_minus_1
Definition: cbs_av1.h:97
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:494
static int FUNC() frame_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrame *current, AVBufferRef *rw_buffer_ref)
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
uint8_t buffer_removal_time_length_minus_1
Definition: cbs_av1.h:69
#define flag(name)
Definition: cbs_av1.c:556
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 int FUNC() segmentation_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:667
void * priv_data
Format private data.
Definition: avformat.h:1379
static int FUNC() film_grain_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() quantization_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define sus(width, name, subs,...)
Definition: cbs_av1.c:566
AV1RawTimingInfo timing_info
Definition: cbs_av1.h:83
static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: cbs_av1.c:512
#define infer(name, value)
Definition: cbs_av1.c:712
static double val(void *priv, double ch)
Definition: aeval.c:76
uint8_t seq_force_screen_content_tools
Definition: cbs_av1.h:118
static int FUNC() padding_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawPadding *current)
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:1953
static uint8_t tmp[11]
Definition: aes_ctr.c:26