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);
50 fixed(1, trailing_one_bit, 1);
54 fixed(1, trailing_zero_bit, 0);
66 fixed(1, zero_bit, 0);
80 current->high_bitdepth) {
82 priv->
bit_depth = current->twelve_bit ? 12 : 10;
84 priv->
bit_depth = current->high_bitdepth ? 10 : 8;
88 infer(mono_chrome, 0);
91 priv->
num_planes = current->mono_chrome ? 1 : 3;
93 flag(color_description_present_flag);
94 if (current->color_description_present_flag) {
97 fb(8, matrix_coefficients);
104 if (current->mono_chrome) {
107 infer(subsampling_x, 1);
108 infer(subsampling_y, 1);
110 infer(separate_uv_delta_q, 0);
116 infer(subsampling_x, 0);
117 infer(subsampling_y, 0);
118 flag(separate_uv_delta_q);
124 infer(subsampling_x, 1);
125 infer(subsampling_y, 1);
127 infer(subsampling_x, 0);
128 infer(subsampling_y, 0);
131 fb(1, subsampling_x);
132 if (current->subsampling_x)
133 fb(1, subsampling_y);
135 infer(subsampling_y, 0);
137 infer(subsampling_x, 1);
138 infer(subsampling_y, 0);
141 if (current->subsampling_x && current->subsampling_y) {
146 flag(separate_uv_delta_q);
160 flag(equal_picture_interval);
161 if (current->equal_picture_interval)
172 fb(5, buffer_delay_length_minus_1);
173 fb(32, num_units_in_decoding_tick);
174 fb(5, buffer_removal_time_length_minus_1);
175 fb(5, frame_presentation_time_length_minus_1);
185 HEADER(
"Sequence Header");
190 flag(reduced_still_picture_header);
192 if (current->reduced_still_picture_header) {
193 infer(timing_info_present_flag, 0);
194 infer(decoder_model_info_present_flag, 0);
195 infer(initial_display_delay_present_flag, 0);
196 infer(operating_points_cnt_minus_1, 0);
197 infer(operating_point_idc[0], 0);
199 fb(5, seq_level_idx[0]);
201 infer(seq_tier[0], 0);
202 infer(decoder_model_present_for_this_op[0], 0);
203 infer(initial_display_delay_present_for_this_op[0], 0);
206 flag(timing_info_present_flag);
207 if (current->timing_info_present_flag) {
210 flag(decoder_model_info_present_flag);
211 if (current->decoder_model_info_present_flag) {
213 (
ctx, rw, ¤t->decoder_model_info));
216 infer(decoder_model_info_present_flag, 0);
219 flag(initial_display_delay_present_flag);
221 fb(5, operating_points_cnt_minus_1);
222 for (
i = 0;
i <= current->operating_points_cnt_minus_1;
i++) {
223 fbs(12, operating_point_idc[
i], 1,
i);
224 fbs(5, seq_level_idx[
i], 1,
i);
226 if (current->seq_level_idx[
i] > 7)
231 if (current->decoder_model_info_present_flag) {
232 flags(decoder_model_present_for_this_op[
i], 1,
i);
233 if (current->decoder_model_present_for_this_op[
i]) {
234 int n = current->decoder_model_info.buffer_delay_length_minus_1 + 1;
235 fbs(
n, decoder_buffer_delay[
i], 1,
i);
236 fbs(
n, encoder_buffer_delay[
i], 1,
i);
237 flags(low_delay_mode_flag[
i], 1,
i);
240 infer(decoder_model_present_for_this_op[
i], 0);
243 if (current->initial_display_delay_present_flag) {
244 flags(initial_display_delay_present_for_this_op[
i], 1,
i);
245 if (current->initial_display_delay_present_for_this_op[
i])
246 fbs(4, initial_display_delay_minus_1[
i], 1,
i);
251 fb(4, frame_width_bits_minus_1);
252 fb(4, frame_height_bits_minus_1);
254 fb(current->frame_width_bits_minus_1 + 1, max_frame_width_minus_1);
255 fb(current->frame_height_bits_minus_1 + 1, max_frame_height_minus_1);
257 if (current->reduced_still_picture_header)
258 infer(frame_id_numbers_present_flag, 0);
260 flag(frame_id_numbers_present_flag);
261 if (current->frame_id_numbers_present_flag) {
262 fb(4, delta_frame_id_length_minus_2);
263 fb(3, additional_frame_id_length_minus_1);
266 flag(use_128x128_superblock);
267 flag(enable_filter_intra);
268 flag(enable_intra_edge_filter);
270 if (current->reduced_still_picture_header) {
271 infer(enable_intraintra_compound, 0);
272 infer(enable_masked_compound, 0);
273 infer(enable_warped_motion, 0);
274 infer(enable_dual_filter, 0);
275 infer(enable_order_hint, 0);
276 infer(enable_jnt_comp, 0);
277 infer(enable_ref_frame_mvs, 0);
279 infer(seq_force_screen_content_tools,
281 infer(seq_force_integer_mv,
284 flag(enable_intraintra_compound);
285 flag(enable_masked_compound);
286 flag(enable_warped_motion);
287 flag(enable_dual_filter);
289 flag(enable_order_hint);
290 if (current->enable_order_hint) {
291 flag(enable_jnt_comp);
292 flag(enable_ref_frame_mvs);
294 infer(enable_jnt_comp, 0);
295 infer(enable_ref_frame_mvs, 0);
298 flag(seq_choose_screen_content_tools);
299 if (current->seq_choose_screen_content_tools)
300 infer(seq_force_screen_content_tools,
303 fb(1, seq_force_screen_content_tools);
304 if (current->seq_force_screen_content_tools > 0) {
305 flag(seq_choose_integer_mv);
306 if (current->seq_choose_integer_mv)
307 infer(seq_force_integer_mv,
310 fb(1, seq_force_integer_mv);
315 if (current->enable_order_hint)
316 fb(3, order_hint_bits_minus_1);
319 flag(enable_superres);
321 flag(enable_restoration);
324 current->seq_profile));
326 flag(film_grain_params_present);
335 HEADER(
"Temporal Delimiter");
352 infer(use_superres, 0);
354 if (current->use_superres) {
375 if (current->frame_size_override_flag) {
379 priv->
frame_width = current->frame_width_minus_1 + 1;
397 flag(render_and_frame_size_different);
399 if (current->render_and_frame_size_different) {
400 fb(16, render_width_minus_1);
401 fb(16, render_height_minus_1);
421 if (current->found_ref[
i]) {
424 if (current->ref_frame_idx[
i] < 0 ||
425 !priv->
ref[current->ref_frame_idx[
i]].
valid) {
427 "Missing reference frame needed for frame size "
428 "(ref = %d, ref_frame_idx = %d).\n",
429 i, current->ref_frame_idx[
i]);
432 ref = &priv->
ref[current->ref_frame_idx[
i]];
458 flag(is_filter_switchable);
459 if (current->is_filter_switchable)
473 int mi_cols, mi_rows, sb_cols, sb_rows, sb_shift, sb_size;
474 int max_tile_width_sb, max_tile_height_sb, max_tile_area_sb;
475 int min_log2_tile_cols, max_log2_tile_cols, max_log2_tile_rows;
476 int min_log2_tiles, min_log2_tile_rows;
483 : ((mi_cols + 15) >> 4);
485 : ((mi_rows + 15) >> 4);
488 sb_size = sb_shift + 2;
496 min_log2_tiles =
FFMAX(min_log2_tile_cols,
499 flag(uniform_tile_spacing_flag);
501 if (current->uniform_tile_spacing_flag) {
502 int tile_width_sb, tile_height_sb;
504 increment(tile_cols_log2, min_log2_tile_cols, max_log2_tile_cols);
506 tile_width_sb = (sb_cols + (1 << current->tile_cols_log2) - 1) >>
507 current->tile_cols_log2;
508 current->tile_cols = (sb_cols + tile_width_sb - 1) / tile_width_sb;
510 min_log2_tile_rows =
FFMAX(min_log2_tiles - current->tile_cols_log2, 0);
512 increment(tile_rows_log2, min_log2_tile_rows, max_log2_tile_rows);
514 tile_height_sb = (sb_rows + (1 << current->tile_rows_log2) - 1) >>
515 current->tile_rows_log2;
516 current->tile_rows = (sb_rows + tile_height_sb - 1) / tile_height_sb;
519 int widest_tile_sb, start_sb, size_sb, max_width, max_height;
525 max_width =
FFMIN(sb_cols - start_sb, max_tile_width_sb);
526 ns(max_width, width_in_sbs_minus_1[
i], 1,
i);
527 size_sb = current->width_in_sbs_minus_1[
i] + 1;
528 widest_tile_sb =
FFMAX(size_sb, widest_tile_sb);
532 current->tile_cols =
i;
534 if (min_log2_tiles > 0)
535 max_tile_area_sb = (sb_rows * sb_cols) >> (min_log2_tiles + 1);
537 max_tile_area_sb = sb_rows * sb_cols;
538 max_tile_height_sb =
FFMAX(max_tile_area_sb / widest_tile_sb, 1);
542 max_height =
FFMIN(sb_rows - start_sb, max_tile_height_sb);
543 ns(max_height, height_in_sbs_minus_1[
i], 1,
i);
544 size_sb = current->height_in_sbs_minus_1[
i] + 1;
548 current->tile_rows =
i;
551 if (current->tile_cols_log2 > 0 ||
552 current->tile_rows_log2 > 0) {
553 fb(current->tile_cols_log2 + current->tile_rows_log2,
554 context_update_tile_id);
555 fb(2, tile_size_bytes_minus1);
557 infer(context_update_tile_id, 0);
581 infer(diff_uv_delta, 0);
586 if (current->diff_uv_delta) {
590 infer(delta_q_v_dc, current->delta_q_u_dc);
591 infer(delta_q_v_ac, current->delta_q_u_ac);
594 infer(delta_q_u_dc, 0);
595 infer(delta_q_u_ac, 0);
596 infer(delta_q_v_dc, 0);
597 infer(delta_q_v_ac, 0);
601 if (current->using_qmatrix) {
607 infer(qm_v, current->qm_u);
620 flag(segmentation_enabled);
622 if (current->segmentation_enabled) {
624 infer(segmentation_update_map, 1);
625 infer(segmentation_temporal_update, 0);
626 infer(segmentation_update_data, 1);
628 flag(segmentation_update_map);
629 if (current->segmentation_update_map)
630 flag(segmentation_temporal_update);
632 infer(segmentation_temporal_update, 0);
633 flag(segmentation_update_data);
636 if (current->segmentation_update_data) {
639 flags(feature_enabled[
i][j], 2,
i, j);
641 if (current->feature_enabled[
i][j] &&
bits[j] > 0) {
643 sus(1 +
bits[j], feature_value[
i][j], 2,
i, j);
645 fbs(
bits[j], feature_value[
i][j], 2,
i, j);
647 infer(feature_value[
i][j], 0);
655 infer(feature_enabled[
i][j], 0);
656 infer(feature_value[
i][j], 0);
669 if (current->base_q_idx > 0)
670 flag(delta_q_present);
672 infer(delta_q_present, 0);
674 if (current->delta_q_present)
685 if (current->delta_q_present) {
686 if (!current->allow_intrabc)
687 flag(delta_lf_present);
689 infer(delta_lf_present, 0);
690 if (current->delta_lf_present) {
692 flag(delta_lf_multi);
694 infer(delta_lf_res, 0);
695 infer(delta_lf_multi, 0);
698 infer(delta_lf_present, 0);
699 infer(delta_lf_res, 0);
700 infer(delta_lf_multi, 0);
713 infer(loop_filter_level[0], 0);
714 infer(loop_filter_level[1], 0);
723 for (
i = 0;
i < 2;
i++)
724 infer(loop_filter_mode_deltas[
i], 0);
728 fb(6, loop_filter_level[0]);
729 fb(6, loop_filter_level[1]);
732 if (current->loop_filter_level[0] ||
733 current->loop_filter_level[1]) {
734 fb(6, loop_filter_level[2]);
735 fb(6, loop_filter_level[3]);
739 fb(3, loop_filter_sharpness);
741 flag(loop_filter_delta_enabled);
742 if (current->loop_filter_delta_enabled) {
743 flag(loop_filter_delta_update);
744 if (current->loop_filter_delta_update) {
746 flags(update_ref_delta[
i], 1,
i);
747 if (current->update_ref_delta[
i])
748 sus(1 + 6, loop_filter_ref_deltas[
i], 1,
i);
750 for (
i = 0;
i < 2;
i++) {
751 flags(update_mode_delta[
i], 1,
i);
752 if (current->update_mode_delta[
i])
753 sus(1 + 6, loop_filter_mode_deltas[
i], 1,
i);
770 infer(cdef_damping_minus_3, 0);
772 infer(cdef_y_pri_strength[0], 0);
773 infer(cdef_y_sec_strength[0], 0);
774 infer(cdef_uv_pri_strength[0], 0);
775 infer(cdef_uv_sec_strength[0], 0);
780 fb(2, cdef_damping_minus_3);
783 for (
i = 0;
i < (1 << current->cdef_bits);
i++) {
784 fbs(4, cdef_y_pri_strength[
i], 1,
i);
785 fbs(2, cdef_y_sec_strength[
i], 1,
i);
788 fbs(4, cdef_uv_pri_strength[
i], 1,
i);
789 fbs(2, cdef_uv_sec_strength[
i], 1,
i);
801 int uses_lr, uses_chroma_lr;
809 uses_lr = uses_chroma_lr = 0;
811 fbs(2, lr_type[
i], 1,
i);
813 if (current->lr_type[
i] != 0) {
830 infer(lr_uv_shift, 0);
858 infer(reference_select, 0);
860 flag(reference_select);
870 int skip_mode_allowed;
876 skip_mode_allowed = 0;
878 int forward_idx, backward_idx;
879 int forward_hint, backward_hint;
880 int ref_hint, dist,
i;
887 current->order_hint);
889 if (forward_idx < 0 ||
893 forward_hint = ref_hint;
895 }
else if (dist > 0) {
896 if (backward_idx < 0 ||
898 backward_hint) < 0) {
900 backward_hint = ref_hint;
905 if (forward_idx < 0) {
906 skip_mode_allowed = 0;
907 }
else if (backward_idx >= 0) {
908 skip_mode_allowed = 1;
911 int second_forward_idx;
912 int second_forward_hint;
914 second_forward_idx = -1;
919 if (second_forward_idx < 0 ||
921 second_forward_hint) > 0) {
922 second_forward_idx =
i;
923 second_forward_hint = ref_hint;
928 if (second_forward_idx < 0) {
929 skip_mode_allowed = 0;
931 skip_mode_allowed = 1;
937 if (skip_mode_allowed)
938 flag(skip_mode_present);
940 infer(skip_mode_present, 0);
949 uint32_t abs_bits, prec_bits, num_syms;
965 num_syms = 2 * (1 << abs_bits) + 1;
986 if (current->is_global[
ref]) {
988 if (current->is_rot_zoom[
ref]) {
1024 int num_pos_luma, num_pos_chroma;
1028 (!current->show_frame && !current->showable_frame))
1033 if (!current->apply_grain)
1041 infer(update_grain, 1);
1043 if (!current->update_grain) {
1044 fb(3, film_grain_params_ref_idx);
1048 fc(4, num_y_points, 0, 14);
1049 for (
i = 0;
i < current->num_y_points;
i++) {
1050 fbs(8, point_y_value[
i], 1,
i);
1051 fbs(8, point_y_scaling[
i], 1,
i);
1055 infer(chroma_scaling_from_luma, 0);
1057 flag(chroma_scaling_from_luma);
1060 current->chroma_scaling_from_luma ||
1063 current->num_y_points == 0)) {
1064 infer(num_cb_points, 0);
1065 infer(num_cr_points, 0);
1067 fb(4, num_cb_points);
1068 for (
i = 0;
i < current->num_cb_points;
i++) {
1069 fbs(8, point_cb_value[
i], 1,
i);
1070 fbs(8, point_cb_scaling[
i], 1,
i);
1072 fb(4, num_cr_points);
1073 for (
i = 0;
i < current->num_cr_points;
i++) {
1074 fbs(8, point_cr_value[
i], 1,
i);
1075 fbs(8, point_cr_scaling[
i], 1,
i);
1079 fb(2, grain_scaling_minus_8);
1080 fb(2, ar_coeff_lag);
1081 num_pos_luma = 2 * current->ar_coeff_lag * (current->ar_coeff_lag + 1);
1082 if (current->num_y_points) {
1083 num_pos_chroma = num_pos_luma + 1;
1084 for (
i = 0;
i < num_pos_luma;
i++)
1085 fbs(8, ar_coeffs_y_plus_128[
i], 1,
i);
1087 num_pos_chroma = num_pos_luma;
1089 if (current->chroma_scaling_from_luma || current->num_cb_points) {
1090 for (
i = 0;
i < num_pos_chroma;
i++)
1091 fbs(8, ar_coeffs_cb_plus_128[
i], 1,
i);
1093 if (current->chroma_scaling_from_luma || current->num_cr_points) {
1094 for (
i = 0;
i < num_pos_chroma;
i++)
1095 fbs(8, ar_coeffs_cr_plus_128[
i], 1,
i);
1097 fb(2, ar_coeff_shift_minus_6);
1098 fb(2, grain_scale_shift);
1099 if (current->num_cb_points) {
1101 fb(8, cb_luma_mult);
1104 if (current->num_cr_points) {
1106 fb(8, cr_luma_mult);
1111 flag(clip_to_restricted_range);
1121 int id_len, diff_len, all_frames, frame_is_intra, order_hint_bits;
1126 "unable to decode frame header.\n");
1136 infer(show_existing_frame, 0);
1139 infer(showable_frame, 0);
1143 flag(show_existing_frame);
1145 if (current->show_existing_frame) {
1148 fb(3, frame_to_show_map_idx);
1149 frame = &priv->
ref[current->frame_to_show_map_idx];
1154 frame_presentation_time);
1158 fb(id_len, display_frame_id);
1161 infer(refresh_frame_flags, all_frames);
1163 infer(refresh_frame_flags, 0);
1173 if (current->show_frame &&
1177 frame_presentation_time);
1179 if (current->show_frame)
1182 flag(showable_frame);
1185 (current->frame_type ==
AV1_FRAME_KEY && current->show_frame))
1186 infer(error_resilient_mode, 1);
1188 flag(error_resilient_mode);
1191 if (current->frame_type ==
AV1_FRAME_KEY && current->show_frame) {
1198 flag(disable_cdf_update);
1202 flag(allow_screen_content_tools);
1204 infer(allow_screen_content_tools,
1207 if (current->allow_screen_content_tools) {
1209 flag(force_integer_mv);
1213 infer(force_integer_mv, 0);
1217 fb(id_len, current_frame_id);
1221 if (current->current_frame_id > (1 << diff_len)) {
1222 if (priv->
ref[
i].
frame_id > current->current_frame_id ||
1227 if (priv->
ref[
i].
frame_id > current->current_frame_id &&
1229 current->current_frame_id -
1235 infer(current_frame_id, 0);
1239 infer(frame_size_override_flag, 1);
1241 infer(frame_size_override_flag, 0);
1243 flag(frame_size_override_flag);
1247 if (order_hint_bits > 0)
1248 fb(order_hint_bits, order_hint);
1250 infer(order_hint, 0);
1252 if (frame_is_intra || current->error_resilient_mode)
1255 fb(3, primary_ref_frame);
1258 flag(buffer_removal_time_present_flag);
1259 if (current->buffer_removal_time_present_flag) {
1263 int in_temporal_layer = (op_pt_idc >> priv->
temporal_id ) & 1;
1264 int in_spatial_layer = (op_pt_idc >> (priv->
spatial_id + 8)) & 1;
1266 in_temporal_layer || in_spatial_layer) {
1268 buffer_removal_time[
i], 1,
i);
1276 (current->frame_type ==
AV1_FRAME_KEY && current->show_frame))
1277 infer(refresh_frame_flags, all_frames);
1279 fb(8, refresh_frame_flags);
1281 if (!frame_is_intra || current->refresh_frame_flags != all_frames) {
1284 fbs(order_hint_bits, ref_order_hint[
i], 1,
i);
1296 if (current->allow_screen_content_tools &&
1298 flag(allow_intrabc);
1300 infer(allow_intrabc, 0);
1304 infer(frame_refs_short_signaling, 0);
1306 flag(frame_refs_short_signaling);
1307 if (current->frame_refs_short_signaling) {
1308 fb(3, last_frame_idx);
1309 fb(3, golden_frame_idx);
1313 infer(ref_frame_idx[
i], current->last_frame_idx);
1316 infer(ref_frame_idx[
i], current->golden_frame_idx);
1318 infer(ref_frame_idx[
i], -1);
1324 if (!current->frame_refs_short_signaling)
1325 fbs(3, ref_frame_idx[
i], 1,
i);
1328 delta_frame_id_minus1[
i], 1,
i);
1332 if (current->frame_size_override_flag &&
1333 !current->error_resilient_mode) {
1340 if (current->force_integer_mv)
1341 infer(allow_high_precision_mv, 0);
1343 flag(allow_high_precision_mv);
1347 flag(is_motion_mode_switchable);
1349 if (current->error_resilient_mode ||
1351 infer(use_ref_frame_mvs, 0);
1353 flag(use_ref_frame_mvs);
1355 infer(allow_intrabc, 0);
1358 if (!frame_is_intra) {
1363 infer(disable_frame_end_update_cdf, 1);
1365 flag(disable_frame_end_update_cdf);
1375 if (current->use_ref_frame_mvs) {
1395 qindex = (current->base_q_idx +
1398 qindex = current->base_q_idx;
1400 qindex = av_clip_uintp2(qindex, 8);
1402 if (qindex || current->delta_q_y_dc ||
1403 current->delta_q_u_ac || current->delta_q_u_dc ||
1404 current->delta_q_v_ac || current->delta_q_v_dc) {
1423 if (frame_is_intra || current->error_resilient_mode ||
1425 infer(allow_warped_motion, 0);
1427 flag(allow_warped_motion);
1429 flag(reduced_tx_set);
1436 if (current->refresh_frame_flags & (1 <<
i)) {
1439 .frame_id = current->current_frame_id,
1445 .frame_type = current->frame_type,
1449 .order_hint = current->order_hint,
1455 "upscaled %d render %dx%d subsample %dx%d "
1456 "bitdepth %d tiles %dx%d.\n", current->order_hint,
1471 int start_pos, fh_bits, fh_bytes, err;
1477 "frame header OBU.\n");
1484 HEADER(
"Redundant Frame Header");
1493 xf(
b, frame_header_copy[
i],
1499 HEADER(
"Redundant Frame Header (used as Frame Header)");
1511 if (current->show_existing_frame) {
1520 fh_start = (
uint8_t*)rw->buffer + start_pos / 8;
1530 fh_start = rw->buf + start_pos / 8;
1532 fh_bytes = (fh_bits + 7) / 8;
1536 if (rw_buffer_ref) {
1559 int num_tiles, tile_bits;
1566 flag(tile_start_and_end_present_flag);
1568 infer(tile_start_and_end_present_flag, 0);
1570 if (num_tiles == 1 || !current->tile_start_and_end_present_flag) {
1572 infer(tg_end, num_tiles - 1);
1576 fb(tile_bits, tg_start);
1577 fb(tile_bits, tg_end);
1583 if (current->tg_end == num_tiles - 1)
1612 fb(8, output_frame_width_in_tiles_minus_1);
1613 fb(8, output_frame_height_in_tiles_minus_1);
1615 fb(16, tile_count_minus_1);
1638 for (
i = 0;
i < 3;
i++) {
1639 fbs(16, primary_chromaticity_x[
i], 1,
i);
1640 fbs(16, primary_chromaticity_y[
i], 1,
i);
1643 fb(16, white_point_chromaticity_x);
1644 fb(16, white_point_chromaticity_y);
1649 fc(32, luminance_min, 0,
FFMIN(((uint64_t)current->luminance_max << 6) - 1,
1664 "unable to parse scalability metadata.\n");
1669 fb(2, spatial_layers_cnt_minus_1);
1670 flag(spatial_layer_dimensions_present_flag);
1671 flag(spatial_layer_description_present_flag);
1672 flag(temporal_group_description_present_flag);
1673 fc(3, scalability_structure_reserved_3bits, 0, 0);
1674 if (current->spatial_layer_dimensions_present_flag) {
1675 for (
i = 0;
i <= current->spatial_layers_cnt_minus_1;
i++) {
1676 fcs(16, spatial_layer_max_width[
i],
1678 fcs(16, spatial_layer_max_height[
i],
1682 if (current->spatial_layer_description_present_flag) {
1683 for (
i = 0;
i <= current->spatial_layers_cnt_minus_1;
i++)
1684 fbs(8, spatial_layer_ref_id[
i], 1,
i);
1686 if (current->temporal_group_description_present_flag) {
1687 fb(8, temporal_group_size);
1688 for (
i = 0;
i < current->temporal_group_size;
i++) {
1689 fbs(3, temporal_group_temporal_id[
i], 1,
i);
1690 flags(temporal_group_temporal_switching_up_point_flag[
i], 1,
i);
1691 flags(temporal_group_spatial_switching_up_point_flag[
i], 1,
i);
1692 fbs(3, temporal_group_ref_cnt[
i], 1,
i);
1693 for (j = 0; j < current->temporal_group_ref_cnt[
i]; j++) {
1694 fbs(8, temporal_group_ref_pic_diff[
i][j], 2,
i, j);
1707 fb(8, scalability_mode_idc);
1721 fb(8, itu_t_t35_country_code);
1722 if (current->itu_t_t35_country_code == 0xff)
1723 fb(8, itu_t_t35_country_code_extension_byte);
1731 if (!current->payload_ref)
1733 current->payload = current->payload_ref->data;
1736 for (
i = 0;
i < current->payload_size;
i++)
1737 xf(8, itu_t_t35_payload_bytes[
i], current->payload[
i],
1748 fb(5, counting_type);
1749 flag(full_timestamp_flag);
1750 flag(discontinuity_flag);
1751 flag(cnt_dropped_flag);
1754 if (current->full_timestamp_flag) {
1755 fc(6, seconds_value, 0, 59);
1756 fc(6, minutes_value, 0, 59);
1757 fc(5, hours_value, 0, 23);
1760 if (current->seconds_flag) {
1761 fc(6, seconds_value, 0, 59);
1763 if (current->minutes_flag) {
1764 fc(6, minutes_value, 0, 59);
1766 if (current->hours_flag)
1767 fc(5, hours_value, 0, 23);
1772 fb(5, time_offset_length);
1773 if (current->time_offset_length > 0)
1774 fb(current->time_offset_length, time_offset_value);
1776 infer(time_offset_length, 0);
1788 switch (current->metadata_type) {
1825 if (!current->payload_ref)
1827 current->payload = current->payload_ref->data;
1830 for (
i = 0;
i < current->payload_size;
i++)
1831 xf(8, obu_padding_byte[
i], current->payload[
i], 0x00, 0xff, 1,
i);