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