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