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 
424  if (current->ref_frame_idx[i] < 0 ||
425  !priv->ref[current->ref_frame_idx[i]].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  ref = &priv->ref[current->ref_frame_idx[i]];
433 
434  priv->upscaled_width = ref->upscaled_width;
435  priv->frame_width = ref->frame_width;
436  priv->frame_height = ref->frame_height;
437  priv->render_width = ref->render_width;
438  priv->render_height = ref->render_height;
439  break;
440  }
441  }
442 
443  if (i >= AV1_REFS_PER_FRAME) {
444  CHECK(FUNC(frame_size)(ctx, rw, current));
445  CHECK(FUNC(render_size)(ctx, rw, current));
446  } else {
447  CHECK(FUNC(superres_params)(ctx, rw, current));
448  }
449 
450  return 0;
451 }
452 
454  AV1RawFrameHeader *current)
455 {
456  int err;
457 
458  flag(is_filter_switchable);
459  if (current->is_filter_switchable)
462  else
464 
465  return 0;
466 }
467 
469  AV1RawFrameHeader *current)
470 {
472  const AV1RawSequenceHeader *seq = priv->sequence_header;
473  int mi_cols, mi_rows, sb_cols, sb_rows, sb_shift, sb_size;
474  int max_tile_width_sb, max_tile_height_sb, max_tile_area_sb;
475  int min_log2_tile_cols, max_log2_tile_cols, max_log2_tile_rows;
476  int min_log2_tiles, min_log2_tile_rows;
477  int i, err;
478 
479  mi_cols = 2 * ((priv->frame_width + 7) >> 3);
480  mi_rows = 2 * ((priv->frame_height + 7) >> 3);
481 
482  sb_cols = seq->use_128x128_superblock ? ((mi_cols + 31) >> 5)
483  : ((mi_cols + 15) >> 4);
484  sb_rows = seq->use_128x128_superblock ? ((mi_rows + 31) >> 5)
485  : ((mi_rows + 15) >> 4);
486 
487  sb_shift = seq->use_128x128_superblock ? 5 : 4;
488  sb_size = sb_shift + 2;
489 
490  max_tile_width_sb = AV1_MAX_TILE_WIDTH >> sb_size;
491  max_tile_area_sb = AV1_MAX_TILE_AREA >> (2 * sb_size);
492 
493  min_log2_tile_cols = cbs_av1_tile_log2(max_tile_width_sb, sb_cols);
494  max_log2_tile_cols = cbs_av1_tile_log2(1, FFMIN(sb_cols, AV1_MAX_TILE_COLS));
495  max_log2_tile_rows = cbs_av1_tile_log2(1, FFMIN(sb_rows, AV1_MAX_TILE_ROWS));
496  min_log2_tiles = FFMAX(min_log2_tile_cols,
497  cbs_av1_tile_log2(max_tile_area_sb, sb_rows * sb_cols));
498 
499  flag(uniform_tile_spacing_flag);
500 
501  if (current->uniform_tile_spacing_flag) {
502  int tile_width_sb, tile_height_sb;
503 
504  increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
505 
506  tile_width_sb = (sb_cols + (1 << current->tile_cols_log2) - 1) >>
507  current->tile_cols_log2;
508  current->tile_cols = (sb_cols + tile_width_sb - 1) / tile_width_sb;
509 
510  min_log2_tile_rows = FFMAX(min_log2_tiles - current->tile_cols_log2, 0);
511 
512  increment(tile_rows_log2, min_log2_tile_rows, max_log2_tile_rows);
513 
514  tile_height_sb = (sb_rows + (1 << current->tile_rows_log2) - 1) >>
515  current->tile_rows_log2;
516  current->tile_rows = (sb_rows + tile_height_sb - 1) / tile_height_sb;
517 
518  } else {
519  int widest_tile_sb, start_sb, size_sb, max_width, max_height;
520 
521  widest_tile_sb = 0;
522 
523  start_sb = 0;
524  for (i = 0; start_sb < sb_cols && i < AV1_MAX_TILE_COLS; i++) {
525  max_width = FFMIN(sb_cols - start_sb, max_tile_width_sb);
526  ns(max_width, width_in_sbs_minus_1[i], 1, i);
527  size_sb = current->width_in_sbs_minus_1[i] + 1;
528  widest_tile_sb = FFMAX(size_sb, widest_tile_sb);
529  start_sb += size_sb;
530  }
531  current->tile_cols_log2 = cbs_av1_tile_log2(1, i);
532  current->tile_cols = i;
533 
534  if (min_log2_tiles > 0)
535  max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
536  else
537  max_tile_area_sb = sb_rows * sb_cols;
538  max_tile_height_sb = FFMAX(max_tile_area_sb / widest_tile_sb, 1);
539 
540  start_sb = 0;
541  for (i = 0; start_sb < sb_rows && i < AV1_MAX_TILE_ROWS; i++) {
542  max_height = FFMIN(sb_rows - start_sb, max_tile_height_sb);
543  ns(max_height, height_in_sbs_minus_1[i], 1, i);
544  size_sb = current->height_in_sbs_minus_1[i] + 1;
545  start_sb += size_sb;
546  }
547  current->tile_rows_log2 = cbs_av1_tile_log2(1, i);
548  current->tile_rows = i;
549  }
550 
551  if (current->tile_cols_log2 > 0 ||
552  current->tile_rows_log2 > 0) {
553  fb(current->tile_cols_log2 + current->tile_rows_log2,
554  context_update_tile_id);
555  fb(2, tile_size_bytes_minus1);
556  } else {
557  infer(context_update_tile_id, 0);
558  }
559 
560  priv->tile_cols = current->tile_cols;
561  priv->tile_rows = current->tile_rows;
562 
563  return 0;
564 }
565 
567  AV1RawFrameHeader *current)
568 {
570  const AV1RawSequenceHeader *seq = priv->sequence_header;
571  int err;
572 
573  fb(8, base_q_idx);
574 
575  delta_q(delta_q_y_dc);
576 
577  if (priv->num_planes > 1) {
579  flag(diff_uv_delta);
580  else
581  infer(diff_uv_delta, 0);
582 
583  delta_q(delta_q_u_dc);
584  delta_q(delta_q_u_ac);
585 
586  if (current->diff_uv_delta) {
587  delta_q(delta_q_v_dc);
588  delta_q(delta_q_v_ac);
589  } else {
590  infer(delta_q_v_dc, current->delta_q_u_dc);
591  infer(delta_q_v_ac, current->delta_q_u_ac);
592  }
593  } else {
594  infer(delta_q_u_dc, 0);
595  infer(delta_q_u_ac, 0);
596  infer(delta_q_v_dc, 0);
597  infer(delta_q_v_ac, 0);
598  }
599 
600  flag(using_qmatrix);
601  if (current->using_qmatrix) {
602  fb(4, qm_y);
603  fb(4, qm_u);
605  fb(4, qm_v);
606  else
607  infer(qm_v, current->qm_u);
608  }
609 
610  return 0;
611 }
612 
614  AV1RawFrameHeader *current)
615 {
616  static const uint8_t bits[AV1_SEG_LVL_MAX] = { 8, 6, 6, 6, 6, 3, 0, 0 };
617  static const uint8_t sign[AV1_SEG_LVL_MAX] = { 1, 1, 1, 1, 1, 0, 0, 0 };
618  int i, j, err;
619 
620  flag(segmentation_enabled);
621 
622  if (current->segmentation_enabled) {
623  if (current->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
624  infer(segmentation_update_map, 1);
625  infer(segmentation_temporal_update, 0);
626  infer(segmentation_update_data, 1);
627  } else {
628  flag(segmentation_update_map);
629  if (current->segmentation_update_map)
630  flag(segmentation_temporal_update);
631  else
632  infer(segmentation_temporal_update, 0);
633  flag(segmentation_update_data);
634  }
635 
636  if (current->segmentation_update_data) {
637  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
638  for (j = 0; j < AV1_SEG_LVL_MAX; j++) {
639  flags(feature_enabled[i][j], 2, i, j);
640 
641  if (current->feature_enabled[i][j] && bits[j] > 0) {
642  if (sign[j])
643  sus(1 + bits[j], feature_value[i][j], 2, i, j);
644  else
645  fbs(bits[j], feature_value[i][j], 2, i, j);
646  } else {
647  infer(feature_value[i][j], 0);
648  }
649  }
650  }
651  }
652  } else {
653  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
654  for (j = 0; j < AV1_SEG_LVL_MAX; j++) {
655  infer(feature_enabled[i][j], 0);
656  infer(feature_value[i][j], 0);
657  }
658  }
659  }
660 
661  return 0;
662 }
663 
665  AV1RawFrameHeader *current)
666 {
667  int err;
668 
669  if (current->base_q_idx > 0)
670  flag(delta_q_present);
671  else
672  infer(delta_q_present, 0);
673 
674  if (current->delta_q_present)
675  fb(2, delta_q_res);
676 
677  return 0;
678 }
679 
681  AV1RawFrameHeader *current)
682 {
683  int err;
684 
685  if (current->delta_q_present) {
686  if (!current->allow_intrabc)
687  flag(delta_lf_present);
688  else
689  infer(delta_lf_present, 0);
690  if (current->delta_lf_present) {
691  fb(2, delta_lf_res);
692  flag(delta_lf_multi);
693  } else {
694  infer(delta_lf_res, 0);
695  infer(delta_lf_multi, 0);
696  }
697  } else {
698  infer(delta_lf_present, 0);
699  infer(delta_lf_res, 0);
700  infer(delta_lf_multi, 0);
701  }
702 
703  return 0;
704 }
705 
707  AV1RawFrameHeader *current)
708 {
710  int i, err;
711 
712  if (priv->coded_lossless || current->allow_intrabc) {
713  infer(loop_filter_level[0], 0);
714  infer(loop_filter_level[1], 0);
715  infer(loop_filter_ref_deltas[AV1_REF_FRAME_INTRA], 1);
716  infer(loop_filter_ref_deltas[AV1_REF_FRAME_LAST], 0);
717  infer(loop_filter_ref_deltas[AV1_REF_FRAME_LAST2], 0);
718  infer(loop_filter_ref_deltas[AV1_REF_FRAME_LAST3], 0);
719  infer(loop_filter_ref_deltas[AV1_REF_FRAME_BWDREF], 0);
720  infer(loop_filter_ref_deltas[AV1_REF_FRAME_GOLDEN], -1);
721  infer(loop_filter_ref_deltas[AV1_REF_FRAME_ALTREF], -1);
722  infer(loop_filter_ref_deltas[AV1_REF_FRAME_ALTREF2], -1);
723  for (i = 0; i < 2; i++)
724  infer(loop_filter_mode_deltas[i], 0);
725  return 0;
726  }
727 
728  fb(6, loop_filter_level[0]);
729  fb(6, loop_filter_level[1]);
730 
731  if (priv->num_planes > 1) {
732  if (current->loop_filter_level[0] ||
733  current->loop_filter_level[1]) {
734  fb(6, loop_filter_level[2]);
735  fb(6, loop_filter_level[3]);
736  }
737  }
738 
739  fb(3, loop_filter_sharpness);
740 
741  flag(loop_filter_delta_enabled);
742  if (current->loop_filter_delta_enabled) {
743  flag(loop_filter_delta_update);
744  if (current->loop_filter_delta_update) {
745  for (i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) {
746  flags(update_ref_delta[i], 1, i);
747  if (current->update_ref_delta[i])
748  sus(1 + 6, loop_filter_ref_deltas[i], 1, i);
749  }
750  for (i = 0; i < 2; i++) {
751  flags(update_mode_delta[i], 1, i);
752  if (current->update_mode_delta[i])
753  sus(1 + 6, loop_filter_mode_deltas[i], 1, i);
754  }
755  }
756  }
757 
758  return 0;
759 }
760 
762  AV1RawFrameHeader *current)
763 {
765  const AV1RawSequenceHeader *seq = priv->sequence_header;
766  int i, err;
767 
768  if (priv->coded_lossless || current->allow_intrabc ||
769  !seq->enable_cdef) {
770  infer(cdef_damping_minus_3, 0);
771  infer(cdef_bits, 0);
772  infer(cdef_y_pri_strength[0], 0);
773  infer(cdef_y_sec_strength[0], 0);
774  infer(cdef_uv_pri_strength[0], 0);
775  infer(cdef_uv_sec_strength[0], 0);
776 
777  return 0;
778  }
779 
780  fb(2, cdef_damping_minus_3);
781  fb(2, cdef_bits);
782 
783  for (i = 0; i < (1 << current->cdef_bits); i++) {
784  fbs(4, cdef_y_pri_strength[i], 1, i);
785  fbs(2, cdef_y_sec_strength[i], 1, i);
786 
787  if (priv->num_planes > 1) {
788  fbs(4, cdef_uv_pri_strength[i], 1, i);
789  fbs(2, cdef_uv_sec_strength[i], 1, i);
790  }
791  }
792 
793  return 0;
794 }
795 
797  AV1RawFrameHeader *current)
798 {
800  const AV1RawSequenceHeader *seq = priv->sequence_header;
801  int uses_lr, uses_chroma_lr;
802  int i, err;
803 
804  if (priv->all_lossless || current->allow_intrabc ||
805  !seq->enable_restoration) {
806  return 0;
807  }
808 
809  uses_lr = uses_chroma_lr = 0;
810  for (i = 0; i < priv->num_planes; i++) {
811  fbs(2, lr_type[i], 1, i);
812 
813  if (current->lr_type[i] != 0) {
814  uses_lr = 1;
815  if (i > 0)
816  uses_chroma_lr = 1;
817  }
818  }
819 
820  if (uses_lr) {
821  if (seq->use_128x128_superblock)
822  increment(lr_unit_shift, 1, 2);
823  else
824  increment(lr_unit_shift, 0, 2);
825 
826  if(seq->color_config.subsampling_x &&
827  seq->color_config.subsampling_y && uses_chroma_lr) {
828  fb(1, lr_uv_shift);
829  } else {
830  infer(lr_uv_shift, 0);
831  }
832  }
833 
834  return 0;
835 }
836 
838  AV1RawFrameHeader *current)
839 {
841  int err;
842 
843  if (priv->coded_lossless)
844  infer(tx_mode, 0);
845  else
846  increment(tx_mode, 1, 2);
847 
848  return 0;
849 }
850 
852  AV1RawFrameHeader *current)
853 {
854  int err;
855 
856  if (current->frame_type == AV1_FRAME_INTRA_ONLY ||
857  current->frame_type == AV1_FRAME_KEY)
858  infer(reference_select, 0);
859  else
860  flag(reference_select);
861 
862  return 0;
863 }
864 
866  AV1RawFrameHeader *current)
867 {
869  const AV1RawSequenceHeader *seq = priv->sequence_header;
870  int skip_mode_allowed;
871  int err;
872 
873  if (current->frame_type == AV1_FRAME_KEY ||
874  current->frame_type == AV1_FRAME_INTRA_ONLY ||
875  !current->reference_select || !seq->enable_order_hint) {
876  skip_mode_allowed = 0;
877  } else {
878  int forward_idx, backward_idx;
879  int forward_hint, backward_hint;
880  int ref_hint, dist, i;
881 
882  forward_idx = -1;
883  backward_idx = -1;
884  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
885  ref_hint = priv->ref[current->ref_frame_idx[i]].order_hint;
886  dist = cbs_av1_get_relative_dist(seq, ref_hint,
887  current->order_hint);
888  if (dist < 0) {
889  if (forward_idx < 0 ||
890  cbs_av1_get_relative_dist(seq, ref_hint,
891  forward_hint) > 0) {
892  forward_idx = i;
893  forward_hint = ref_hint;
894  }
895  } else if (dist > 0) {
896  if (backward_idx < 0 ||
897  cbs_av1_get_relative_dist(seq, ref_hint,
898  backward_hint) < 0) {
899  backward_idx = i;
900  backward_hint = ref_hint;
901  }
902  }
903  }
904 
905  if (forward_idx < 0) {
906  skip_mode_allowed = 0;
907  } else if (backward_idx >= 0) {
908  skip_mode_allowed = 1;
909  // Frames for skip mode are forward_idx and backward_idx.
910  } else {
911  int second_forward_idx;
912  int second_forward_hint;
913 
914  second_forward_idx = -1;
915  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
916  ref_hint = priv->ref[current->ref_frame_idx[i]].order_hint;
917  if (cbs_av1_get_relative_dist(seq, ref_hint,
918  forward_hint) < 0) {
919  if (second_forward_idx < 0 ||
920  cbs_av1_get_relative_dist(seq, ref_hint,
921  second_forward_hint) > 0) {
922  second_forward_idx = i;
923  second_forward_hint = ref_hint;
924  }
925  }
926  }
927 
928  if (second_forward_idx < 0) {
929  skip_mode_allowed = 0;
930  } else {
931  skip_mode_allowed = 1;
932  // Frames for skip mode are forward_idx and second_forward_idx.
933  }
934  }
935  }
936 
937  if (skip_mode_allowed)
938  flag(skip_mode_present);
939  else
940  infer(skip_mode_present, 0);
941 
942  return 0;
943 }
944 
946  AV1RawFrameHeader *current,
947  int type, int ref, int idx)
948 {
949  uint32_t abs_bits, prec_bits, num_syms;
950  int err;
951 
952  if (idx < 2) {
954  abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS - !current->allow_high_precision_mv;
955  prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS - !current->allow_high_precision_mv;
956  } else {
957  abs_bits = AV1_GM_ABS_TRANS_BITS;
958  prec_bits = AV1_GM_TRANS_PREC_BITS;
959  }
960  } else {
961  abs_bits = AV1_GM_ABS_ALPHA_BITS;
962  prec_bits = AV1_GM_ALPHA_PREC_BITS;
963  }
964 
965  num_syms = 2 * (1 << abs_bits) + 1;
966  subexp(gm_params[ref][idx], num_syms, 2, ref, idx);
967 
968  // Actual gm_params value is not reconstructed here.
969  (void)prec_bits;
970 
971  return 0;
972 }
973 
975  AV1RawFrameHeader *current)
976 {
977  int ref, type;
978  int err;
979 
980  if (current->frame_type == AV1_FRAME_KEY ||
981  current->frame_type == AV1_FRAME_INTRA_ONLY)
982  return 0;
983 
985  flags(is_global[ref], 1, ref);
986  if (current->is_global[ref]) {
987  flags(is_rot_zoom[ref], 1, ref);
988  if (current->is_rot_zoom[ref]) {
990  } else {
991  flags(is_translation[ref], 1, ref);
992  type = current->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION
994  }
995  } else {
997  }
998 
999  if (type >= AV1_WARP_MODEL_ROTZOOM) {
1000  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 2));
1001  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 3));
1002  if (type == AV1_WARP_MODEL_AFFINE) {
1003  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 4));
1004  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 5));
1005  } else {
1006  // gm_params[ref][4] = -gm_params[ref][3]
1007  // gm_params[ref][5] = gm_params[ref][2]
1008  }
1009  }
1011  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 0));
1012  CHECK(FUNC(global_motion_param)(ctx, rw, current, type, ref, 1));
1013  }
1014  }
1015 
1016  return 0;
1017 }
1018 
1020  AV1RawFrameHeader *current)
1021 {
1023  const AV1RawSequenceHeader *seq = priv->sequence_header;
1024  int num_pos_luma, num_pos_chroma;
1025  int i, err;
1026 
1027  if (!seq->film_grain_params_present ||
1028  (!current->show_frame && !current->showable_frame))
1029  return 0;
1030 
1031  flag(apply_grain);
1032 
1033  if (!current->apply_grain)
1034  return 0;
1035 
1036  fb(16, grain_seed);
1037 
1038  if (current->frame_type == AV1_FRAME_INTER)
1039  flag(update_grain);
1040  else
1041  infer(update_grain, 1);
1042 
1043  if (!current->update_grain) {
1044  fb(3, film_grain_params_ref_idx);
1045  return 0;
1046  }
1047 
1048  fc(4, num_y_points, 0, 14);
1049  for (i = 0; i < current->num_y_points; i++) {
1050  fbs(8, point_y_value[i], 1, i);
1051  fbs(8, point_y_scaling[i], 1, i);
1052  }
1053 
1054  if (seq->color_config.mono_chrome)
1055  infer(chroma_scaling_from_luma, 0);
1056  else
1057  flag(chroma_scaling_from_luma);
1058 
1059  if (seq->color_config.mono_chrome ||
1060  current->chroma_scaling_from_luma ||
1061  (seq->color_config.subsampling_x == 1 &&
1062  seq->color_config.subsampling_y == 1 &&
1063  current->num_y_points == 0)) {
1064  infer(num_cb_points, 0);
1065  infer(num_cr_points, 0);
1066  } else {
1067  fb(4, num_cb_points);
1068  for (i = 0; i < current->num_cb_points; i++) {
1069  fbs(8, point_cb_value[i], 1, i);
1070  fbs(8, point_cb_scaling[i], 1, i);
1071  }
1072  fb(4, num_cr_points);
1073  for (i = 0; i < current->num_cr_points; i++) {
1074  fbs(8, point_cr_value[i], 1, i);
1075  fbs(8, point_cr_scaling[i], 1, i);
1076  }
1077  }
1078 
1079  fb(2, grain_scaling_minus_8);
1080  fb(2, ar_coeff_lag);
1081  num_pos_luma = 2 * current->ar_coeff_lag * (current->ar_coeff_lag + 1);
1082  if (current->num_y_points) {
1083  num_pos_chroma = num_pos_luma + 1;
1084  for (i = 0; i < num_pos_luma; i++)
1085  fbs(8, ar_coeffs_y_plus_128[i], 1, i);
1086  } else {
1087  num_pos_chroma = num_pos_luma;
1088  }
1089  if (current->chroma_scaling_from_luma || current->num_cb_points) {
1090  for (i = 0; i < num_pos_chroma; i++)
1091  fbs(8, ar_coeffs_cb_plus_128[i], 1, i);
1092  }
1093  if (current->chroma_scaling_from_luma || current->num_cr_points) {
1094  for (i = 0; i < num_pos_chroma; i++)
1095  fbs(8, ar_coeffs_cr_plus_128[i], 1, i);
1096  }
1097  fb(2, ar_coeff_shift_minus_6);
1098  fb(2, grain_scale_shift);
1099  if (current->num_cb_points) {
1100  fb(8, cb_mult);
1101  fb(8, cb_luma_mult);
1102  fb(9, cb_offset);
1103  }
1104  if (current->num_cr_points) {
1105  fb(8, cr_mult);
1106  fb(8, cr_luma_mult);
1107  fb(9, cr_offset);
1108  }
1109 
1110  flag(overlap_flag);
1111  flag(clip_to_restricted_range);
1112 
1113  return 0;
1114 }
1115 
1117  AV1RawFrameHeader *current)
1118 {
1120  const AV1RawSequenceHeader *seq;
1121  int id_len, diff_len, all_frames, frame_is_intra, order_hint_bits;
1122  int i, err;
1123 
1124  if (!priv->sequence_header) {
1125  av_log(ctx->log_ctx, AV_LOG_ERROR, "No sequence header available: "
1126  "unable to decode frame header.\n");
1127  return AVERROR_INVALIDDATA;
1128  }
1129  seq = priv->sequence_header;
1130 
1131  id_len = seq->additional_frame_id_length_minus_1 +
1133  all_frames = (1 << AV1_NUM_REF_FRAMES) - 1;
1134 
1135  if (seq->reduced_still_picture_header) {
1136  infer(show_existing_frame, 0);
1137  infer(frame_type, AV1_FRAME_KEY);
1138  infer(show_frame, 1);
1139  infer(showable_frame, 0);
1140  frame_is_intra = 1;
1141 
1142  } else {
1143  flag(show_existing_frame);
1144 
1145  if (current->show_existing_frame) {
1147 
1148  fb(3, frame_to_show_map_idx);
1149  frame = &priv->ref[current->frame_to_show_map_idx];
1150 
1154  frame_presentation_time);
1155  }
1156 
1158  fb(id_len, display_frame_id);
1159 
1160  if (frame->frame_type == AV1_FRAME_KEY)
1161  infer(refresh_frame_flags, all_frames);
1162  else
1163  infer(refresh_frame_flags, 0);
1164 
1165  return 0;
1166  }
1167 
1168  fb(2, frame_type);
1169  frame_is_intra = (current->frame_type == AV1_FRAME_INTRA_ONLY ||
1170  current->frame_type == AV1_FRAME_KEY);
1171 
1172  flag(show_frame);
1173  if (current->show_frame &&
1177  frame_presentation_time);
1178  }
1179  if (current->show_frame)
1180  infer(showable_frame, current->frame_type != AV1_FRAME_KEY);
1181  else
1182  flag(showable_frame);
1183 
1184  if (current->frame_type == AV1_FRAME_SWITCH ||
1185  (current->frame_type == AV1_FRAME_KEY && current->show_frame))
1186  infer(error_resilient_mode, 1);
1187  else
1188  flag(error_resilient_mode);
1189  }
1190 
1191  if (current->frame_type == AV1_FRAME_KEY && current->show_frame) {
1192  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1193  priv->ref[i].valid = 0;
1194  priv->ref[i].order_hint = 0;
1195  }
1196  }
1197 
1198  flag(disable_cdf_update);
1199 
1200  if (seq->seq_force_screen_content_tools ==
1202  flag(allow_screen_content_tools);
1203  } else {
1204  infer(allow_screen_content_tools,
1206  }
1207  if (current->allow_screen_content_tools) {
1209  flag(force_integer_mv);
1210  else
1211  infer(force_integer_mv, seq->seq_force_integer_mv);
1212  } else {
1213  infer(force_integer_mv, 0);
1214  }
1215 
1216  if (seq->frame_id_numbers_present_flag) {
1217  fb(id_len, current_frame_id);
1218 
1219  diff_len = seq->delta_frame_id_length_minus_2 + 2;
1220  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1221  if (current->current_frame_id > (1 << diff_len)) {
1222  if (priv->ref[i].frame_id > current->current_frame_id ||
1223  priv->ref[i].frame_id < (current->current_frame_id -
1224  (1 << diff_len)))
1225  priv->ref[i].valid = 0;
1226  } else {
1227  if (priv->ref[i].frame_id > current->current_frame_id &&
1228  priv->ref[i].frame_id < ((1 << id_len) +
1229  current->current_frame_id -
1230  (1 << diff_len)))
1231  priv->ref[i].valid = 0;
1232  }
1233  }
1234  } else {
1235  infer(current_frame_id, 0);
1236  }
1237 
1238  if (current->frame_type == AV1_FRAME_SWITCH)
1239  infer(frame_size_override_flag, 1);
1240  else if(seq->reduced_still_picture_header)
1241  infer(frame_size_override_flag, 0);
1242  else
1243  flag(frame_size_override_flag);
1244 
1245  order_hint_bits =
1246  seq->enable_order_hint ? seq->order_hint_bits_minus_1 + 1 : 0;
1247  if (order_hint_bits > 0)
1248  fb(order_hint_bits, order_hint);
1249  else
1250  infer(order_hint, 0);
1251 
1252  if (frame_is_intra || current->error_resilient_mode)
1253  infer(primary_ref_frame, AV1_PRIMARY_REF_NONE);
1254  else
1255  fb(3, primary_ref_frame);
1256 
1258  flag(buffer_removal_time_present_flag);
1259  if (current->buffer_removal_time_present_flag) {
1260  for (i = 0; i <= seq->operating_points_cnt_minus_1; i++) {
1262  int op_pt_idc = seq->operating_point_idc[i];
1263  int in_temporal_layer = (op_pt_idc >> priv->temporal_id ) & 1;
1264  int in_spatial_layer = (op_pt_idc >> (priv->spatial_id + 8)) & 1;
1265  if (seq->operating_point_idc[i] == 0 ||
1266  in_temporal_layer || in_spatial_layer) {
1268  buffer_removal_time[i], 1, i);
1269  }
1270  }
1271  }
1272  }
1273  }
1274 
1275  if (current->frame_type == AV1_FRAME_SWITCH ||
1276  (current->frame_type == AV1_FRAME_KEY && current->show_frame))
1277  infer(refresh_frame_flags, all_frames);
1278  else
1279  fb(8, refresh_frame_flags);
1280 
1281  if (!frame_is_intra || current->refresh_frame_flags != all_frames) {
1282  if (current->error_resilient_mode && seq->enable_order_hint) {
1283  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1284  fbs(order_hint_bits, ref_order_hint[i], 1, i);
1285  if (current->ref_order_hint[i] != priv->ref[i].order_hint)
1286  priv->ref[i].valid = 0;
1287  }
1288  }
1289  }
1290 
1291  if (current->frame_type == AV1_FRAME_KEY ||
1292  current->frame_type == AV1_FRAME_INTRA_ONLY) {
1293  CHECK(FUNC(frame_size)(ctx, rw, current));
1294  CHECK(FUNC(render_size)(ctx, rw, current));
1295 
1296  if (current->allow_screen_content_tools &&
1297  priv->upscaled_width == priv->frame_width)
1298  flag(allow_intrabc);
1299  else
1300  infer(allow_intrabc, 0);
1301 
1302  } else {
1303  if (!seq->enable_order_hint) {
1304  infer(frame_refs_short_signaling, 0);
1305  } else {
1306  flag(frame_refs_short_signaling);
1307  if (current->frame_refs_short_signaling) {
1308  fb(3, last_frame_idx);
1309  fb(3, golden_frame_idx);
1310 
1311  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
1312  if (i == 0)
1313  infer(ref_frame_idx[i], current->last_frame_idx);
1314  else if (i == AV1_REF_FRAME_GOLDEN -
1316  infer(ref_frame_idx[i], current->golden_frame_idx);
1317  else
1318  infer(ref_frame_idx[i], -1);
1319  }
1320  }
1321  }
1322 
1323  for (i = 0; i < AV1_REFS_PER_FRAME; i++) {
1324  if (!current->frame_refs_short_signaling)
1325  fbs(3, ref_frame_idx[i], 1, i);
1326  if (seq->frame_id_numbers_present_flag) {
1328  delta_frame_id_minus1[i], 1, i);
1329  }
1330  }
1331 
1332  if (current->frame_size_override_flag &&
1333  !current->error_resilient_mode) {
1334  CHECK(FUNC(frame_size_with_refs)(ctx, rw, current));
1335  } else {
1336  CHECK(FUNC(frame_size)(ctx, rw, current));
1337  CHECK(FUNC(render_size)(ctx, rw, current));
1338  }
1339 
1340  if (current->force_integer_mv)
1341  infer(allow_high_precision_mv, 0);
1342  else
1343  flag(allow_high_precision_mv);
1344 
1345  CHECK(FUNC(interpolation_filter)(ctx, rw, current));
1346 
1347  flag(is_motion_mode_switchable);
1348 
1349  if (current->error_resilient_mode ||
1350  !seq->enable_ref_frame_mvs)
1351  infer(use_ref_frame_mvs, 0);
1352  else
1353  flag(use_ref_frame_mvs);
1354 
1355  infer(allow_intrabc, 0);
1356  }
1357 
1358  if (!frame_is_intra) {
1359  // Derive reference frame sign biases.
1360  }
1361 
1362  if (seq->reduced_still_picture_header || current->disable_cdf_update)
1363  infer(disable_frame_end_update_cdf, 1);
1364  else
1365  flag(disable_frame_end_update_cdf);
1366 
1367  if (current->primary_ref_frame == AV1_PRIMARY_REF_NONE) {
1368  // Init non-coeff CDFs.
1369  // Setup past independence.
1370  } else {
1371  // Load CDF tables from previous frame.
1372  // Load params from previous frame.
1373  }
1374 
1375  if (current->use_ref_frame_mvs) {
1376  // Perform motion field estimation process.
1377  }
1378 
1379  CHECK(FUNC(tile_info)(ctx, rw, current));
1380 
1381  CHECK(FUNC(quantization_params)(ctx, rw, current));
1382 
1383  CHECK(FUNC(segmentation_params)(ctx, rw, current));
1384 
1385  CHECK(FUNC(delta_q_params)(ctx, rw, current));
1386 
1387  CHECK(FUNC(delta_lf_params)(ctx, rw, current));
1388 
1389  // Init coeff CDFs / load previous segments.
1390 
1391  priv->coded_lossless = 1;
1392  for (i = 0; i < AV1_MAX_SEGMENTS; i++) {
1393  int qindex;
1394  if (current->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {
1395  qindex = (current->base_q_idx +
1396  current->feature_value[i][AV1_SEG_LVL_ALT_Q]);
1397  } else {
1398  qindex = current->base_q_idx;
1399  }
1400  qindex = av_clip_uintp2(qindex, 8);
1401 
1402  if (qindex || current->delta_q_y_dc ||
1403  current->delta_q_u_ac || current->delta_q_u_dc ||
1404  current->delta_q_v_ac || current->delta_q_v_dc) {
1405  priv->coded_lossless = 0;
1406  }
1407  }
1408  priv->all_lossless = priv->coded_lossless &&
1409  priv->frame_width == priv->upscaled_width;
1410 
1411  CHECK(FUNC(loop_filter_params)(ctx, rw, current));
1412 
1413  CHECK(FUNC(cdef_params)(ctx, rw, current));
1414 
1415  CHECK(FUNC(lr_params)(ctx, rw, current));
1416 
1417  CHECK(FUNC(read_tx_mode)(ctx, rw, current));
1418 
1419  CHECK(FUNC(frame_reference_mode)(ctx, rw, current));
1420 
1421  CHECK(FUNC(skip_mode_params)(ctx, rw, current));
1422 
1423  if (frame_is_intra || current->error_resilient_mode ||
1424  !seq->enable_warped_motion)
1425  infer(allow_warped_motion, 0);
1426  else
1427  flag(allow_warped_motion);
1428 
1429  flag(reduced_tx_set);
1430 
1431  CHECK(FUNC(global_motion_params)(ctx, rw, current));
1432 
1433  CHECK(FUNC(film_grain_params)(ctx, rw, current));
1434 
1435  for (i = 0; i < AV1_NUM_REF_FRAMES; i++) {
1436  if (current->refresh_frame_flags & (1 << i)) {
1437  priv->ref[i] = (AV1ReferenceFrameState) {
1438  .valid = 1,
1439  .frame_id = current->current_frame_id,
1440  .upscaled_width = priv->upscaled_width,
1441  .frame_width = priv->frame_width,
1442  .frame_height = priv->frame_height,
1443  .render_width = priv->render_width,
1444  .render_height = priv->render_height,
1445  .frame_type = current->frame_type,
1446  .subsampling_x = seq->color_config.subsampling_x,
1447  .subsampling_y = seq->color_config.subsampling_y,
1448  .bit_depth = priv->bit_depth,
1449  .order_hint = current->order_hint,
1450  };
1451  }
1452  }
1453 
1454  av_log(ctx->log_ctx, AV_LOG_DEBUG, "Frame %d: size %dx%d "
1455  "upscaled %d render %dx%d subsample %dx%d "
1456  "bitdepth %d tiles %dx%d.\n", current->order_hint,
1457  priv->frame_width, priv->frame_height, priv->upscaled_width,
1458  priv->render_width, priv->render_height,
1459  seq->color_config.subsampling_x + 1,
1460  seq->color_config.subsampling_y + 1, priv->bit_depth,
1461  priv->tile_rows, priv->tile_cols);
1462 
1463  return 0;
1464 }
1465 
1467  AV1RawFrameHeader *current, int redundant,
1468  AVBufferRef *rw_buffer_ref)
1469 {
1471  int start_pos, fh_bits, fh_bytes, err;
1472  uint8_t *fh_start;
1473 
1474  if (priv->seen_frame_header) {
1475  if (!redundant) {
1476  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid repeated "
1477  "frame header OBU.\n");
1478  return AVERROR_INVALIDDATA;
1479  } else {
1480  GetBitContext fh;
1481  size_t i, b;
1482  uint32_t val;
1483 
1484  HEADER("Redundant Frame Header");
1485 
1486  av_assert0(priv->frame_header_ref && priv->frame_header);
1487 
1488  init_get_bits(&fh, priv->frame_header,
1489  priv->frame_header_size);
1490  for (i = 0; i < priv->frame_header_size; i += 8) {
1491  b = FFMIN(priv->frame_header_size - i, 8);
1492  val = get_bits(&fh, b);
1493  xf(b, frame_header_copy[i],
1494  val, val, val, 1, i / 8);
1495  }
1496  }
1497  } else {
1498  if (redundant)
1499  HEADER("Redundant Frame Header (used as Frame Header)");
1500  else
1501  HEADER("Frame Header");
1502 
1503 #ifdef READ
1504  start_pos = get_bits_count(rw);
1505 #else
1506  start_pos = put_bits_count(rw);
1507 #endif
1508 
1509  CHECK(FUNC(uncompressed_header)(ctx, rw, current));
1510 
1511  if (current->show_existing_frame) {
1512  priv->seen_frame_header = 0;
1513  } else {
1514  priv->seen_frame_header = 1;
1515 
1517 
1518 #ifdef READ
1519  fh_bits = get_bits_count(rw) - start_pos;
1520  fh_start = (uint8_t*)rw->buffer + start_pos / 8;
1521 #else
1522  // Need to flush the bitwriter so that we can copy its output,
1523  // but use a copy so we don't affect the caller's structure.
1524  {
1525  PutBitContext tmp = *rw;
1526  flush_put_bits(&tmp);
1527  }
1528 
1529  fh_bits = put_bits_count(rw) - start_pos;
1530  fh_start = rw->buf + start_pos / 8;
1531 #endif
1532  fh_bytes = (fh_bits + 7) / 8;
1533 
1534  priv->frame_header_size = fh_bits;
1535 
1536  if (rw_buffer_ref) {
1537  priv->frame_header_ref = av_buffer_ref(rw_buffer_ref);
1538  if (!priv->frame_header_ref)
1539  return AVERROR(ENOMEM);
1540  priv->frame_header = fh_start;
1541  } else {
1542  priv->frame_header_ref =
1544  if (!priv->frame_header_ref)
1545  return AVERROR(ENOMEM);
1546  priv->frame_header = priv->frame_header_ref->data;
1547  memcpy(priv->frame_header, fh_start, fh_bytes);
1548  }
1549  }
1550  }
1551 
1552  return 0;
1553 }
1554 
1556  AV1RawTileGroup *current)
1557 {
1559  int num_tiles, tile_bits;
1560  int err;
1561 
1562  HEADER("Tile Group");
1563 
1564  num_tiles = priv->tile_cols * priv->tile_rows;
1565  if (num_tiles > 1)
1566  flag(tile_start_and_end_present_flag);
1567  else
1568  infer(tile_start_and_end_present_flag, 0);
1569 
1570  if (num_tiles == 1 || !current->tile_start_and_end_present_flag) {
1571  infer(tg_start, 0);
1572  infer(tg_end, num_tiles - 1);
1573  } else {
1574  tile_bits = cbs_av1_tile_log2(1, priv->tile_cols) +
1575  cbs_av1_tile_log2(1, priv->tile_rows);
1576  fb(tile_bits, tg_start);
1577  fb(tile_bits, tg_end);
1578  }
1579 
1580  CHECK(FUNC(byte_alignment)(ctx, rw));
1581 
1582  // Reset header for next frame.
1583  if (current->tg_end == num_tiles - 1)
1584  priv->seen_frame_header = 0;
1585 
1586  // Tile data follows.
1587 
1588  return 0;
1589 }
1590 
1592  AV1RawFrame *current,
1593  AVBufferRef *rw_buffer_ref)
1594 {
1595  int err;
1596 
1597  CHECK(FUNC(frame_header_obu)(ctx, rw, &current->header,
1598  0, rw_buffer_ref));
1599 
1600  CHECK(FUNC(byte_alignment)(ctx, rw));
1601 
1602  CHECK(FUNC(tile_group_obu)(ctx, rw, &current->tile_group));
1603 
1604  return 0;
1605 }
1606 
1608  AV1RawTileList *current)
1609 {
1610  int err;
1611 
1612  fb(8, output_frame_width_in_tiles_minus_1);
1613  fb(8, output_frame_height_in_tiles_minus_1);
1614 
1615  fb(16, tile_count_minus_1);
1616 
1617  // Tile data follows.
1618 
1619  return 0;
1620 }
1621 
1623  AV1RawMetadataHDRCLL *current)
1624 {
1625  int err;
1626 
1627  fb(16, max_cll);
1628  fb(16, max_fall);
1629 
1630  return 0;
1631 }
1632 
1634  AV1RawMetadataHDRMDCV *current)
1635 {
1636  int err, i;
1637 
1638  for (i = 0; i < 3; i++) {
1639  fbs(16, primary_chromaticity_x[i], 1, i);
1640  fbs(16, primary_chromaticity_y[i], 1, i);
1641  }
1642 
1643  fb(16, white_point_chromaticity_x);
1644  fb(16, white_point_chromaticity_y);
1645 
1646  fc(32, luminance_max, 1, MAX_UINT_BITS(32));
1647  // luminance_min must be lower than luminance_max. Convert luminance_max from
1648  // 24.8 fixed point to 18.14 fixed point in order to compare them.
1649  fc(32, luminance_min, 0, FFMIN(((uint64_t)current->luminance_max << 6) - 1,
1650  MAX_UINT_BITS(32)));
1651 
1652  return 0;
1653 }
1654 
1656  AV1RawMetadataScalability *current)
1657 {
1659  const AV1RawSequenceHeader *seq;
1660  int err, i, j;
1661 
1662  if (!priv->sequence_header) {
1663  av_log(ctx->log_ctx, AV_LOG_ERROR, "No sequence header available: "
1664  "unable to parse scalability metadata.\n");
1665  return AVERROR_INVALIDDATA;
1666  }
1667  seq = priv->sequence_header;
1668 
1669  fb(2, spatial_layers_cnt_minus_1);
1670  flag(spatial_layer_dimensions_present_flag);
1671  flag(spatial_layer_description_present_flag);
1672  flag(temporal_group_description_present_flag);
1673  fc(3, scalability_structure_reserved_3bits, 0, 0);
1674  if (current->spatial_layer_dimensions_present_flag) {
1675  for (i = 0; i <= current->spatial_layers_cnt_minus_1; i++) {
1676  fcs(16, spatial_layer_max_width[i],
1677  0, seq->max_frame_width_minus_1 + 1, 1, i);
1678  fcs(16, spatial_layer_max_height[i],
1679  0, seq->max_frame_height_minus_1 + 1, 1, i);
1680  }
1681  }
1682  if (current->spatial_layer_description_present_flag) {
1683  for (i = 0; i <= current->spatial_layers_cnt_minus_1; i++)
1684  fbs(8, spatial_layer_ref_id[i], 1, i);
1685  }
1686  if (current->temporal_group_description_present_flag) {
1687  fb(8, temporal_group_size);
1688  for (i = 0; i < current->temporal_group_size; i++) {
1689  fbs(3, temporal_group_temporal_id[i], 1, i);
1690  flags(temporal_group_temporal_switching_up_point_flag[i], 1, i);
1691  flags(temporal_group_spatial_switching_up_point_flag[i], 1, i);
1692  fbs(3, temporal_group_ref_cnt[i], 1, i);
1693  for (j = 0; j < current->temporal_group_ref_cnt[i]; j++) {
1694  fbs(8, temporal_group_ref_pic_diff[i][j], 2, i, j);
1695  }
1696  }
1697  }
1698 
1699  return 0;
1700 }
1701 
1703  AV1RawMetadataScalability *current)
1704 {
1705  int err;
1706 
1707  fb(8, scalability_mode_idc);
1708 
1709  if (current->scalability_mode_idc == AV1_SCALABILITY_SS)
1710  CHECK(FUNC(scalability_structure)(ctx, rw, current));
1711 
1712  return 0;
1713 }
1714 
1716  AV1RawMetadataITUTT35 *current)
1717 {
1718  int err;
1719  size_t i;
1720 
1721  fb(8, itu_t_t35_country_code);
1722  if (current->itu_t_t35_country_code == 0xff)
1723  fb(8, itu_t_t35_country_code_extension_byte);
1724 
1725 #ifdef READ
1726  // The payload runs up to the start of the trailing bits, but there might
1727  // be arbitrarily many trailing zeroes so we need to read through twice.
1728  current->payload_size = cbs_av1_get_payload_bytes_left(rw);
1729 
1730  current->payload_ref = av_buffer_alloc(current->payload_size);
1731  if (!current->payload_ref)
1732  return AVERROR(ENOMEM);
1733  current->payload = current->payload_ref->data;
1734 #endif
1735 
1736  for (i = 0; i < current->payload_size; i++)
1737  xf(8, itu_t_t35_payload_bytes[i], current->payload[i],
1738  0x00, 0xff, 1, i);
1739 
1740  return 0;
1741 }
1742 
1744  AV1RawMetadataTimecode *current)
1745 {
1746  int err;
1747 
1748  fb(5, counting_type);
1749  flag(full_timestamp_flag);
1750  flag(discontinuity_flag);
1751  flag(cnt_dropped_flag);
1752  fb(9, n_frames);
1753 
1754  if (current->full_timestamp_flag) {
1755  fc(6, seconds_value, 0, 59);
1756  fc(6, minutes_value, 0, 59);
1757  fc(5, hours_value, 0, 23);
1758  } else {
1759  flag(seconds_flag);
1760  if (current->seconds_flag) {
1761  fc(6, seconds_value, 0, 59);
1762  flag(minutes_flag);
1763  if (current->minutes_flag) {
1764  fc(6, minutes_value, 0, 59);
1765  flag(hours_flag);
1766  if (current->hours_flag)
1767  fc(5, hours_value, 0, 23);
1768  }
1769  }
1770  }
1771 
1772  fb(5, time_offset_length);
1773  if (current->time_offset_length > 0)
1774  fb(current->time_offset_length, time_offset_value);
1775  else
1776  infer(time_offset_length, 0);
1777 
1778  return 0;
1779 }
1780 
1782  AV1RawMetadata *current)
1783 {
1784  int err;
1785 
1786  leb128(metadata_type);
1787 
1788  switch (current->metadata_type) {
1790  CHECK(FUNC(metadata_hdr_cll)(ctx, rw, &current->metadata.hdr_cll));
1791  break;
1793  CHECK(FUNC(metadata_hdr_mdcv)(ctx, rw, &current->metadata.hdr_mdcv));
1794  break;
1796  CHECK(FUNC(metadata_scalability)(ctx, rw, &current->metadata.scalability));
1797  break;
1799  CHECK(FUNC(metadata_itut_t35)(ctx, rw, &current->metadata.itut_t35));
1800  break;
1802  CHECK(FUNC(metadata_timecode)(ctx, rw, &current->metadata.timecode));
1803  break;
1804  default:
1805  // Unknown metadata type.
1806  return AVERROR_PATCHWELCOME;
1807  }
1808 
1809  return 0;
1810 }
1811 
1813  AV1RawPadding *current)
1814 {
1815  int i, err;
1816 
1817  HEADER("Padding");
1818 
1819 #ifdef READ
1820  // The payload runs up to the start of the trailing bits, but there might
1821  // be arbitrarily many trailing zeroes so we need to read through twice.
1822  current->payload_size = cbs_av1_get_payload_bytes_left(rw);
1823 
1824  current->payload_ref = av_buffer_alloc(current->payload_size);
1825  if (!current->payload_ref)
1826  return AVERROR(ENOMEM);
1827  current->payload = current->payload_ref->data;
1828 #endif
1829 
1830  for (i = 0; i < current->payload_size; i++)
1831  xf(8, obu_padding_byte[i], current->payload[i], 0x00, 0xff, 1, i);
1832 
1833  return 0;
1834 }
AV1RawSequenceHeader::seq_force_integer_mv
uint8_t seq_force_integer_mv
Definition: cbs_av1.h:120
AV1_SUPERRES_NUM
@ AV1_SUPERRES_NUM
Definition: av1.h:100
tile_list_obu
static int FUNC() tile_list_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileList *current)
Definition: cbs_av1_syntax_template.c:1607
AV1_GM_TRANS_PREC_BITS
@ AV1_GM_TRANS_PREC_BITS
Definition: av1.h:110
uncompressed_header
static int FUNC() uncompressed_header(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:1116
av_buffer_alloc
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
AVERROR
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
CodedBitstreamAV1Context::seen_frame_header
int seen_frame_header
Definition: cbs_av1.h:422
CodedBitstreamAV1Context::tile_cols
int tile_cols
Definition: cbs_av1.h:441
AV1RawSequenceHeader
Definition: cbs_av1.h:73
segmentation_params
static int FUNC() segmentation_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:613
n
int n
Definition: avisynth_c.h:760
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
subexp
#define subexp(name, max, subs,...)
Definition: cbs_av1.c:697
superres_params
static int FUNC() superres_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:342
AV1RawSequenceHeader::operating_point_idc
uint16_t operating_point_idc[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:86
AV1RawPadding
Definition: cbs_av1.h:380
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
HEADER
#define HEADER(name)
Definition: cbs_av1.c:537
av_unused
#define av_unused
Definition: attributes.h:125
infer
#define infer(name, value)
Definition: cbs_av1.c:713
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
sus
#define sus(width, name, subs,...)
Definition: cbs_av1.c:567
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:168
CodedBitstreamAV1Context::frame_header_ref
AVBufferRef * frame_header_ref
Definition: cbs_av1.h:423
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:470
AV1_WARP_MODEL_ROTZOOM
@ AV1_WARP_MODEL_ROTZOOM
Definition: av1.h:115
AV1RawSequenceHeader::timing_info
AV1RawTimingInfo timing_info
Definition: cbs_av1.h:83
AV1_CSP_COLOCATED
@ AV1_CSP_COLOCATED
Definition: av1.h:127
AV1RawSequenceHeader::frame_id_numbers_present_flag
uint8_t frame_id_numbers_present_flag
Definition: cbs_av1.h:101
CodedBitstreamAV1Context::frame_header_size
size_t frame_header_size
Definition: cbs_av1.h:425
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:497
fc
#define fc(width, name, range_min, range_max)
Definition: cbs_av1.c:555
quantization_params
static int FUNC() quantization_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:566
AV1_REF_FRAME_GOLDEN
@ AV1_REF_FRAME_GOLDEN
Definition: av1.h:65
AV1RawSequenceHeader::decoder_model_info
AV1RawDecoderModelInfo decoder_model_info
Definition: cbs_av1.h:84
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
AV1ReferenceFrameState::order_hint
int order_hint
Definition: cbs_av1.h:415
AV1RawColorConfig::subsampling_y
uint8_t subsampling_y
Definition: cbs_av1.h:53
AV1RawColorConfig::separate_uv_delta_q
uint8_t separate_uv_delta_q
Definition: cbs_av1.h:55
AV1_MAX_TILE_COLS
@ AV1_MAX_TILE_COLS
Definition: av1.h:81
tile_info
static int FUNC() tile_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:468
metadata_itut_t35
static int FUNC() metadata_itut_t35(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataITUTT35 *current)
Definition: cbs_av1_syntax_template.c:1715
AV1RawColorConfig
Definition: cbs_av1.h:41
AV1RawFrame
Definition: cbs_av1.h:299
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AV1RawSequenceHeader::film_grain_params_present
uint8_t film_grain_params_present
Definition: cbs_av1.h:130
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:481
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
metadata_scalability
static int FUNC() metadata_scalability(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataScalability *current)
Definition: cbs_av1_syntax_template.c:1702
AV1_METADATA_TYPE_SCALABILITY
@ AV1_METADATA_TYPE_SCALABILITY
Definition: av1.h:46
AV1RawSequenceHeader::enable_ref_frame_mvs
uint8_t enable_ref_frame_mvs
Definition: cbs_av1.h:115
read_tx_mode
static int FUNC() read_tx_mode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:837
obu_header
static int FUNC() obu_header(CodedBitstreamContext *ctx, RWContext *rw, AV1RawOBUHeader *current)
Definition: cbs_av1_syntax_template.c:19
GetBitContext
Definition: get_bits.h:61
AV1RawSequenceHeader::decoder_model_present_for_this_op
uint8_t decoder_model_present_for_this_op[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:89
scalability_structure
static int FUNC() scalability_structure(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataScalability *current)
Definition: cbs_av1_syntax_template.c:1655
AV1RawTileList
Definition: cbs_av1.h:304
AV1ReferenceFrameState::frame_id
int frame_id
Definition: cbs_av1.h:405
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV1RawSequenceHeader::delta_frame_id_length_minus_2
uint8_t delta_frame_id_length_minus_2
Definition: cbs_av1.h:102
global_motion_params
static int FUNC() global_motion_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:974
AV1RawMetadataHDRMDCV
Definition: cbs_av1.h:317
AV1_FRAME_KEY
@ AV1_FRAME_KEY
Definition: av1.h:53
skip_mode_params
static int FUNC() skip_mode_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:865
AV1ReferenceFrameState::valid
int valid
Definition: cbs_av1.h:404
AV1RawDecoderModelInfo::frame_presentation_time_length_minus_1
uint8_t frame_presentation_time_length_minus_1
Definition: cbs_av1.h:70
show_frame
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
Definition: ffprobe.c:2112
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVFormatContext::metadata
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1582
AV1_GM_ABS_TRANS_BITS
@ AV1_GM_ABS_TRANS_BITS
Definition: av1.h:109
interpolation_filter
static int FUNC() interpolation_filter(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:453
AV1_INTERPOLATION_FILTER_SWITCHABLE
@ AV1_INTERPOLATION_FILTER_SWITCHABLE
Definition: av1.h:103
frame_size_with_refs
static int FUNC() frame_size_with_refs(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:413
CodedBitstreamAV1Context::frame_height
int frame_height
Definition: cbs_av1.h:433
CodedBitstreamAV1Context::upscaled_width
int upscaled_width
Definition: cbs_av1.h:434
AV1_REF_FRAME_INTRA
@ AV1_REF_FRAME_INTRA
Definition: av1.h:61
color_config
static int FUNC() color_config(CodedBitstreamContext *ctx, RWContext *rw, AV1RawColorConfig *current, int seq_profile)
Definition: cbs_av1_syntax_template.c:71
bits
uint8_t bits
Definition: vp3data.h:202
AV1RawDecoderModelInfo
Definition: cbs_av1.h:66
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
color_range
color_range
Definition: vf_selectivecolor.c:44
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:98
AV1RawMetadataHDRCLL
Definition: cbs_av1.h:312
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:446
PutBitContext
Definition: put_bits.h:35
AV1_FRAME_SWITCH
@ AV1_FRAME_SWITCH
Definition: av1.h:56
frame_size
static int FUNC() frame_size(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:368
AV1_MAX_TILE_ROWS
@ AV1_MAX_TILE_ROWS
Definition: av1.h:80
leb128
#define leb128(name)
Definition: cbs_av1.c:709
AV1RawMetadata
Definition: cbs_av1.h:369
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AV1RawTimingInfo
Definition: cbs_av1.h:58
av_buffer_unref
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
AV1RawMetadataScalability
Definition: cbs_av1.h:326
AV1RawFrameHeader
Definition: cbs_av1.h:133
AV1_PRIMARY_REF_NONE
@ AV1_PRIMARY_REF_NONE
Definition: av1.h:86
fbs
#define fbs(width, name, subs,...)
Definition: cbs_av1.c:561
AV1_METADATA_TYPE_ITUT_T35
@ AV1_METADATA_TYPE_ITUT_T35
Definition: av1.h:47
cbs_av1_get_payload_bytes_left
static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)
Definition: cbs_av1.c:525
lr_params
static int FUNC() lr_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:796
metadata_hdr_mdcv
static int FUNC() metadata_hdr_mdcv(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataHDRMDCV *current)
Definition: cbs_av1_syntax_template.c:1633
decoder_model_info
static int FUNC() decoder_model_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawDecoderModelInfo *current)
Definition: cbs_av1_syntax_template.c:167
delta_q
#define delta_q(name)
Definition: cbs_av1.c:703
delta_lf_params
static int FUNC() delta_lf_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:680
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:445
metadata_timecode
static int FUNC() metadata_timecode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataTimecode *current)
Definition: cbs_av1_syntax_template.c:1743
CodedBitstreamAV1Context::render_width
int render_width
Definition: cbs_av1.h:435
sequence_header_obu
static int FUNC() sequence_header_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawSequenceHeader *current)
Definition: cbs_av1_syntax_template.c:180
AV1_SEG_LVL_ALT_Q
@ AV1_SEG_LVL_ALT_Q
Definition: av1.h:91
AV1_FRAME_INTER
@ AV1_FRAME_INTER
Definition: av1.h:54
loop_filter_params
static int FUNC() loop_filter_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:706
AV1_SELECT_INTEGER_MV
@ AV1_SELECT_INTEGER_MV
Definition: av1.h:98
AV1RawSequenceHeader::seq_force_screen_content_tools
uint8_t seq_force_screen_content_tools
Definition: cbs_av1.h:118
AV1_REF_FRAME_BWDREF
@ AV1_REF_FRAME_BWDREF
Definition: av1.h:66
AV1_METADATA_TYPE_HDR_CLL
@ AV1_METADATA_TYPE_HDR_CLL
Definition: av1.h:44
render_size
static int FUNC() render_size(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:391
AV1_GM_ABS_ALPHA_BITS
@ AV1_GM_ABS_ALPHA_BITS
Definition: av1.h:105
AV1RawSequenceHeader::max_frame_height_minus_1
uint16_t max_frame_height_minus_1
Definition: cbs_av1.h:99
frame_header_obu
static int FUNC() frame_header_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current, int redundant, AVBufferRef *rw_buffer_ref)
Definition: cbs_av1_syntax_template.c:1466
AV1_MAX_TILE_WIDTH
@ AV1_MAX_TILE_WIDTH
Definition: av1.h:78
AV1_REF_FRAME_ALTREF2
@ AV1_REF_FRAME_ALTREF2
Definition: av1.h:67
FF_PROFILE_AV1_MAIN
#define FF_PROFILE_AV1_MAIN
Definition: avcodec.h:2991
AV1_METADATA_TYPE_HDR_MDCV
@ AV1_METADATA_TYPE_HDR_MDCV
Definition: av1.h:45
AV1_WARP_MODEL_AFFINE
@ AV1_WARP_MODEL_AFFINE
Definition: av1.h:116
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
frame_reference_mode
static int FUNC() frame_reference_mode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:851
fcs
#define fcs(width, name, range_min, range_max, subs,...)
Definition: cbs_av1.c:563
AV1RawSequenceHeader::use_128x128_superblock
uint8_t use_128x128_superblock
Definition: cbs_av1.h:105
CodedBitstreamAV1Context::tile_rows
int tile_rows
Definition: cbs_av1.h:442
AV1RawSequenceHeader::frame_height_bits_minus_1
uint8_t frame_height_bits_minus_1
Definition: cbs_av1.h:97
AV1_SUPERRES_DENOM_MIN
@ AV1_SUPERRES_DENOM_MIN
Definition: av1.h:101
CodedBitstreamAV1Context::frame_header
uint8_t * frame_header
Definition: cbs_av1.h:424
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:176
frame_obu
static int FUNC() frame_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrame *current, AVBufferRef *rw_buffer_ref)
Definition: cbs_av1_syntax_template.c:1591
val
const char const char void * val
Definition: avisynth_c.h:863
AV1ReferenceFrameState
Definition: cbs_av1.h:403
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AV1_FRAME_INTRA_ONLY
@ AV1_FRAME_INTRA_ONLY
Definition: av1.h:55
AV1_GM_TRANS_ONLY_PREC_BITS
@ AV1_GM_TRANS_ONLY_PREC_BITS
Definition: av1.h:108
ns
#define ns(max_value, name, subs,...)
Definition: cbs_av1.c:686
metadata_hdr_cll
static int FUNC() metadata_hdr_cll(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataHDRCLL *current)
Definition: cbs_av1_syntax_template.c:1622
CodedBitstreamAV1Context::frame_width
int frame_width
Definition: cbs_av1.h:432
flag
#define flag(name)
Definition: cbs_av1.c:557
cbs_av1_tile_log2
static int cbs_av1_tile_log2(int blksize, int target)
Definition: cbs_av1.c:506
CodedBitstreamAV1Context::spatial_id
int spatial_id
Definition: cbs_av1.h:428
CodedBitstreamAV1Context::coded_lossless
int coded_lossless
Definition: cbs_av1.h:439
AV1_OBU_PADDING
@ AV1_OBU_PADDING
Definition: av1.h:39
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
AV1RawSequenceHeader::enable_superres
uint8_t enable_superres
Definition: cbs_av1.h:124
AV1_REF_FRAME_LAST3
@ AV1_REF_FRAME_LAST3
Definition: av1.h:64
CodedBitstreamAV1Context::bit_depth
int bit_depth
Definition: cbs_av1.h:431
AV1_REF_FRAME_LAST2
@ AV1_REF_FRAME_LAST2
Definition: av1.h:63
increment
#define increment(name, min, max)
Definition: cbs_av1.c:692
AV1RawTimingInfo::equal_picture_interval
uint8_t equal_picture_interval
Definition: cbs_av1.h:62
fb
#define fb(width, name)
Definition: cbs_av1.c:553
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:668
uint8_t
uint8_t
Definition: audio_convert.c:194
AV1RawSequenceHeader::max_frame_width_minus_1
uint16_t max_frame_width_minus_1
Definition: cbs_av1.h:98
AV1RawSequenceHeader::color_config
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
AV1_NUM_REF_FRAMES
@ AV1_NUM_REF_FRAMES
Definition: av1.h:83
film_grain_params
static int FUNC() film_grain_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:1019
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:499
AV1RawSequenceHeader::enable_order_hint
uint8_t enable_order_hint
Definition: cbs_av1.h:113
AV1_TOTAL_REFS_PER_FRAME
@ AV1_TOTAL_REFS_PER_FRAME
Definition: av1.h:85
FF_PROFILE_AV1_PROFESSIONAL
#define FF_PROFILE_AV1_PROFESSIONAL
Definition: avcodec.h:2993
byte_alignment
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_av1_syntax_template.c:61
tile_group_obu
static int FUNC() tile_group_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileGroup *current)
Definition: cbs_av1_syntax_template.c:1555
AV1_MAX_SEGMENTS
@ AV1_MAX_SEGMENTS
Definition: av1.h:88
AV1RawColorConfig::subsampling_x
uint8_t subsampling_x
Definition: cbs_av1.h:52
AV1_REFS_PER_FRAME
@ AV1_REFS_PER_FRAME
Definition: av1.h:84
AV1_WARP_MODEL_IDENTITY
@ AV1_WARP_MODEL_IDENTITY
Definition: av1.h:113
frame
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
Definition: filter_design.txt:264
AV1RawDecoderModelInfo::buffer_removal_time_length_minus_1
uint8_t buffer_removal_time_length_minus_1
Definition: cbs_av1.h:69
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:790
cbs_av1_get_relative_dist
static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
Definition: cbs_av1.c:513
CodedBitstreamAV1Context::all_lossless
int all_lossless
Definition: cbs_av1.h:440
AV1RawMetadataITUTT35
Definition: cbs_av1.h:344
AV1RawSequenceHeader::frame_width_bits_minus_1
uint8_t frame_width_bits_minus_1
Definition: cbs_av1.h:96
AV1RawSequenceHeader::enable_warped_motion
uint8_t enable_warped_motion
Definition: cbs_av1.h:110
CodedBitstreamAV1Context::ref
AV1ReferenceFrameState * ref
Definition: cbs_av1.h:444
CodedBitstreamAV1Context::sequence_header
AV1RawSequenceHeader * sequence_header
Definition: cbs_av1.h:419
CodedBitstreamAV1Context::render_height
int render_height
Definition: cbs_av1.h:436
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
AV1RawColorConfig::mono_chrome
uint8_t mono_chrome
Definition: cbs_av1.h:44
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AV1_WARP_MODEL_TRANSLATION
@ AV1_WARP_MODEL_TRANSLATION
Definition: av1.h:114
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
CodedBitstreamAV1Context::num_planes
int num_planes
Definition: cbs_av1.h:438
AV1RawSequenceHeader::order_hint_bits_minus_1
uint8_t order_hint_bits_minus_1
Definition: cbs_av1.h:122
AV1RawMetadataTimecode
Definition: cbs_av1.h:353
uvlc
#define uvlc(name, range_min, range_max)
Definition: cbs_av1.c:681
AV1RawTileGroup
Definition: cbs_av1.h:291
cdef_params
static int FUNC() cdef_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:761
global_motion_param
static int FUNC() global_motion_param(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current, int type, int ref, int idx)
Definition: cbs_av1_syntax_template.c:945
temporal_delimiter_obu
static int FUNC() temporal_delimiter_obu(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_av1_syntax_template.c:331
AV1_REF_FRAME_ALTREF
@ AV1_REF_FRAME_ALTREF
Definition: av1.h:68
trailing_bits
static int FUNC() trailing_bits(CodedBitstreamContext *ctx, RWContext *rw, int nb_bits)
Definition: cbs_av1_syntax_template.c:44
AV1_SELECT_SCREEN_CONTENT_TOOLS
@ AV1_SELECT_SCREEN_CONTENT_TOOLS
Definition: av1.h:97
padding_obu
static int FUNC() padding_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawPadding *current)
Definition: cbs_av1_syntax_template.c:1812
zero
#define zero
Definition: regdef.h:64
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:81
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
AV1RawSequenceHeader::enable_restoration
uint8_t enable_restoration
Definition: cbs_av1.h:126
timing_info
static int FUNC() timing_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTimingInfo *current)
Definition: cbs_av1_syntax_template.c:152
AV1RawSequenceHeader::operating_points_cnt_minus_1
uint8_t operating_points_cnt_minus_1
Definition: cbs_av1.h:81
AV1_METADATA_TYPE_TIMECODE
@ AV1_METADATA_TYPE_TIMECODE
Definition: av1.h:48
AV1RawSequenceHeader::additional_frame_id_length_minus_1
uint8_t additional_frame_id_length_minus_1
Definition: cbs_av1.h:103
AV1_SCALABILITY_SS
@ AV1_SCALABILITY_SS
Definition: av1.h:146
AV1_REF_FRAME_LAST
@ AV1_REF_FRAME_LAST
Definition: av1.h:62
AV1RawSequenceHeader::enable_cdef
uint8_t enable_cdef
Definition: cbs_av1.h:125
AV1RawSequenceHeader::reduced_still_picture_header
uint8_t reduced_still_picture_header
Definition: cbs_av1.h:76
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:570
AV1_CSP_UNKNOWN
@ AV1_CSP_UNKNOWN
Definition: av1.h:125
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV1_SEG_LVL_MAX
@ AV1_SEG_LVL_MAX
Definition: av1.h:89
AV1_MAX_TILE_AREA
@ AV1_MAX_TILE_AREA
Definition: av1.h:79
FF_PROFILE_AV1_HIGH
#define FF_PROFILE_AV1_HIGH
Definition: avcodec.h:2992
RWContext
#define RWContext
Definition: cbs_av1.c:666
AV1RawOBUHeader
Definition: cbs_av1.h:29
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1370
AV1_GM_ALPHA_PREC_BITS
@ AV1_GM_ALPHA_PREC_BITS
Definition: av1.h:106
color_primaries
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
Definition: vf_colorspace.c:209
delta_q_params
static int FUNC() delta_q_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
Definition: cbs_av1_syntax_template.c:664
metadata_obu
static int FUNC() metadata_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadata *current)
Definition: cbs_av1_syntax_template.c:1781
AV1_GM_ABS_TRANS_ONLY_BITS
@ AV1_GM_ABS_TRANS_ONLY_BITS
Definition: av1.h:107
AV1RawSequenceHeader::decoder_model_info_present_flag
uint8_t decoder_model_info_present_flag
Definition: cbs_av1.h:79
CodedBitstreamAV1Context::temporal_id
int temporal_id
Definition: cbs_av1.h:427
CodedBitstreamAV1Context
Definition: cbs_av1.h:418