27 fc(1, obu_forbidden_bit, 0, 0);
30 flag(obu_extension_flag);
31 flag(obu_has_size_field);
33 fc(1, obu_reserved_1bit, 0, 0);
35 if (current->obu_extension_flag) {
38 fc(3, extension_header_reserved_3bits, 0, 0);
40 infer(temporal_id, 0);
56 fixed(1, trailing_one_bit, 1);
60 fixed(1, trailing_zero_bit, 0);
72 fixed(1, zero_bit, 0);
86 current->high_bitdepth) {
88 priv->
bit_depth = current->twelve_bit ? 12 : 10;
90 priv->
bit_depth = current->high_bitdepth ? 10 : 8;
94 infer(mono_chrome, 0);
97 priv->
num_planes = current->mono_chrome ? 1 : 3;
99 flag(color_description_present_flag);
100 if (current->color_description_present_flag) {
103 fb(8, matrix_coefficients);
110 if (current->mono_chrome) {
113 infer(subsampling_x, 1);
114 infer(subsampling_y, 1);
116 infer(separate_uv_delta_q, 0);
122 infer(subsampling_x, 0);
123 infer(subsampling_y, 0);
124 flag(separate_uv_delta_q);
130 infer(subsampling_x, 1);
131 infer(subsampling_y, 1);
133 infer(subsampling_x, 0);
134 infer(subsampling_y, 0);
137 fb(1, subsampling_x);
138 if (current->subsampling_x)
139 fb(1, subsampling_y);
141 infer(subsampling_y, 0);
143 infer(subsampling_x, 1);
144 infer(subsampling_y, 0);
147 if (current->subsampling_x && current->subsampling_y) {
152 flag(separate_uv_delta_q);
166 flag(equal_picture_interval);
167 if (current->equal_picture_interval)
178 fb(5, buffer_delay_length_minus_1);
179 fb(32, num_units_in_decoding_tick);
180 fb(5, buffer_removal_time_length_minus_1);
181 fb(5, frame_presentation_time_length_minus_1);
191 HEADER(
"Sequence Header");
196 flag(reduced_still_picture_header);
198 if (current->reduced_still_picture_header) {
199 infer(timing_info_present_flag, 0);
200 infer(decoder_model_info_present_flag, 0);
201 infer(initial_display_delay_present_flag, 0);
202 infer(operating_points_cnt_minus_1, 0);
203 infer(operating_point_idc[0], 0);
205 fb(5, seq_level_idx[0]);
207 infer(seq_tier[0], 0);
208 infer(decoder_model_present_for_this_op[0], 0);
209 infer(initial_display_delay_present_for_this_op[0], 0);
212 flag(timing_info_present_flag);
213 if (current->timing_info_present_flag) {
216 flag(decoder_model_info_present_flag);
217 if (current->decoder_model_info_present_flag) {
219 (
ctx, rw, ¤t->decoder_model_info));
222 infer(decoder_model_info_present_flag, 0);
225 flag(initial_display_delay_present_flag);
227 fb(5, operating_points_cnt_minus_1);
228 for (i = 0; i <= current->operating_points_cnt_minus_1; i++) {
229 fbs(12, operating_point_idc[i], 1, i);
230 fbs(5, seq_level_idx[i], 1, i);
232 if (current->seq_level_idx[i] > 7)
233 flags(seq_tier[i], 1, i);
235 infer(seq_tier[i], 0);
237 if (current->decoder_model_info_present_flag) {
238 flags(decoder_model_present_for_this_op[i], 1, i);
239 if (current->decoder_model_present_for_this_op[i]) {
240 int n = current->decoder_model_info.buffer_delay_length_minus_1 + 1;
241 fbs(n, decoder_buffer_delay[i], 1, i);
242 fbs(n, encoder_buffer_delay[i], 1, i);
243 flags(low_delay_mode_flag[i], 1, i);
246 infer(decoder_model_present_for_this_op[i], 0);
249 if (current->initial_display_delay_present_flag) {
250 flags(initial_display_delay_present_for_this_op[i], 1, i);
251 if (current->initial_display_delay_present_for_this_op[i])
252 fbs(4, initial_display_delay_minus_1[i], 1, i);
257 fb(4, frame_width_bits_minus_1);
258 fb(4, frame_height_bits_minus_1);
260 fb(current->frame_width_bits_minus_1 + 1, max_frame_width_minus_1);
261 fb(current->frame_height_bits_minus_1 + 1, max_frame_height_minus_1);
263 if (current->reduced_still_picture_header)
264 infer(frame_id_numbers_present_flag, 0);
266 flag(frame_id_numbers_present_flag);
267 if (current->frame_id_numbers_present_flag) {
268 fb(4, delta_frame_id_length_minus_2);
269 fb(3, additional_frame_id_length_minus_1);
272 flag(use_128x128_superblock);
273 flag(enable_filter_intra);
274 flag(enable_intra_edge_filter);
276 if (current->reduced_still_picture_header) {
277 infer(enable_interintra_compound, 0);
278 infer(enable_masked_compound, 0);
279 infer(enable_warped_motion, 0);
280 infer(enable_dual_filter, 0);
281 infer(enable_order_hint, 0);
282 infer(enable_jnt_comp, 0);
283 infer(enable_ref_frame_mvs, 0);
285 infer(seq_force_screen_content_tools,
287 infer(seq_force_integer_mv,
290 flag(enable_interintra_compound);
291 flag(enable_masked_compound);
292 flag(enable_warped_motion);
293 flag(enable_dual_filter);
295 flag(enable_order_hint);
296 if (current->enable_order_hint) {
297 flag(enable_jnt_comp);
298 flag(enable_ref_frame_mvs);
300 infer(enable_jnt_comp, 0);
301 infer(enable_ref_frame_mvs, 0);
304 flag(seq_choose_screen_content_tools);
305 if (current->seq_choose_screen_content_tools)
306 infer(seq_force_screen_content_tools,
309 fb(1, seq_force_screen_content_tools);
310 if (current->seq_force_screen_content_tools > 0) {
311 flag(seq_choose_integer_mv);
312 if (current->seq_choose_integer_mv)
313 infer(seq_force_integer_mv,
316 fb(1, seq_force_integer_mv);
321 if (current->enable_order_hint)
322 fb(3, order_hint_bits_minus_1);
325 flag(enable_superres);
327 flag(enable_restoration);
330 current->seq_profile));
332 flag(film_grain_params_present);
341 HEADER(
"Temporal Delimiter");
359 int cur_frame_hint, latest_order_hint, earliest_order_hint,
ref;
363 ref_frame_idx[i] = -1;
369 used_frame[current->last_frame_idx] = 1;
370 used_frame[current->golden_frame_idx] = 1;
374 shifted_order_hints[i] = cur_frame_hint +
378 latest_order_hint = shifted_order_hints[current->last_frame_idx];
379 earliest_order_hint = shifted_order_hints[current->golden_frame_idx];
383 int hint = shifted_order_hints[
i];
384 if (!used_frame[i] && hint >= cur_frame_hint &&
385 (ref < 0 || hint >= latest_order_hint)) {
387 latest_order_hint = hint;
397 int hint = shifted_order_hints[
i];
398 if (!used_frame[i] && hint >= cur_frame_hint &&
399 (ref < 0 || hint < earliest_order_hint)) {
401 earliest_order_hint = hint;
411 int hint = shifted_order_hints[
i];
412 if (!used_frame[i] && hint >= cur_frame_hint &&
413 (ref < 0 || hint < earliest_order_hint)) {
415 earliest_order_hint = hint;
423 for (i = 0; i < AV1_REFS_PER_FRAME - 2; i++) {
424 int ref_frame = ref_frame_list[
i];
428 int hint = shifted_order_hints[j];
429 if (!used_frame[j] && hint < cur_frame_hint &&
430 (ref < 0 || hint >= latest_order_hint)) {
432 latest_order_hint = hint;
444 int hint = shifted_order_hints[
i];
445 if (ref < 0 || hint < earliest_order_hint) {
447 earliest_order_hint = hint;
451 if (ref_frame_idx[i] < 0)
452 ref_frame_idx[
i] =
ref;
453 infer(ref_frame_idx[i], ref_frame_idx[i]);
469 infer(use_superres, 0);
471 if (current->use_superres) {
492 if (current->frame_size_override_flag) {
500 priv->
frame_width = current->frame_width_minus_1 + 1;
514 flag(render_and_frame_size_different);
516 if (current->render_and_frame_size_different) {
517 fb(16, render_width_minus_1);
518 fb(16, render_height_minus_1);
520 infer(render_width_minus_1, current->frame_width_minus_1);
521 infer(render_height_minus_1, current->frame_height_minus_1);
537 flags(found_ref[i], 1, i);
538 if (current->found_ref[i]) {
540 &priv->
ref[current->ref_frame_idx[
i]];
544 "Missing reference frame needed for frame size " 545 "(ref = %d, ref_frame_idx = %d).\n",
546 i, current->ref_frame_idx[i]);
564 if (i >= AV1_REFS_PER_FRAME) {
579 flag(is_filter_switchable);
580 if (current->is_filter_switchable)
594 int mi_cols, mi_rows, sb_cols, sb_rows, sb_shift, sb_size;
595 int max_tile_width_sb, max_tile_height_sb, max_tile_area_sb;
596 int min_log2_tile_cols, max_log2_tile_cols, max_log2_tile_rows;
597 int min_log2_tiles, min_log2_tile_rows;
604 : ((mi_cols + 15) >> 4);
606 : ((mi_rows + 15) >> 4);
609 sb_size = sb_shift + 2;
617 min_log2_tiles =
FFMAX(min_log2_tile_cols,
620 flag(uniform_tile_spacing_flag);
622 if (current->uniform_tile_spacing_flag) {
623 int tile_width_sb, tile_height_sb;
625 increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
627 tile_width_sb = (sb_cols + (1 << current->tile_cols_log2) - 1) >>
628 current->tile_cols_log2;
629 current->tile_cols = (sb_cols + tile_width_sb - 1) / tile_width_sb;
631 min_log2_tile_rows =
FFMAX(min_log2_tiles - current->tile_cols_log2, 0);
633 increment(tile_rows_log2, min_log2_tile_rows, max_log2_tile_rows);
635 tile_height_sb = (sb_rows + (1 << current->tile_rows_log2) - 1) >>
636 current->tile_rows_log2;
637 current->tile_rows = (sb_rows + tile_height_sb - 1) / tile_height_sb;
639 for (i = 0; i < current->tile_cols - 1; i++)
640 infer(width_in_sbs_minus_1[i], tile_width_sb - 1);
641 infer(width_in_sbs_minus_1[i],
642 sb_cols - (current->tile_cols - 1) * tile_width_sb - 1);
643 for (i = 0; i < current->tile_rows - 1; i++)
644 infer(height_in_sbs_minus_1[i], tile_height_sb - 1);
645 infer(height_in_sbs_minus_1[i],
646 sb_rows - (current->tile_rows - 1) * tile_height_sb - 1);
649 int widest_tile_sb, start_sb, size_sb, max_width, max_height;
655 max_width =
FFMIN(sb_cols - start_sb, max_tile_width_sb);
656 ns(max_width, width_in_sbs_minus_1[i], 1, i);
657 size_sb = current->width_in_sbs_minus_1[
i] + 1;
658 widest_tile_sb =
FFMAX(size_sb, widest_tile_sb);
662 current->tile_cols =
i;
664 if (min_log2_tiles > 0)
665 max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
667 max_tile_area_sb = sb_rows * sb_cols;
668 max_tile_height_sb =
FFMAX(max_tile_area_sb / widest_tile_sb, 1);
672 max_height =
FFMIN(sb_rows - start_sb, max_tile_height_sb);
673 ns(max_height, height_in_sbs_minus_1[i], 1, i);
674 size_sb = current->height_in_sbs_minus_1[
i] + 1;
678 current->tile_rows =
i;
681 if (current->tile_cols_log2 > 0 ||
682 current->tile_rows_log2 > 0) {
683 fb(current->tile_cols_log2 + current->tile_rows_log2,
684 context_update_tile_id);
685 fb(2, tile_size_bytes_minus1);
687 infer(context_update_tile_id, 0);
711 infer(diff_uv_delta, 0);
716 if (current->diff_uv_delta) {
720 infer(delta_q_v_dc, current->delta_q_u_dc);
721 infer(delta_q_v_ac, current->delta_q_u_ac);
724 infer(delta_q_u_dc, 0);
725 infer(delta_q_u_ac, 0);
726 infer(delta_q_v_dc, 0);
727 infer(delta_q_v_ac, 0);
731 if (current->using_qmatrix) {
737 infer(qm_v, current->qm_u);
753 flag(segmentation_enabled);
755 if (current->segmentation_enabled) {
757 infer(segmentation_update_map, 1);
758 infer(segmentation_temporal_update, 0);
759 infer(segmentation_update_data, 1);
761 flag(segmentation_update_map);
762 if (current->segmentation_update_map)
763 flag(segmentation_temporal_update);
765 infer(segmentation_temporal_update, 0);
766 flag(segmentation_update_data);
770 const uint8_t *ref_feature_enabled;
771 const int16_t *ref_feature_value;
774 ref_feature_enabled = default_feature_enabled;
775 ref_feature_value = default_feature_value;
777 ref_feature_enabled =
784 if (current->segmentation_update_data) {
785 flags(feature_enabled[i][j], 2, i, j);
787 if (current->feature_enabled[i][j] && bits[j] > 0) {
789 sus(1 + bits[j], feature_value[i][j], 2, i, j);
791 fbs(bits[j], feature_value[i][j], 2, i, j);
793 infer(feature_value[i][j], 0);
796 infer(feature_enabled[i][j], ref_feature_enabled[j]);
797 infer(feature_value[i][j], ref_feature_value[j]);
804 infer(feature_enabled[i][j], 0);
805 infer(feature_value[i][j], 0);
818 if (current->base_q_idx > 0)
819 flag(delta_q_present);
821 infer(delta_q_present, 0);
823 if (current->delta_q_present)
834 if (current->delta_q_present) {
835 if (!current->allow_intrabc)
836 flag(delta_lf_present);
838 infer(delta_lf_present, 0);
839 if (current->delta_lf_present) {
841 flag(delta_lf_multi);
843 infer(delta_lf_res, 0);
844 infer(delta_lf_multi, 0);
847 infer(delta_lf_present, 0);
848 infer(delta_lf_res, 0);
849 infer(delta_lf_multi, 0);
860 { 1, 0, 0, 0, -1, 0, -1, -1 };
861 static const int8_t default_loop_filter_mode_deltas[2] = { 0, 0 };
865 infer(loop_filter_level[0], 0);
866 infer(loop_filter_level[1], 0);
875 for (i = 0; i < 2; i++)
876 infer(loop_filter_mode_deltas[i], 0);
880 fb(6, loop_filter_level[0]);
881 fb(6, loop_filter_level[1]);
884 if (current->loop_filter_level[0] ||
885 current->loop_filter_level[1]) {
886 fb(6, loop_filter_level[2]);
887 fb(6, loop_filter_level[3]);
891 fb(3, loop_filter_sharpness);
893 flag(loop_filter_delta_enabled);
894 if (current->loop_filter_delta_enabled) {
895 const int8_t *ref_loop_filter_ref_deltas, *ref_loop_filter_mode_deltas;
898 ref_loop_filter_ref_deltas = default_loop_filter_ref_deltas;
899 ref_loop_filter_mode_deltas = default_loop_filter_mode_deltas;
901 ref_loop_filter_ref_deltas =
903 ref_loop_filter_mode_deltas =
907 flag(loop_filter_delta_update);
909 if (current->loop_filter_delta_update)
910 flags(update_ref_delta[i], 1, i);
912 infer(update_ref_delta[i], 0);
913 if (current->update_ref_delta[i])
914 sus(1 + 6, loop_filter_ref_deltas[i], 1, i);
916 infer(loop_filter_ref_deltas[i], ref_loop_filter_ref_deltas[i]);
918 for (i = 0; i < 2; i++) {
919 if (current->loop_filter_delta_update)
920 flags(update_mode_delta[i], 1, i);
922 infer(update_mode_delta[i], 0);
923 if (current->update_mode_delta[i])
924 sus(1 + 6, loop_filter_mode_deltas[i], 1, i);
926 infer(loop_filter_mode_deltas[i], ref_loop_filter_mode_deltas[i]);
930 infer(loop_filter_ref_deltas[i], default_loop_filter_ref_deltas[i]);
931 for (i = 0; i < 2; i++)
932 infer(loop_filter_mode_deltas[i], default_loop_filter_mode_deltas[i]);
947 infer(cdef_damping_minus_3, 0);
949 infer(cdef_y_pri_strength[0], 0);
950 infer(cdef_y_sec_strength[0], 0);
951 infer(cdef_uv_pri_strength[0], 0);
952 infer(cdef_uv_sec_strength[0], 0);
957 fb(2, cdef_damping_minus_3);
960 for (i = 0; i < (1 << current->cdef_bits); i++) {
961 fbs(4, cdef_y_pri_strength[i], 1, i);
962 fbs(2, cdef_y_sec_strength[i], 1, i);
965 fbs(4, cdef_uv_pri_strength[i], 1, i);
966 fbs(2, cdef_uv_sec_strength[i], 1, i);
978 int uses_lr, uses_chroma_lr;
986 uses_lr = uses_chroma_lr = 0;
988 fbs(2, lr_type[i], 1, i);
1007 infer(lr_uv_shift, 0);
1035 infer(reference_select, 0);
1037 flag(reference_select);
1047 int skip_mode_allowed;
1053 skip_mode_allowed = 0;
1055 int forward_idx, backward_idx;
1056 int forward_hint, backward_hint;
1057 int ref_hint, dist,
i;
1066 if (forward_idx < 0 ||
1068 forward_hint) > 0) {
1070 forward_hint = ref_hint;
1072 }
else if (dist > 0) {
1073 if (backward_idx < 0 ||
1075 backward_hint) < 0) {
1077 backward_hint = ref_hint;
1082 if (forward_idx < 0) {
1083 skip_mode_allowed = 0;
1084 }
else if (backward_idx >= 0) {
1085 skip_mode_allowed = 1;
1088 int second_forward_idx;
1089 int second_forward_hint;
1091 second_forward_idx = -1;
1095 forward_hint) < 0) {
1096 if (second_forward_idx < 0 ||
1098 second_forward_hint) > 0) {
1099 second_forward_idx =
i;
1100 second_forward_hint = ref_hint;
1105 if (second_forward_idx < 0) {
1106 skip_mode_allowed = 0;
1108 skip_mode_allowed = 1;
1114 if (skip_mode_allowed)
1115 flag(skip_mode_present);
1117 infer(skip_mode_present, 0);
1126 uint32_t abs_bits, prec_bits, num_syms;
1142 num_syms = 2 * (1 << abs_bits) + 1;
1162 flags(is_global[ref], 1, ref);
1163 if (current->is_global[ref]) {
1164 flags(is_rot_zoom[ref], 1, ref);
1165 if (current->is_rot_zoom[ref]) {
1168 flags(is_translation[ref], 1, ref);
1202 int num_pos_luma, num_pos_chroma;
1211 if (!current->apply_grain)
1219 infer(update_grain, 1);
1221 if (!current->update_grain) {
1222 fb(3, film_grain_params_ref_idx);
1226 fc(4, num_y_points, 0, 14);
1227 for (i = 0; i < current->num_y_points; i++) {
1228 fcs(8, point_y_value[i],
1229 i ? current->point_y_value[i - 1] + 1 : 0,
1232 fbs(8, point_y_scaling[i], 1, i);
1236 infer(chroma_scaling_from_luma, 0);
1238 flag(chroma_scaling_from_luma);
1241 current->chroma_scaling_from_luma ||
1244 current->num_y_points == 0)) {
1245 infer(num_cb_points, 0);
1246 infer(num_cr_points, 0);
1248 fc(4, num_cb_points, 0, 10);
1249 for (i = 0; i < current->num_cb_points; i++) {
1250 fcs(8, point_cb_value[i],
1251 i ? current->point_cb_value[i - 1] + 1 : 0,
1254 fbs(8, point_cb_scaling[i], 1, i);
1256 fc(4, num_cr_points, 0, 10);
1257 for (i = 0; i < current->num_cr_points; i++) {
1258 fcs(8, point_cr_value[i],
1259 i ? current->point_cr_value[i - 1] + 1 : 0,
1262 fbs(8, point_cr_scaling[i], 1, i);
1266 fb(2, grain_scaling_minus_8);
1267 fb(2, ar_coeff_lag);
1268 num_pos_luma = 2 * current->ar_coeff_lag * (current->ar_coeff_lag + 1);
1269 if (current->num_y_points) {
1270 num_pos_chroma = num_pos_luma + 1;
1271 for (i = 0; i < num_pos_luma; i++)
1272 fbs(8, ar_coeffs_y_plus_128[i], 1, i);
1274 num_pos_chroma = num_pos_luma;
1276 if (current->chroma_scaling_from_luma || current->num_cb_points) {
1277 for (i = 0; i < num_pos_chroma; i++)
1278 fbs(8, ar_coeffs_cb_plus_128[i], 1, i);
1280 if (current->chroma_scaling_from_luma || current->num_cr_points) {
1281 for (i = 0; i < num_pos_chroma; i++)
1282 fbs(8, ar_coeffs_cr_plus_128[i], 1, i);
1284 fb(2, ar_coeff_shift_minus_6);
1285 fb(2, grain_scale_shift);
1286 if (current->num_cb_points) {
1288 fb(8, cb_luma_mult);
1291 if (current->num_cr_points) {
1293 fb(8, cr_luma_mult);
1298 flag(clip_to_restricted_range);
1308 int id_len, diff_len, all_frames, frame_is_intra, order_hint_bits;
1313 "unable to decode frame header.\n");
1323 infer(show_existing_frame, 0);
1326 infer(showable_frame, 0);
1330 flag(show_existing_frame);
1332 if (current->show_existing_frame) {
1335 fb(3, frame_to_show_map_idx);
1336 ref = &priv->
ref[current->frame_to_show_map_idx];
1340 "show_existing_frame (frame_to_show_map_idx = %d).\n",
1341 current->frame_to_show_map_idx);
1348 frame_presentation_time);
1352 fb(id_len, display_frame_id);
1356 infer(refresh_frame_flags, all_frames);
1368 infer(refresh_frame_flags, 0);
1384 if (current->show_frame &&
1388 frame_presentation_time);
1390 if (current->show_frame)
1393 flag(showable_frame);
1396 (current->frame_type ==
AV1_FRAME_KEY && current->show_frame))
1397 infer(error_resilient_mode, 1);
1399 flag(error_resilient_mode);
1402 if (current->frame_type ==
AV1_FRAME_KEY && current->show_frame) {
1409 flag(disable_cdf_update);
1413 flag(allow_screen_content_tools);
1415 infer(allow_screen_content_tools,
1418 if (current->allow_screen_content_tools) {
1420 flag(force_integer_mv);
1424 infer(force_integer_mv, 0);
1428 fb(id_len, current_frame_id);
1432 if (current->current_frame_id > (1 << diff_len)) {
1433 if (priv->
ref[i].
frame_id > current->current_frame_id ||
1434 priv->
ref[i].
frame_id < (current->current_frame_id -
1438 if (priv->
ref[i].
frame_id > current->current_frame_id &&
1440 current->current_frame_id -
1446 infer(current_frame_id, 0);
1450 infer(frame_size_override_flag, 1);
1452 infer(frame_size_override_flag, 0);
1454 flag(frame_size_override_flag);
1458 if (order_hint_bits > 0)
1459 fb(order_hint_bits, order_hint);
1461 infer(order_hint, 0);
1464 if (frame_is_intra || current->error_resilient_mode)
1467 fb(3, primary_ref_frame);
1470 flag(buffer_removal_time_present_flag);
1471 if (current->buffer_removal_time_present_flag) {
1475 int in_temporal_layer = (op_pt_idc >> priv->
temporal_id ) & 1;
1476 int in_spatial_layer = (op_pt_idc >> (priv->
spatial_id + 8)) & 1;
1478 (in_temporal_layer && in_spatial_layer)) {
1480 buffer_removal_time[i], 1, i);
1488 (current->frame_type ==
AV1_FRAME_KEY && current->show_frame))
1489 infer(refresh_frame_flags, all_frames);
1491 fb(8, refresh_frame_flags);
1493 if (!frame_is_intra || current->refresh_frame_flags != all_frames) {
1496 if (current->error_resilient_mode)
1497 fbs(order_hint_bits, ref_order_hint[i], 1, i);
1511 if (current->allow_screen_content_tools &&
1513 flag(allow_intrabc);
1515 infer(allow_intrabc, 0);
1519 infer(frame_refs_short_signaling, 0);
1521 flag(frame_refs_short_signaling);
1522 if (current->frame_refs_short_signaling) {
1523 fb(3, last_frame_idx);
1524 fb(3, golden_frame_idx);
1530 if (!current->frame_refs_short_signaling)
1531 fbs(3, ref_frame_idx[i], 1, i);
1534 delta_frame_id_minus1[i], 1, i);
1538 if (current->frame_size_override_flag &&
1539 !current->error_resilient_mode) {
1546 if (current->force_integer_mv)
1547 infer(allow_high_precision_mv, 0);
1549 flag(allow_high_precision_mv);
1553 flag(is_motion_mode_switchable);
1555 if (current->error_resilient_mode ||
1557 infer(use_ref_frame_mvs, 0);
1559 flag(use_ref_frame_mvs);
1561 infer(allow_intrabc, 0);
1564 if (!frame_is_intra) {
1569 infer(disable_frame_end_update_cdf, 1);
1571 flag(disable_frame_end_update_cdf);
1581 if (current->use_ref_frame_mvs) {
1601 qindex = (current->base_q_idx +
1604 qindex = current->base_q_idx;
1608 if (qindex || current->delta_q_y_dc ||
1609 current->delta_q_u_ac || current->delta_q_u_dc ||
1610 current->delta_q_v_ac || current->delta_q_v_dc) {
1629 if (frame_is_intra || current->error_resilient_mode ||
1631 infer(allow_warped_motion, 0);
1633 flag(allow_warped_motion);
1635 flag(reduced_tx_set);
1642 "upscaled %d render %dx%d subsample %dx%d " 1643 "bitdepth %d tiles %dx%d.\n", priv->
order_hint,
1652 if (current->refresh_frame_flags & (1 << i)) {
1655 .frame_id = current->current_frame_id,
1661 .frame_type = current->frame_type,
1668 sizeof(current->loop_filter_ref_deltas));
1670 sizeof(current->loop_filter_mode_deltas));
1672 sizeof(current->feature_enabled));
1674 sizeof(current->feature_value));
1686 int start_pos, fh_bits, fh_bytes, err;
1692 "frame header OBU.\n");
1699 HEADER(
"Redundant Frame Header");
1708 xf(b, frame_header_copy[i],
1709 val, val, val, 1, i / 8);
1714 HEADER(
"Redundant Frame Header (used as Frame Header)");
1728 if (current->show_existing_frame) {
1737 fh_start = (
uint8_t*)rw->buffer + start_pos / 8;
1747 fh_start = rw->buf + start_pos / 8;
1749 fh_bytes = (fh_bits + 7) / 8;
1753 if (rw_buffer_ref) {
1776 int num_tiles, tile_bits;
1783 flag(tile_start_and_end_present_flag);
1785 infer(tile_start_and_end_present_flag, 0);
1787 if (num_tiles == 1 || !current->tile_start_and_end_present_flag) {
1789 infer(tg_end, num_tiles - 1);
1793 fc(tile_bits, tg_start, priv->
tile_num, num_tiles - 1);
1794 fc(tile_bits, tg_end, current->tg_start, num_tiles - 1);
1797 priv->
tile_num = current->tg_end + 1;
1802 if (current->tg_end == num_tiles - 1)
1831 fb(8, output_frame_width_in_tiles_minus_1);
1832 fb(8, output_frame_height_in_tiles_minus_1);
1834 fb(16, tile_count_minus_1);
1857 for (i = 0; i < 3; i++) {
1858 fbs(16, primary_chromaticity_x[i], 1, i);
1859 fbs(16, primary_chromaticity_y[i], 1, i);
1862 fb(16, white_point_chromaticity_x);
1863 fb(16, white_point_chromaticity_y);
1868 fc(32, luminance_min, 0,
FFMIN(((uint64_t)current->luminance_max << 6) - 1,
1883 "unable to parse scalability metadata.\n");
1888 fb(2, spatial_layers_cnt_minus_1);
1889 flag(spatial_layer_dimensions_present_flag);
1890 flag(spatial_layer_description_present_flag);
1891 flag(temporal_group_description_present_flag);
1892 fc(3, scalability_structure_reserved_3bits, 0, 0);
1893 if (current->spatial_layer_dimensions_present_flag) {
1894 for (i = 0; i <= current->spatial_layers_cnt_minus_1; i++) {
1895 fcs(16, spatial_layer_max_width[i],
1897 fcs(16, spatial_layer_max_height[i],
1901 if (current->spatial_layer_description_present_flag) {
1902 for (i = 0; i <= current->spatial_layers_cnt_minus_1; i++)
1903 fbs(8, spatial_layer_ref_id[i], 1, i);
1905 if (current->temporal_group_description_present_flag) {
1906 fb(8, temporal_group_size);
1907 for (i = 0; i < current->temporal_group_size; i++) {
1908 fbs(3, temporal_group_temporal_id[i], 1, i);
1909 flags(temporal_group_temporal_switching_up_point_flag[i], 1, i);
1910 flags(temporal_group_spatial_switching_up_point_flag[i], 1, i);
1911 fbs(3, temporal_group_ref_cnt[i], 1, i);
1912 for (j = 0; j < current->temporal_group_ref_cnt[
i]; j++) {
1913 fbs(8, temporal_group_ref_pic_diff[i][j], 2, i, j);
1926 fb(8, scalability_mode_idc);
1940 fb(8, itu_t_t35_country_code);
1941 if (current->itu_t_t35_country_code == 0xff)
1942 fb(8, itu_t_t35_country_code_extension_byte);
1950 if (!current->payload_ref)
1952 current->payload = current->payload_ref->data;
1955 for (i = 0; i < current->payload_size; i++)
1956 xf(8, itu_t_t35_payload_bytes[i], current->payload[i],
1967 fb(5, counting_type);
1968 flag(full_timestamp_flag);
1969 flag(discontinuity_flag);
1970 flag(cnt_dropped_flag);
1973 if (current->full_timestamp_flag) {
1974 fc(6, seconds_value, 0, 59);
1975 fc(6, minutes_value, 0, 59);
1976 fc(5, hours_value, 0, 23);
1979 if (current->seconds_flag) {
1980 fc(6, seconds_value, 0, 59);
1982 if (current->minutes_flag) {
1983 fc(6, minutes_value, 0, 59);
1985 if (current->hours_flag)
1986 fc(5, hours_value, 0, 23);
1991 fb(5, time_offset_length);
1992 if (current->time_offset_length > 0)
1993 fb(current->time_offset_length, time_offset_value);
1995 infer(time_offset_length, 0);
2007 switch (current->metadata_type) {
2044 if (!current->payload_ref)
2046 current->payload = current->payload_ref->data;
2049 for (i = 0; i < current->payload_size; i++)
2050 xf(8, obu_padding_byte[i], current->payload[i], 0x00, 0xff, 1, i);
static int FUNC() tile_group_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileGroup *current)
static int FUNC() trailing_bits(CodedBitstreamContext *ctx, RWContext *rw, int nb_bits)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
int8_t loop_filter_ref_deltas[AV1_TOTAL_REFS_PER_FRAME]
#define fixed(width, name, value)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int FUNC() tile_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() tile_list_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTileList *current)
static int FUNC() interpolation_filter(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
static int FUNC() uncompressed_header(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() decoder_model_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawDecoderModelInfo *current)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static int FUNC() loop_filter_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define MAX_UINT_BITS(length)
static int FUNC() delta_lf_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define subexp(name, max, subs,...)
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)
static int FUNC() render_size(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
uint8_t frame_presentation_time_length_minus_1
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)
static int FUNC() frame_header(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawFrameHeader *current)
static int FUNC() metadata_itut_t35(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataITUTT35 *current)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVDictionary * metadata
Metadata that applies to the whole file.
static int FUNC() frame_reference_mode(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define fcs(width, name, range_min, range_max, subs,...)
uint8_t separate_uv_delta_q
AVBufferRef * frame_header_ref
static int FUNC() obu_header(CodedBitstreamContext *ctx, RWContext *rw, AV1RawOBUHeader *current)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
static int FUNC() global_motion_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() skip_mode_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() metadata_scalability(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataScalability *current)
static int put_bits_count(PutBitContext *s)
static int cbs_av1_tile_log2(int blksize, int target)
static int FUNC() color_config(CodedBitstreamContext *ctx, RWContext *rw, AV1RawColorConfig *current, int seq_profile)
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
static int FUNC() metadata_hdr_cll(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataHDRCLL *current)
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
uint8_t feature_enabled[AV1_MAX_SEGMENTS][AV1_SEG_LVL_MAX]
static const struct ColorPrimaries color_primaries[AVCOL_PRI_NB]
#define increment(name, min, max)
static int FUNC() frame_size_with_refs(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
static int FUNC() sequence_header_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawSequenceHeader *current)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define fbs(width, name, subs,...)
static int FUNC() frame_size(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
uint8_t * data
The data buffer.
static size_t cbs_av1_get_payload_bytes_left(GetBitContext *gbc)
static int FUNC() metadata_hdr_mdcv(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadataHDRMDCV *current)
#define uvlc(name, range_min, range_max)
#define FF_PROFILE_AV1_PROFESSIONAL
Context structure for coded bitstream operations.
static int FUNC() global_motion_param(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current, int type, int ref, int idx)
AV1ReferenceFrameState ref[AV1_NUM_REF_FRAMES]
static int FUNC() temporal_delimiter_obu(CodedBitstreamContext *ctx, RWContext *rw)
static int FUNC() delta_q_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define FF_PROFILE_AV1_MAIN
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
int8_t loop_filter_mode_deltas[2]
static void update_refs(VP8Context *s)
static int FUNC() set_frame_refs(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
AV1RawSequenceHeader * sequence_header
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
#define flags(name, subs,...)
static int FUNC() metadata_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawMetadata *current)
static int FUNC() timing_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTimingInfo *current)
int16_t feature_value[AV1_MAX_SEGMENTS][AV1_SEG_LVL_MAX]
#define ns(max_value, name, subs,...)
A reference to a data buffer.
IEC 61966-2-1 (sRGB or sYCC)
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.
static int ref[MAX_W *MAX_W]
uint8_t buffer_removal_time_length_minus_1
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static int FUNC() segmentation_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define xf(width, name, var, range_min, range_max, subs,...)
void * priv_data
Format private data.
static int FUNC() quantization_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFrameHeader *current)
#define sus(width, name, subs,...)
static int FUNC() film_grain_params(CodedBitstreamContext *ctx, RWContext *rw, AV1RawFilmGrainParams *current, AV1RawFrameHeader *frame_header)
static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)
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)
static double val(void *priv, double ch)
static int FUNC() padding_obu(CodedBitstreamContext *ctx, RWContext *rw, AV1RawPadding *current)
#define FF_PROFILE_AV1_HIGH