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 {
21 int err;
22
23 fixed(1, rbsp_stop_one_bit, 1);
25 fixed(1, rbsp_alignment_zero_bit, 0);
26
27 return 0;
28 }
29
32 int expected_nal_unit_type)
33 {
34 int err;
35
36 fixed(1, forbidden_zero_bit, 0);
37
38 if (expected_nal_unit_type >= 0)
39 u(6, nal_unit_type, expected_nal_unit_type,
40 expected_nal_unit_type);
41 else
43
44 u(6, nuh_layer_id, 0, 62);
45 u(3, nuh_temporal_id_plus1, 1, 7);
46
47 return 0;
48 }
49
51 {
52 int err;
53
54 fixed(1, alignment_bit_equal_to_one, 1);
56 fixed(1, alignment_bit_equal_to_zero, 0);
57
58 return 0;
59 }
60
63 {
64 int err;
65 size_t k;
66 #ifdef READ
69 start = *rw;
72 current->bit_length = k;
73 if (k > 0) {
74 *rw = start;
75 allocate(current->data, (current->bit_length + 7) / 8);
76 for (k = 0; k < current->bit_length; k++) {
78 current->data[k / 8] |=
bit << (7 - k % 8);
79 }
80 }
81 #else
82 for (k = 0; k < current->bit_length; k++)
84 #endif
85 return 0;
86 }
87
90 int profile_present_flag,
91 int max_num_sub_layers_minus1)
92 {
94
95 if (profile_present_flag) {
96 u(2, general_profile_space, 0, 0);
97 flag(general_tier_flag);
98 ub(5, general_profile_idc);
99
100 for (j = 0; j < 32; j++)
101 flags(general_profile_compatibility_flag[j], 1, j);
102
103 flag(general_progressive_source_flag);
104 flag(general_interlaced_source_flag);
105 flag(general_non_packed_constraint_flag);
106 flag(general_frame_only_constraint_flag);
107
108 #define profile_compatible(x) (current->general_profile_idc == (x) || \
109 current->general_profile_compatibility_flag[x])
114 flag(general_max_12bit_constraint_flag);
115 flag(general_max_10bit_constraint_flag);
116 flag(general_max_8bit_constraint_flag);
117 flag(general_max_422chroma_constraint_flag);
118 flag(general_max_420chroma_constraint_flag);
119 flag(general_max_monochrome_constraint_flag);
120 flag(general_intra_constraint_flag);
121 flag(general_one_picture_only_constraint_flag);
122 flag(general_lower_bit_rate_constraint_flag);
123
126 flag(general_max_14bit_constraint_flag);
127 fixed(24, general_reserved_zero_33bits, 0);
128 fixed( 9, general_reserved_zero_33bits, 0);
129 } else {
130 fixed(24, general_reserved_zero_34bits, 0);
131 fixed(10, general_reserved_zero_34bits, 0);
132 }
134 fixed(7, general_reserved_zero_7bits, 0);
135 flag(general_one_picture_only_constraint_flag);
136 fixed(24, general_reserved_zero_35bits, 0);
137 fixed(11, general_reserved_zero_35bits, 0);
138 } else {
139 fixed(24, general_reserved_zero_43bits, 0);
140 fixed(19, general_reserved_zero_43bits, 0);
141 }
142
147 flag(general_inbld_flag);
148 } else {
149 fixed(1, general_reserved_zero_bit, 0);
150 }
151 #undef profile_compatible
152 }
153
154 ub(8, general_level_idc);
155
156 for (
i = 0;
i < max_num_sub_layers_minus1;
i++) {
157 flags(sub_layer_profile_present_flag[
i], 1,
i);
158 flags(sub_layer_level_present_flag[
i], 1,
i);
159 }
160
161 if (max_num_sub_layers_minus1 > 0) {
162 for (
i = max_num_sub_layers_minus1;
i < 8;
i++)
163 fixed(2, reserved_zero_2bits, 0);
164 }
165
166 for (
i = 0;
i < max_num_sub_layers_minus1;
i++) {
167 if (current->sub_layer_profile_present_flag[
i]) {
168 us(2, sub_layer_profile_space[
i], 0, 0, 1,
i);
169 flags(sub_layer_tier_flag[
i], 1,
i);
170 ubs(5, sub_layer_profile_idc[
i], 1,
i);
171
172 for (j = 0; j < 32; j++)
173 flags(sub_layer_profile_compatibility_flag[
i][j], 2,
i, j);
174
175 flags(sub_layer_progressive_source_flag[
i], 1,
i);
176 flags(sub_layer_interlaced_source_flag[
i], 1,
i);
177 flags(sub_layer_non_packed_constraint_flag[
i], 1,
i);
178 flags(sub_layer_frame_only_constraint_flag[
i], 1,
i);
179
180 #define profile_compatible(x) (current->sub_layer_profile_idc[i] == (x) || \
181 current->sub_layer_profile_compatibility_flag[i][x])
186 flags(sub_layer_max_12bit_constraint_flag[
i], 1,
i);
187 flags(sub_layer_max_10bit_constraint_flag[
i], 1,
i);
188 flags(sub_layer_max_8bit_constraint_flag[
i], 1,
i);
189 flags(sub_layer_max_422chroma_constraint_flag[
i], 1,
i);
190 flags(sub_layer_max_420chroma_constraint_flag[
i], 1,
i);
191 flags(sub_layer_max_monochrome_constraint_flag[
i], 1,
i);
192 flags(sub_layer_intra_constraint_flag[
i], 1,
i);
193 flags(sub_layer_one_picture_only_constraint_flag[
i], 1,
i);
194 flags(sub_layer_lower_bit_rate_constraint_flag[
i], 1,
i);
195
198 flags(sub_layer_max_14bit_constraint_flag[
i], 1,
i);
199 fixed(24, sub_layer_reserved_zero_33bits, 0);
200 fixed( 9, sub_layer_reserved_zero_33bits, 0);
201 } else {
202 fixed(24, sub_layer_reserved_zero_34bits, 0);
203 fixed(10, sub_layer_reserved_zero_34bits, 0);
204 }
206 fixed(7, sub_layer_reserved_zero_7bits, 0);
207 flags(sub_layer_one_picture_only_constraint_flag[
i], 1,
i);
208 fixed(24, sub_layer_reserved_zero_43bits, 0);
209 fixed(11, sub_layer_reserved_zero_43bits, 0);
210 } else {
211 fixed(24, sub_layer_reserved_zero_43bits, 0);
212 fixed(19, sub_layer_reserved_zero_43bits, 0);
213 }
214
219 flags(sub_layer_inbld_flag[
i], 1,
i);
220 } else {
221 fixed(1, sub_layer_reserved_zero_bit, 0);
222 }
223 #undef profile_compatible
224 }
225 if (current->sub_layer_level_present_flag[
i])
226 ubs(8, sub_layer_level_idc[
i], 1,
i);
227 }
228
229 return 0;
230 }
231
234 int nal, int sub_layer_id)
235 {
238
239 if (nal)
240 current = &hrd->nal_sub_layer_hrd_parameters[sub_layer_id];
241 else
242 current = &hrd->vcl_sub_layer_hrd_parameters[sub_layer_id];
243
244 for (
i = 0;
i <= hrd->cpb_cnt_minus1[sub_layer_id];
i++) {
245 ues(bit_rate_value_minus1[
i], 0, UINT32_MAX - 1, 1,
i);
246 ues(cpb_size_value_minus1[
i], 0, UINT32_MAX - 1, 1,
i);
247 if (hrd->sub_pic_hrd_params_present_flag) {
248 ues(cpb_size_du_value_minus1[
i], 0, UINT32_MAX - 1, 1,
i);
249 ues(bit_rate_du_value_minus1[
i], 0, UINT32_MAX - 1, 1,
i);
250 }
252 }
253
254 return 0;
255 }
256
259 int max_num_sub_layers_minus1)
260 {
262
263 if (common_inf_present_flag) {
264 flag(nal_hrd_parameters_present_flag);
265 flag(vcl_hrd_parameters_present_flag);
266
267 if (current->nal_hrd_parameters_present_flag ||
268 current->vcl_hrd_parameters_present_flag) {
269 flag(sub_pic_hrd_params_present_flag);
270 if (current->sub_pic_hrd_params_present_flag) {
271 ub(8, tick_divisor_minus2);
272 ub(5, du_cpb_removal_delay_increment_length_minus1);
273 flag(sub_pic_cpb_params_in_pic_timing_sei_flag);
274 ub(5, dpb_output_delay_du_length_minus1);
275 }
276
277 ub(4, bit_rate_scale);
278 ub(4, cpb_size_scale);
279 if (current->sub_pic_hrd_params_present_flag)
280 ub(4, cpb_size_du_scale);
281
282 ub(5, initial_cpb_removal_delay_length_minus1);
283 ub(5, au_cpb_removal_delay_length_minus1);
284 ub(5, dpb_output_delay_length_minus1);
285 } else {
286 infer(sub_pic_hrd_params_present_flag, 0);
287
288 infer(initial_cpb_removal_delay_length_minus1, 23);
289 infer(au_cpb_removal_delay_length_minus1, 23);
290 infer(dpb_output_delay_length_minus1, 23);
291 }
292 }
293
294 for (
i = 0;
i <= max_num_sub_layers_minus1;
i++) {
295 flags(fixed_pic_rate_general_flag[
i], 1,
i);
296
297 if (!current->fixed_pic_rate_general_flag[
i])
298 flags(fixed_pic_rate_within_cvs_flag[
i], 1,
i);
299 else
300 infer(fixed_pic_rate_within_cvs_flag[
i], 1);
301
302 if (current->fixed_pic_rate_within_cvs_flag[
i]) {
303 ues(elemental_duration_in_tc_minus1[
i], 0, 2047, 1,
i);
304 infer(low_delay_hrd_flag[
i], 0);
305 } else
306 flags(low_delay_hrd_flag[
i], 1,
i);
307
308 if (!current->low_delay_hrd_flag[
i])
309 ues(cpb_cnt_minus1[
i], 0, 31, 1,
i);
310 else
311 infer(cpb_cnt_minus1[
i], 0);
312
313 if (current->nal_hrd_parameters_present_flag)
315 if (current->vcl_hrd_parameters_present_flag)
317 }
318
319 return 0;
320 }
321
324 {
325 int err;
326
327 flag(aspect_ratio_info_present_flag);
328 if (current->aspect_ratio_info_present_flag) {
329 ub(8, aspect_ratio_idc);
330 if (current->aspect_ratio_idc == 255) {
333 }
334 } else {
335 infer(aspect_ratio_idc, 0);
336 }
337
338 flag(overscan_info_present_flag);
339 if (current->overscan_info_present_flag)
340 flag(overscan_appropriate_flag);
341
342 flag(video_signal_type_present_flag);
343 if (current->video_signal_type_present_flag) {
345 flag(video_full_range_flag);
346 flag(colour_description_present_flag);
347 if (current->colour_description_present_flag) {
348 ub(8, colour_primaries);
350 ub(8, matrix_coefficients);
351 } else {
352 infer(colour_primaries, 2);
354 infer(matrix_coefficients, 2);
355 }
356 } else {
357 infer(video_format, 5);
358 infer(video_full_range_flag, 0);
359 infer(colour_primaries, 2);
361 infer(matrix_coefficients, 2);
362 }
363
364 flag(chroma_loc_info_present_flag);
365 if (current->chroma_loc_info_present_flag) {
366 ue(chroma_sample_loc_type_top_field, 0, 5);
367 ue(chroma_sample_loc_type_bottom_field, 0, 5);
368 } else {
369 infer(chroma_sample_loc_type_top_field, 0);
370 infer(chroma_sample_loc_type_bottom_field, 0);
371 }
372
373 flag(neutral_chroma_indication_flag);
374 flag(field_seq_flag);
375 flag(frame_field_info_present_flag);
376
377 flag(default_display_window_flag);
378 if (current->default_display_window_flag) {
379 ue(def_disp_win_left_offset, 0, 16384);
380 ue(def_disp_win_right_offset, 0, 16384);
381 ue(def_disp_win_top_offset, 0, 16384);
382 ue(def_disp_win_bottom_offset, 0, 16384);
383 }
384
385 flag(vui_timing_info_present_flag);
386 if (current->vui_timing_info_present_flag) {
387 u(32, vui_num_units_in_tick, 1, UINT32_MAX);
388 u(32, vui_time_scale, 1, UINT32_MAX);
389 flag(vui_poc_proportional_to_timing_flag);
390 if (current->vui_poc_proportional_to_timing_flag)
391 ue(vui_num_ticks_poc_diff_one_minus1, 0, UINT32_MAX - 1);
392
393 flag(vui_hrd_parameters_present_flag);
394 if (current->vui_hrd_parameters_present_flag) {
396 1,
sps->sps_max_sub_layers_minus1));
397 }
398 }
399
400 flag(bitstream_restriction_flag);
401 if (current->bitstream_restriction_flag) {
402 flag(tiles_fixed_structure_flag);
403 flag(motion_vectors_over_pic_boundaries_flag);
404 flag(restricted_ref_pic_lists_flag);
405 ue(min_spatial_segmentation_idc, 0, 4095);
406 ue(max_bytes_per_pic_denom, 0, 16);
407 ue(max_bits_per_min_cu_denom, 0, 16);
408 ue(log2_max_mv_length_horizontal, 0, 16);
409 ue(log2_max_mv_length_vertical, 0, 16);
410 } else {
411 infer(tiles_fixed_structure_flag, 0);
412 infer(motion_vectors_over_pic_boundaries_flag, 1);
413 infer(min_spatial_segmentation_idc, 0);
414 infer(max_bytes_per_pic_denom, 2);
415 infer(max_bits_per_min_cu_denom, 1);
416 infer(log2_max_mv_length_horizontal, 15);
417 infer(log2_max_mv_length_vertical, 15);
418 }
419
420 return 0;
421 }
422
425 {
427
428 HEADER(
"Video Parameter Set");
429
431
432 ub(4, vps_video_parameter_set_id);
433
434 flag(vps_base_layer_internal_flag);
435 flag(vps_base_layer_available_flag);
438 flag(vps_temporal_id_nesting_flag);
439
440 if (current->vps_max_sub_layers_minus1 == 0 &&
441 current->vps_temporal_id_nesting_flag != 1) {
443 "vps_temporal_id_nesting_flag must be 1 if "
444 "vps_max_sub_layers_minus1 is 0.\n");
446 }
447
448 fixed(16, vps_reserved_0xffff_16bits, 0xffff);
449
451 1, current->vps_max_sub_layers_minus1));
452
453 flag(vps_sub_layer_ordering_info_present_flag);
454 for (
i = (current->vps_sub_layer_ordering_info_present_flag ?
455 0 : current->vps_max_sub_layers_minus1);
456 i <= current->vps_max_sub_layers_minus1;
i++) {
457 ues(vps_max_dec_pic_buffering_minus1[
i],
459 ues(vps_max_num_reorder_pics[
i],
460 0, current->vps_max_dec_pic_buffering_minus1[
i], 1,
i);
461 ues(vps_max_latency_increase_plus1[
i],
462 0, UINT32_MAX - 1, 1,
i);
463 }
464 if (!current->vps_sub_layer_ordering_info_present_flag) {
465 for (
i = 0;
i < current->vps_max_sub_layers_minus1;
i++) {
466 infer(vps_max_dec_pic_buffering_minus1[
i],
467 current->vps_max_dec_pic_buffering_minus1[current->vps_max_sub_layers_minus1]);
468 infer(vps_max_num_reorder_pics[
i],
469 current->vps_max_num_reorder_pics[current->vps_max_sub_layers_minus1]);
470 infer(vps_max_latency_increase_plus1[
i],
471 current->vps_max_latency_increase_plus1[current->vps_max_sub_layers_minus1]);
472 }
473 }
474
477 for (
i = 1;
i <= current->vps_num_layer_sets_minus1;
i++) {
478 for (j = 0; j <= current->vps_max_layer_id; j++)
479 flags(layer_id_included_flag[
i][j], 2,
i, j);
480 }
481 for (j = 0; j <= current->vps_max_layer_id; j++)
482 infer(layer_id_included_flag[0][j], j == 0);
483
484 flag(vps_timing_info_present_flag);
485 if (current->vps_timing_info_present_flag) {
486 u(32, vps_num_units_in_tick, 1, UINT32_MAX);
487 u(32, vps_time_scale, 1, UINT32_MAX);
488 flag(vps_poc_proportional_to_timing_flag);
489 if (current->vps_poc_proportional_to_timing_flag)
490 ue(vps_num_ticks_poc_diff_one_minus1, 0, UINT32_MAX - 1);
491 ue(vps_num_hrd_parameters, 0, current->vps_num_layer_sets_minus1 + 1);
492 for (
i = 0;
i < current->vps_num_hrd_parameters;
i++) {
493 ues(hrd_layer_set_idx[
i],
494 current->vps_base_layer_internal_flag ? 0 : 1,
495 current->vps_num_layer_sets_minus1, 1,
i);
497 flags(cprms_present_flag[
i], 1,
i);
498 else
499 infer(cprms_present_flag[0], 1);
500
502 current->cprms_present_flag[
i],
503 current->vps_max_sub_layers_minus1));
504 }
505 }
506
507 flag(vps_extension_flag);
508 if (current->vps_extension_flag)
510
512
513 return 0;
514 }
515
519 {
521
522 if (st_rps_idx != 0)
523 flag(inter_ref_pic_set_prediction_flag);
524 else
525 infer(inter_ref_pic_set_prediction_flag, 0);
526
527 if (current->inter_ref_pic_set_prediction_flag) {
528 unsigned int ref_rps_idx, num_delta_pocs, num_ref_pics;
530 int delta_rps, d_poc;
535
536 if (st_rps_idx ==
sps->num_short_term_ref_pic_sets)
537 ue(delta_idx_minus1, 0, st_rps_idx - 1);
538 else
539 infer(delta_idx_minus1, 0);
540
541 ref_rps_idx = st_rps_idx - (current->delta_idx_minus1 + 1);
542 ref = &
sps->st_ref_pic_set[ref_rps_idx];
543 num_delta_pocs =
ref->num_negative_pics +
ref->num_positive_pics;
545
546 flag(delta_rps_sign);
547 ue(abs_delta_rps_minus1, 0, INT16_MAX);
548 delta_rps = (1 - 2 * current->delta_rps_sign) *
549 (current->abs_delta_rps_minus1 + 1);
550
551 num_ref_pics = 0;
552 for (j = 0; j <= num_delta_pocs; j++) {
553 flags(used_by_curr_pic_flag[j], 1, j);
554 if (!current->used_by_curr_pic_flag[j])
555 flags(use_delta_flag[j], 1, j);
556 else
557 infer(use_delta_flag[j], 1);
558 if (current->use_delta_flag[j])
559 ++num_ref_pics;
560 }
563 "short-term ref pic set %d "
564 "contains too many pictures.\n", st_rps_idx);
566 }
567
568 // Since the stored form of an RPS here is actually the delta-step
569 // form used when inter_ref_pic_set_prediction_flag is not set, we
570 // need to reconstruct that here in order to be able to refer to
571 // the RPS later (which is required for parsing, because we don't
572 // even know what syntax elements appear without it). Therefore,
573 // this code takes the delta-step form of the reference set, turns
574 // it into the delta-array form, applies the prediction process of
575 // 7.4.8, converts the result back to the delta-step form, and
576 // stores that as the current set for future use. Note that the
577 // inferences here mean that writers using prediction will need
578 // to fill in the delta-step values correctly as well - since the
579 // whole RPS prediction process is somewhat overly sophisticated,
580 // this hopefully forms a useful check for them to ensure their
581 // predicted form actually matches what was intended rather than
582 // an onerous additional requirement.
583
584 d_poc = 0;
585 for (
i = 0;
i <
ref->num_negative_pics;
i++) {
586 d_poc -=
ref->delta_poc_s0_minus1[
i] + 1;
587 ref_delta_poc_s0[
i] = d_poc;
588 }
589 d_poc = 0;
590 for (
i = 0;
i <
ref->num_positive_pics;
i++) {
591 d_poc +=
ref->delta_poc_s1_minus1[
i] + 1;
592 ref_delta_poc_s1[
i] = d_poc;
593 }
594
596 for (j =
ref->num_positive_pics - 1; j >= 0; j--) {
597 d_poc = ref_delta_poc_s1[j] + delta_rps;
598 if (d_poc < 0 && current->use_delta_flag[
ref->num_negative_pics + j]) {
599 delta_poc_s0[
i] = d_poc;
600 used_by_curr_pic_s0[
i++] =
601 current->used_by_curr_pic_flag[
ref->num_negative_pics + j];
602 }
603 }
604 if (delta_rps < 0 && current->use_delta_flag[num_delta_pocs]) {
605 delta_poc_s0[
i] = delta_rps;
606 used_by_curr_pic_s0[
i++] =
607 current->used_by_curr_pic_flag[num_delta_pocs];
608 }
609 for (j = 0; j <
ref->num_negative_pics; j++) {
610 d_poc = ref_delta_poc_s0[j] + delta_rps;
611 if (d_poc < 0 && current->use_delta_flag[j]) {
612 delta_poc_s0[
i] = d_poc;
613 used_by_curr_pic_s0[
i++] = current->used_by_curr_pic_flag[j];
614 }
615 }
616
617 infer(num_negative_pics,
i);
618 for (
i = 0;
i < current->num_negative_pics;
i++) {
619 infer(delta_poc_s0_minus1[
i],
620 -(delta_poc_s0[
i] - (
i == 0 ? 0 : delta_poc_s0[
i - 1])) - 1);
621 infer(used_by_curr_pic_s0_flag[
i], used_by_curr_pic_s0[
i]);
622 }
623
625 for (j =
ref->num_negative_pics - 1; j >= 0; j--) {
626 d_poc = ref_delta_poc_s0[j] + delta_rps;
627 if (d_poc > 0 && current->use_delta_flag[j]) {
628 delta_poc_s1[
i] = d_poc;
629 used_by_curr_pic_s1[
i++] = current->used_by_curr_pic_flag[j];
630 }
631 }
632 if (delta_rps > 0 && current->use_delta_flag[num_delta_pocs]) {
633 delta_poc_s1[
i] = delta_rps;
634 used_by_curr_pic_s1[
i++] =
635 current->used_by_curr_pic_flag[num_delta_pocs];
636 }
637 for (j = 0; j <
ref->num_positive_pics; j++) {
638 d_poc = ref_delta_poc_s1[j] + delta_rps;
639 if (d_poc > 0 && current->use_delta_flag[
ref->num_negative_pics + j]) {
640 delta_poc_s1[
i] = d_poc;
641 used_by_curr_pic_s1[
i++] =
642 current->used_by_curr_pic_flag[
ref->num_negative_pics + j];
643 }
644 }
645
646 infer(num_positive_pics,
i);
647 for (
i = 0;
i < current->num_positive_pics;
i++) {
648 infer(delta_poc_s1_minus1[
i],
649 delta_poc_s1[
i] - (
i == 0 ? 0 : delta_poc_s1[
i - 1]) - 1);
650 infer(used_by_curr_pic_s1_flag[
i], used_by_curr_pic_s1[
i]);
651 }
652
653 } else {
654 ue(num_negative_pics, 0, 15);
655 ue(num_positive_pics, 0, 15 - current->num_negative_pics);
656
657 for (
i = 0;
i < current->num_negative_pics;
i++) {
658 ues(delta_poc_s0_minus1[
i], 0, INT16_MAX, 1,
i);
659 flags(used_by_curr_pic_s0_flag[
i], 1,
i);
660 }
661
662 for (
i = 0;
i < current->num_positive_pics;
i++) {
663 ues(delta_poc_s1_minus1[
i], 0, INT16_MAX, 1,
i);
664 flags(used_by_curr_pic_s1_flag[
i], 1,
i);
665 }
666 }
667
668 return 0;
669 }
670
673 {
674 int sizeId, matrixId;
676
677 for (sizeId = 0; sizeId < 4; sizeId++) {
678 for (matrixId = 0; matrixId < 6; matrixId += (sizeId == 3 ? 3 : 1)) {
679 flags(scaling_list_pred_mode_flag[sizeId][matrixId],
680 2, sizeId, matrixId);
681 if (!current->scaling_list_pred_mode_flag[sizeId][matrixId]) {
682 ues(scaling_list_pred_matrix_id_delta[sizeId][matrixId],
683 0, sizeId == 3 ? matrixId / 3 : matrixId,
684 2, sizeId, matrixId);
685 } else {
686 n =
FFMIN(64, 1 << (4 + (sizeId << 1)));
687 if (sizeId > 1) {
688 ses(scaling_list_dc_coef_minus8[sizeId - 2][matrixId], -7, +247,
689 2, sizeId - 2, matrixId);
690 }
691 for (
i = 0;
i < n;
i++) {
692 ses(scaling_list_delta_coeff[sizeId][matrixId][
i],
693 -128, +127, 3, sizeId, matrixId,
i);
694 }
695 }
696 }
697 }
698
699 return 0;
700 }
701
704 {
705 int err;
706
707 flag(transform_skip_rotation_enabled_flag);
708 flag(transform_skip_context_enabled_flag);
709 flag(implicit_rdpcm_enabled_flag);
710 flag(explicit_rdpcm_enabled_flag);
711 flag(extended_precision_processing_flag);
712 flag(intra_smoothing_disabled_flag);
713 flag(high_precision_offsets_enabled_flag);
714 flag(persistent_rice_adaptation_enabled_flag);
715 flag(cabac_bypass_alignment_enabled_flag);
716
717 return 0;
718 }
719
722 {
724
725 flag(sps_curr_pic_ref_enabled_flag);
726
727 flag(palette_mode_enabled_flag);
728 if (current->palette_mode_enabled_flag) {
729 ue(palette_max_size, 0, 64);
730 ue(delta_palette_max_predictor_size, 0, 128);
731
732 flag(sps_palette_predictor_initializer_present_flag);
733 if (current->sps_palette_predictor_initializer_present_flag) {
734 ue(sps_num_palette_predictor_initializer_minus1, 0, 127);
735 for (
comp = 0;
comp < (current->chroma_format_idc ? 3 : 1);
comp++) {
736 int bit_depth =
comp == 0 ? current->bit_depth_luma_minus8 + 8
737 : current->bit_depth_chroma_minus8 + 8;
738 for (
i = 0;
i <= current->sps_num_palette_predictor_initializer_minus1;
i++)
740 }
741 }
742 }
743
744 u(2, motion_vector_resolution_control_idc, 0, 2);
745 flag(intra_boundary_filtering_disable_flag);
746
747 return 0;
748 }
749
752 {
753 int err;
754
755 flag(inter_view_mv_vert_constraint_flag);
756
757 return 0;
758 }
759
763 {
764 infer(aspect_ratio_idc, 0);
765
766 infer(video_format, 5);
767 infer(video_full_range_flag, 0);
768 infer(colour_primaries, 2);
770 infer(matrix_coefficients, 2);
771
772 infer(chroma_sample_loc_type_top_field, 0);
773 infer(chroma_sample_loc_type_bottom_field, 0);
774
775 infer(tiles_fixed_structure_flag, 0);
776 infer(motion_vectors_over_pic_boundaries_flag, 1);
777 infer(min_spatial_segmentation_idc, 0);
778 infer(max_bytes_per_pic_denom, 2);
779 infer(max_bits_per_min_cu_denom, 1);
780 infer(log2_max_mv_length_horizontal, 15);
781 infer(log2_max_mv_length_vertical, 15);
782
783 return 0;
784 }
785
788 {
792 unsigned int min_cb_log2_size_y, ctb_log2_size_y,
793 min_cb_size_y, min_tb_log2_size_y;
794 unsigned int multi_layer_ext_sps_flag;
795
796 HEADER(
"Sequence Parameter Set");
797
799
800 ub(4, sps_video_parameter_set_id);
804 current->sps_video_parameter_set_id);
806 }
807
808 if (current->nal_unit_header.nuh_layer_id == 0)
809 u(3, sps_max_sub_layers_minus1, 0,
vps->vps_max_sub_layers_minus1);
810 else {
813 ?
vps->vps_max_sub_layers_minus1
814 : current->sps_ext_or_max_sub_layers_minus1);
815 }
816 multi_layer_ext_sps_flag = current->nal_unit_header.nuh_layer_id &&
818 if (!multi_layer_ext_sps_flag) {
819 flag(sps_temporal_id_nesting_flag);
820
821 if (
vps->vps_temporal_id_nesting_flag &&
822 !current->sps_temporal_id_nesting_flag) {
824 "sps_temporal_id_nesting_flag must be 1 if "
825 "vps_temporal_id_nesting_flag is 1.\n");
827 }
828 if (current->sps_max_sub_layers_minus1 == 0 &&
829 current->sps_temporal_id_nesting_flag != 1) {
831 "sps_temporal_id_nesting_flag must be 1 if "
832 "sps_max_sub_layers_minus1 is 0.\n");
834 }
835
837 1, current->sps_max_sub_layers_minus1));
838 } else {
839 if (current->sps_max_sub_layers_minus1 > 0)
840 infer(sps_temporal_id_nesting_flag,
vps->vps_temporal_id_nesting_flag);
841 else
842 infer(sps_temporal_id_nesting_flag, 1);
843 }
844
845 ue(sps_seq_parameter_set_id, 0, 15);
846
847 if (multi_layer_ext_sps_flag) {
848 flag(update_rep_format_flag);
849 if (current->update_rep_format_flag)
850 ub(8, sps_rep_format_idx);
851 } else {
852 ue(chroma_format_idc, 0, 3);
853 if (current->chroma_format_idc == 3)
854 flag(separate_colour_plane_flag);
855 else
856 infer(separate_colour_plane_flag, 0);
857
860
861 flag(conformance_window_flag);
862 if (current->conformance_window_flag) {
863 ue(conf_win_left_offset, 0, current->pic_width_in_luma_samples);
864 ue(conf_win_right_offset, 0, current->pic_width_in_luma_samples);
865 ue(conf_win_top_offset, 0, current->pic_height_in_luma_samples);
866 ue(conf_win_bottom_offset, 0, current->pic_height_in_luma_samples);
867 } else {
868 infer(conf_win_left_offset, 0);
869 infer(conf_win_right_offset, 0);
870 infer(conf_win_top_offset, 0);
871 infer(conf_win_bottom_offset, 0);
872 }
873
874 ue(bit_depth_luma_minus8, 0, 8);
875 ue(bit_depth_chroma_minus8, 0, 8);
876 }
877
878 ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
879
880 if (!multi_layer_ext_sps_flag) {
881 flag(sps_sub_layer_ordering_info_present_flag);
882 for (
i = (current->sps_sub_layer_ordering_info_present_flag ?
883 0 : current->sps_max_sub_layers_minus1);
884 i <= current->sps_max_sub_layers_minus1;
i++) {
885 ues(sps_max_dec_pic_buffering_minus1[
i],
887 ues(sps_max_num_reorder_pics[
i],
888 0, current->sps_max_dec_pic_buffering_minus1[
i], 1,
i);
889 ues(sps_max_latency_increase_plus1[
i],
890 0, UINT32_MAX - 1, 1,
i);
891 }
892 if (!current->sps_sub_layer_ordering_info_present_flag) {
893 for (
i = 0;
i < current->sps_max_sub_layers_minus1;
i++) {
894 infer(sps_max_dec_pic_buffering_minus1[
i],
895 current->sps_max_dec_pic_buffering_minus1[current->sps_max_sub_layers_minus1]);
896 infer(sps_max_num_reorder_pics[
i],
897 current->sps_max_num_reorder_pics[current->sps_max_sub_layers_minus1]);
898 infer(sps_max_latency_increase_plus1[
i],
899 current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
900 }
901 }
902 }
903
904 ue(log2_min_luma_coding_block_size_minus3, 0, 3);
905 min_cb_log2_size_y = current->log2_min_luma_coding_block_size_minus3 + 3;
906
907 ue(log2_diff_max_min_luma_coding_block_size, 0, 3);
908 ctb_log2_size_y = min_cb_log2_size_y +
909 current->log2_diff_max_min_luma_coding_block_size;
910
911 min_cb_size_y = 1 << min_cb_log2_size_y;
912 if (current->pic_width_in_luma_samples % min_cb_size_y ||
913 current->pic_height_in_luma_samples % min_cb_size_y) {
915 "by MinCbSizeY = %u.\n", current->pic_width_in_luma_samples,
916 current->pic_height_in_luma_samples, min_cb_size_y);
918 }
919
920 ue(log2_min_luma_transform_block_size_minus2, 0, min_cb_log2_size_y - 3);
921 min_tb_log2_size_y = current->log2_min_luma_transform_block_size_minus2 + 2;
922
923 ue(log2_diff_max_min_luma_transform_block_size,
924 0,
FFMIN(ctb_log2_size_y, 5) - min_tb_log2_size_y);
925
926 ue(max_transform_hierarchy_depth_inter,
927 0, ctb_log2_size_y - min_tb_log2_size_y);
928 ue(max_transform_hierarchy_depth_intra,
929 0, ctb_log2_size_y - min_tb_log2_size_y);
930
931 flag(scaling_list_enabled_flag);
932 if (current->scaling_list_enabled_flag) {
933 if (multi_layer_ext_sps_flag)
934 flag(sps_infer_scaling_list_flag);
935 else
936 infer(sps_infer_scaling_list_flag, 0);
937 if (current->sps_infer_scaling_list_flag)
938 ub(6, sps_scaling_list_ref_layer_id);
939 else {
940 flag(sps_scaling_list_data_present_flag);
941 if (current->sps_scaling_list_data_present_flag)
943 }
944 } else {
945 infer(sps_scaling_list_data_present_flag, 0);
946 }
947
948 flag(amp_enabled_flag);
949 flag(sample_adaptive_offset_enabled_flag);
950
951 flag(pcm_enabled_flag);
952 if (current->pcm_enabled_flag) {
953 u(4, pcm_sample_bit_depth_luma_minus1,
954 0, current->bit_depth_luma_minus8 + 8 - 1);
955 u(4, pcm_sample_bit_depth_chroma_minus1,
956 0, current->bit_depth_chroma_minus8 + 8 - 1);
957
958 ue(log2_min_pcm_luma_coding_block_size_minus3,
959 FFMIN(min_cb_log2_size_y, 5) - 3,
FFMIN(ctb_log2_size_y, 5) - 3);
960 ue(log2_diff_max_min_pcm_luma_coding_block_size,
961 0,
FFMIN(ctb_log2_size_y, 5) - (current->log2_min_pcm_luma_coding_block_size_minus3 + 3));
962
963 flag(pcm_loop_filter_disabled_flag);
964 }
965
967 for (
i = 0;
i < current->num_short_term_ref_pic_sets;
i++)
969
970 flag(long_term_ref_pics_present_flag);
971 if (current->long_term_ref_pics_present_flag) {
973 for (
i = 0;
i < current->num_long_term_ref_pics_sps;
i++) {
974 ubs(current->log2_max_pic_order_cnt_lsb_minus4 + 4,
975 lt_ref_pic_poc_lsb_sps[
i], 1,
i);
976 flags(used_by_curr_pic_lt_sps_flag[
i], 1,
i);
977 }
978 }
979
980 flag(sps_temporal_mvp_enabled_flag);
981 flag(strong_intra_smoothing_enabled_flag);
982
983 flag(vui_parameters_present_flag);
984 if (current->vui_parameters_present_flag)
986 else
988
989 flag(sps_extension_present_flag);
990 if (current->sps_extension_present_flag) {
991 flag(sps_range_extension_flag);
992 flag(sps_multilayer_extension_flag);
993 flag(sps_3d_extension_flag);
994 flag(sps_scc_extension_flag);
995 ub(4, sps_extension_4bits);
996 }
997
998 if (current->sps_range_extension_flag)
1000 if (current->sps_multilayer_extension_flag)
1002 if (current->sps_3d_extension_flag)
1004 if (current->sps_scc_extension_flag)
1006 if (current->sps_extension_4bits)
1008
1010
1011 return 0;
1012 }
1013
1016 {
1020
1021 if (current->transform_skip_enabled_flag)
1022 ue(log2_max_transform_skip_block_size_minus2, 0, 3);
1023 flag(cross_component_prediction_enabled_flag);
1024
1025 flag(chroma_qp_offset_list_enabled_flag);
1026 if (current->chroma_qp_offset_list_enabled_flag) {
1027 ue(diff_cu_chroma_qp_offset_depth,
1028 0,
sps->log2_diff_max_min_luma_coding_block_size);
1029 ue(chroma_qp_offset_list_len_minus1, 0, 5);
1030 for (
i = 0;
i <= current->chroma_qp_offset_list_len_minus1;
i++) {
1031 ses(cb_qp_offset_list[
i], -12, +12, 1,
i);
1032 ses(cr_qp_offset_list[
i], -12, +12, 1,
i);
1033 }
1034 }
1035
1036 ue(log2_sao_offset_scale_luma, 0,
FFMAX(0,
sps->bit_depth_luma_minus8 - 2));
1037 ue(log2_sao_offset_scale_chroma, 0,
FFMAX(0,
sps->bit_depth_chroma_minus8 - 2));
1038
1039 return 0;
1040 }
1041
1044 unsigned int idx_y, unsigned int idx_cb,
1045 unsigned int idx_cr, unsigned int inp_length)
1046 {
1047 int part_num_y, cm_res_bits;
1048 int err;
1049
1050 part_num_y = 1 << current->cm_y_part_num_log2;
1051
1053 if (inp_depth < current->cm_octant_depth)
1054 flags(split_octant_flag[inp_depth], 1, inp_depth);
1055 else
1056 infer(split_octant_flag[inp_depth], 0);
1057
1058 if (current->split_octant_flag[inp_depth])
1059 for (int k = 0; k < 2; k++)
1060 for (int m = 0; m < 2; m++)
1061 for (int n = 0; n < 2; n++)
1063 idx_y + part_num_y * k * inp_length / 2,
1064 idx_cb + m * inp_length / 2,
1065 idx_cr + n * inp_length / 2,
1066 inp_length / 2));
1067 else
1068 for (
int i = 0;
i < part_num_y;
i++) {
1069 int idx_shift_y = idx_y + (
i << (current->cm_octant_depth - inp_depth));
1070 for (int j = 0; j < 4; j++) {
1071 flags(coded_res_flag[idx_shift_y][idx_cb][idx_cr][j],
1072 4, idx_shift_y, idx_cb, idx_cr, j);
1073 if (current->coded_res_flag[idx_shift_y][idx_cb][idx_cr][j]) {
1074 for (
int c = 0;
c < 3;
c++) {
1075 ues(res_coeff_q[idx_shift_y][idx_cb][idx_cr][j][
c], 0, 3,
1076 5, idx_shift_y, idx_cb, idx_cr, j,
c);
1077 cm_res_bits =
FFMAX(0, 10 + (current->luma_bit_depth_cm_input_minus8 + 8) -
1078 (current->luma_bit_depth_cm_output_minus8 + 8) -
1079 current->cm_res_quant_bits - (current->cm_delta_flc_bits_minus1 + 1));
1080 if (cm_res_bits)
1081 ubs(cm_res_bits, res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][
c],
1082 5, idx_shift_y, idx_cb, idx_cr, j,
c);
1083 else
1084 infer(res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][
c], 0);
1085 if (current->res_coeff_q[idx_shift_y][idx_cb][idx_cr][j][
c] ||
1086 current->res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][
c])
1087 ub(1, res_coeff_s[idx_shift_y][idx_cb][idx_cr][j][
c]);
1088 else
1089 infer(res_coeff_s[idx_shift_y][idx_cb][idx_cr][j][
c], 0);
1090 }
1091 } else {
1092 for (
int c = 0;
c < 3;
c++) {
1093 infer(res_coeff_q[idx_shift_y][idx_cb][idx_cr][j][
c], 0);
1094 infer(res_coeff_r[idx_shift_y][idx_cb][idx_cr][j][
c], 0);
1095 infer(res_coeff_s[idx_shift_y][idx_cb][idx_cr][j][
c], 0);
1096 }
1097 }
1098 }
1099 }
1100
1101 return 0;
1102 }
1103
1106 {
1107 int err;
1108
1109 ue(num_cm_ref_layers_minus1, 0, 61);
1110 for (
int i = 0;
i <= current->num_cm_ref_layers_minus1;
i++)
1111 ubs(6, cm_ref_layer_id[
i], 1,
i);
1112
1113 u(2, cm_octant_depth, 0, 1);
1114 u(2, cm_y_part_num_log2, 0, 3 - current->cm_octant_depth);
1115
1116 ue(luma_bit_depth_cm_input_minus8, 0, 8);
1117 ue(chroma_bit_depth_cm_input_minus8, 0, 8);
1118 ue(luma_bit_depth_cm_output_minus8, 0, 8);
1119 ue(chroma_bit_depth_cm_output_minus8, 0, 8);
1120
1121 ub(2, cm_res_quant_bits);
1122 ub(2, cm_delta_flc_bits_minus1);
1123
1124 if (current->cm_octant_depth == 1) {
1125 se(cm_adapt_threshold_u_delta, -32768, 32767);
1126 se(cm_adapt_threshold_v_delta, -32768, 32767);
1127 } else {
1128 infer(cm_adapt_threshold_u_delta, 0);
1129 infer(cm_adapt_threshold_v_delta, 0);
1130 }
1131
1133
1134 return 0;
1135 }
1136
1139 {
1144
1145 flag(poc_reset_info_present_flag);
1146 flag(pps_infer_scaling_list_flag);
1147 if (current->pps_infer_scaling_list_flag)
1148 ub(6, pps_scaling_list_ref_layer_id);
1149
1153 }
1154
1155 ue(num_ref_loc_offsets, 0,
vps->vps_max_layers_minus1);
1156 for (
i = 0;
i < current->num_ref_loc_offsets;
i++) {
1157 ubs(6, ref_loc_offset_layer_id[
i], 1,
i);
1158 offset = current->ref_loc_offset_layer_id[
i];
1159 flags(scaled_ref_layer_offset_present_flag[
i], 1,
i);
1160 if (current->scaled_ref_layer_offset_present_flag[
i]) {
1164 ses(scaled_ref_layer_bottom_offset[
offset], -16384, 16383, 1,
offset);
1165 } else {
1170 }
1171 flags(ref_region_offset_present_flag[
i], 1,
i);
1172 if (current->ref_region_offset_present_flag[
i]) {
1177 } else {
1182 }
1183 flags(resample_phase_set_present_flag[
i], 1,
i);
1184 if (current->resample_phase_set_present_flag[
i]) {
1189 } else {
1193 }
1194 }
1195
1196 flag(colour_mapping_enabled_flag);
1197 if (current->colour_mapping_enabled_flag)
1199
1200 return 0;
1201 }
1202
1205 {
1207
1208 flag(pps_curr_pic_ref_enabled_flag);
1209
1210 flag(residual_adaptive_colour_transform_enabled_flag);
1211 if (current->residual_adaptive_colour_transform_enabled_flag) {
1212 flag(pps_slice_act_qp_offsets_present_flag);
1213 se(pps_act_y_qp_offset_plus5, -7, +17);
1214 se(pps_act_cb_qp_offset_plus5, -7, +17);
1215 se(pps_act_cr_qp_offset_plus3, -9, +15);
1216 } else {
1217 infer(pps_slice_act_qp_offsets_present_flag, 0);
1218 infer(pps_act_y_qp_offset_plus5, 0);
1219 infer(pps_act_cb_qp_offset_plus5, 0);
1220 infer(pps_act_cr_qp_offset_plus3, 0);
1221 }
1222
1223 flag(pps_palette_predictor_initializer_present_flag);
1224 if (current->pps_palette_predictor_initializer_present_flag) {
1225 ue(pps_num_palette_predictor_initializer, 0, 128);
1226 if (current->pps_num_palette_predictor_initializer > 0) {
1227 flag(monochrome_palette_flag);
1228 ue(luma_bit_depth_entry_minus8, 0, 8);
1229 if (!current->monochrome_palette_flag)
1230 ue(chroma_bit_depth_entry_minus8, 0, 8);
1231 for (
comp = 0;
comp < (current->monochrome_palette_flag ? 1 : 3);
comp++) {
1232 int bit_depth =
comp == 0 ? current->luma_bit_depth_entry_minus8 + 8
1233 : current->chroma_bit_depth_entry_minus8 + 8;
1234 for (
i = 0;
i < current->pps_num_palette_predictor_initializer;
i++)
1236 }
1237 }
1238 }
1239
1240 return 0;
1241 }
1242
1245 {
1249
1250 HEADER(
"Picture Parameter Set");
1251
1253
1254 ue(pps_pic_parameter_set_id, 0, 63);
1255 ue(pps_seq_parameter_set_id, 0, 15);
1256 sps = h265->
sps[current->pps_seq_parameter_set_id];
1259 current->pps_seq_parameter_set_id);
1261 }
1263
1264 flag(dependent_slice_segments_enabled_flag);
1265 flag(output_flag_present_flag);
1266 ub(3, num_extra_slice_header_bits);
1267 flag(sign_data_hiding_enabled_flag);
1268 flag(cabac_init_present_flag);
1269
1270 ue(num_ref_idx_l0_default_active_minus1, 0, 14);
1271 ue(num_ref_idx_l1_default_active_minus1, 0, 14);
1272
1273 se(init_qp_minus26, -(26 + 6 *
sps->bit_depth_luma_minus8), +25);
1274
1275 flag(constrained_intra_pred_flag);
1276 flag(transform_skip_enabled_flag);
1277 flag(cu_qp_delta_enabled_flag);
1278 if (current->cu_qp_delta_enabled_flag)
1279 ue(diff_cu_qp_delta_depth,
1280 0,
sps->log2_diff_max_min_luma_coding_block_size);
1281 else
1282 infer(diff_cu_qp_delta_depth, 0);
1283
1284 se(pps_cb_qp_offset, -12, +12);
1285 se(pps_cr_qp_offset, -12, +12);
1286 flag(pps_slice_chroma_qp_offsets_present_flag);
1287
1288 flag(weighted_pred_flag);
1289 flag(weighted_bipred_flag);
1290
1291 flag(transquant_bypass_enabled_flag);
1292 flag(tiles_enabled_flag);
1293 flag(entropy_coding_sync_enabled_flag);
1294
1295 if (current->tiles_enabled_flag) {
1298 flag(uniform_spacing_flag);
1299 if (!current->uniform_spacing_flag) {
1300 for (
i = 0;
i < current->num_tile_columns_minus1;
i++)
1301 ues(column_width_minus1[
i], 0,
sps->pic_width_in_luma_samples, 1,
i);
1302 for (
i = 0;
i < current->num_tile_rows_minus1;
i++)
1303 ues(row_height_minus1[
i], 0,
sps->pic_height_in_luma_samples, 1,
i);
1304 }
1305 flag(loop_filter_across_tiles_enabled_flag);
1306 } else {
1307 infer(num_tile_columns_minus1, 0);
1308 infer(num_tile_rows_minus1, 0);
1309 }
1310
1311 flag(pps_loop_filter_across_slices_enabled_flag);
1312 flag(deblocking_filter_control_present_flag);
1313 if (current->deblocking_filter_control_present_flag) {
1314 flag(deblocking_filter_override_enabled_flag);
1315 flag(pps_deblocking_filter_disabled_flag);
1316 if (!current->pps_deblocking_filter_disabled_flag) {
1317 se(pps_beta_offset_div2, -6, +6);
1318 se(pps_tc_offset_div2, -6, +6);
1319 } else {
1320 infer(pps_beta_offset_div2, 0);
1321 infer(pps_tc_offset_div2, 0);
1322 }
1323 } else {
1324 infer(deblocking_filter_override_enabled_flag, 0);
1325 infer(pps_deblocking_filter_disabled_flag, 0);
1326 infer(pps_beta_offset_div2, 0);
1327 infer(pps_tc_offset_div2, 0);
1328 }
1329
1330 flag(pps_scaling_list_data_present_flag);
1331 if (current->pps_scaling_list_data_present_flag)
1333
1334 flag(lists_modification_present_flag);
1335
1336 ue(log2_parallel_merge_level_minus2,
1337 0, (
sps->log2_min_luma_coding_block_size_minus3 + 3 +
1338 sps->log2_diff_max_min_luma_coding_block_size - 2));
1339
1340 flag(slice_segment_header_extension_present_flag);
1341
1342 flag(pps_extension_present_flag);
1343 if (current->pps_extension_present_flag) {
1344 flag(pps_range_extension_flag);
1345 flag(pps_multilayer_extension_flag);
1346 flag(pps_3d_extension_flag);
1347 flag(pps_scc_extension_flag);
1348 ub(4, pps_extension_4bits);
1349 }
1350 if (current->pps_range_extension_flag)
1352 if (current->pps_multilayer_extension_flag)
1354 if (current->pps_3d_extension_flag)
1356 if (current->pps_scc_extension_flag)
1358 if (current->pps_extension_4bits)
1360
1362
1363 return 0;
1364 }
1365
1368 {
1369 int err;
1370
1371 HEADER(
"Access Unit Delimiter");
1372
1374
1375 u(3, pic_type, 0, 2);
1376
1378
1379 return 0;
1380 }
1381
1384 unsigned int num_pic_total_curr)
1385 {
1386 unsigned int entry_size;
1388
1389 entry_size =
av_log2(num_pic_total_curr - 1) + 1;
1390
1391 flag(ref_pic_list_modification_flag_l0);
1392 if (current->ref_pic_list_modification_flag_l0) {
1393 for (
i = 0;
i <= current->num_ref_idx_l0_active_minus1;
i++)
1394 us(entry_size, list_entry_l0[
i], 0, num_pic_total_curr - 1, 1,
i);
1395 }
1396
1398 flag(ref_pic_list_modification_flag_l1);
1399 if (current->ref_pic_list_modification_flag_l1) {
1400 for (
i = 0;
i <= current->num_ref_idx_l1_active_minus1;
i++)
1401 us(entry_size, list_entry_l1[
i], 0, num_pic_total_curr - 1, 1,
i);
1402 }
1403 }
1404
1405 return 0;
1406 }
1407
1410 {
1414 int chroma = !
sps->separate_colour_plane_flag &&
1415 sps->chroma_format_idc != 0;
1416
1417 ue(luma_log2_weight_denom, 0, 7);
1419 se(delta_chroma_log2_weight_denom, -7, 7);
1420 else
1421 infer(delta_chroma_log2_weight_denom, 0);
1422
1423 for (
i = 0;
i <= current->num_ref_idx_l0_active_minus1;
i++) {
1424 if (1 /* is not same POC and same layer_id */)
1425 flags(luma_weight_l0_flag[
i], 1,
i);
1426 else
1427 infer(luma_weight_l0_flag[
i], 0);
1428 }
1430 for (
i = 0;
i <= current->num_ref_idx_l0_active_minus1;
i++) {
1431 if (1 /* is not same POC and same layer_id */)
1432 flags(chroma_weight_l0_flag[
i], 1,
i);
1433 else
1434 infer(chroma_weight_l0_flag[
i], 0);
1435 }
1436 }
1437
1438 for (
i = 0;
i <= current->num_ref_idx_l0_active_minus1;
i++) {
1439 if (current->luma_weight_l0_flag[
i]) {
1440 ses(delta_luma_weight_l0[
i], -128, +127, 1,
i);
1441 ses(luma_offset_l0[
i],
1442 -(1 << (
sps->bit_depth_luma_minus8 + 8 - 1)),
1443 ((1 << (
sps->bit_depth_luma_minus8 + 8 - 1)) - 1), 1,
i);
1444 } else {
1445 infer(delta_luma_weight_l0[
i], 0);
1446 infer(luma_offset_l0[
i], 0);
1447 }
1448 if (current->chroma_weight_l0_flag[
i]) {
1449 for (j = 0; j < 2; j++) {
1450 ses(delta_chroma_weight_l0[
i][j], -128, +127, 2,
i, j);
1451 ses(chroma_offset_l0[
i][j],
1452 -(4 << (
sps->bit_depth_chroma_minus8 + 8 - 1)),
1453 ((4 << (
sps->bit_depth_chroma_minus8 + 8 - 1)) - 1), 2,
i, j);
1454 }
1455 } else {
1456 for (j = 0; j < 2; j++) {
1457 infer(delta_chroma_weight_l0[
i][j], 0);
1458 infer(chroma_offset_l0[
i][j], 0);
1459 }
1460 }
1461 }
1462
1464 for (
i = 0;
i <= current->num_ref_idx_l1_active_minus1;
i++) {
1465 if (1 /* RefPicList1[i] is not CurrPic, nor is it in a different layer */)
1466 flags(luma_weight_l1_flag[
i], 1,
i);
1467 else
1468 infer(luma_weight_l1_flag[
i], 0);
1469 }
1471 for (
i = 0;
i <= current->num_ref_idx_l1_active_minus1;
i++) {
1472 if (1 /* RefPicList1[i] is not CurrPic, nor is it in a different layer */)
1473 flags(chroma_weight_l1_flag[
i], 1,
i);
1474 else
1475 infer(chroma_weight_l1_flag[
i], 0);
1476 }
1477 }
1478
1479 for (
i = 0;
i <= current->num_ref_idx_l1_active_minus1;
i++) {
1480 if (current->luma_weight_l1_flag[
i]) {
1481 ses(delta_luma_weight_l1[
i], -128, +127, 1,
i);
1482 ses(luma_offset_l1[
i],
1483 -(1 << (
sps->bit_depth_luma_minus8 + 8 - 1)),
1484 ((1 << (
sps->bit_depth_luma_minus8 + 8 - 1)) - 1), 1,
i);
1485 } else {
1486 infer(delta_luma_weight_l1[
i], 0);
1487 infer(luma_offset_l1[
i], 0);
1488 }
1489 if (current->chroma_weight_l1_flag[
i]) {
1490 for (j = 0; j < 2; j++) {
1491 ses(delta_chroma_weight_l1[
i][j], -128, +127, 2,
i, j);
1492 ses(chroma_offset_l1[
i][j],
1493 -(4 << (
sps->bit_depth_chroma_minus8 + 8 - 1)),
1494 ((4 << (
sps->bit_depth_chroma_minus8 + 8 - 1)) - 1), 2,
i, j);
1495 }
1496 } else {
1497 for (j = 0; j < 2; j++) {
1498 infer(delta_chroma_weight_l1[
i][j], 0);
1499 infer(chroma_offset_l1[
i][j], 0);
1500 }
1501 }
1502 }
1503 }
1504
1505 return 0;
1506 }
1507
1510 {
1514 unsigned int min_cb_log2_size_y, ctb_log2_size_y, ctb_size_y;
1515 unsigned int pic_width_in_ctbs_y, pic_height_in_ctbs_y, pic_size_in_ctbs_y;
1516 unsigned int num_pic_total_curr = 0;
1518
1519 HEADER(
"Slice Segment Header");
1520
1522
1523 flag(first_slice_segment_in_pic_flag);
1524
1527 flag(no_output_of_prior_pics_flag);
1528
1529 ue(slice_pic_parameter_set_id, 0, 63);
1530
1531 pps = h265->
pps[current->slice_pic_parameter_set_id];
1534 current->slice_pic_parameter_set_id);
1536 }
1538
1539 sps = h265->
sps[
pps->pps_seq_parameter_set_id];
1542 pps->pps_seq_parameter_set_id);
1544 }
1546
1547 min_cb_log2_size_y =
sps->log2_min_luma_coding_block_size_minus3 + 3;
1548 ctb_log2_size_y = min_cb_log2_size_y +
sps->log2_diff_max_min_luma_coding_block_size;
1549 ctb_size_y = 1 << ctb_log2_size_y;
1550 pic_width_in_ctbs_y =
1551 (
sps->pic_width_in_luma_samples + ctb_size_y - 1) / ctb_size_y;
1552 pic_height_in_ctbs_y =
1553 (
sps->pic_height_in_luma_samples + ctb_size_y - 1) / ctb_size_y;
1554 pic_size_in_ctbs_y = pic_width_in_ctbs_y * pic_height_in_ctbs_y;
1555
1556 if (!current->first_slice_segment_in_pic_flag) {
1557 unsigned int address_size =
av_log2(pic_size_in_ctbs_y - 1) + 1;
1558 if (
pps->dependent_slice_segments_enabled_flag)
1559 flag(dependent_slice_segment_flag);
1560 else
1561 infer(dependent_slice_segment_flag, 0);
1562 u(address_size, slice_segment_address, 0, pic_size_in_ctbs_y - 1);
1563 } else {
1564 infer(dependent_slice_segment_flag, 0);
1565 }
1566
1567 if (!current->dependent_slice_segment_flag) {
1568 for (
i = 0;
i <
pps->num_extra_slice_header_bits;
i++)
1569 flags(slice_reserved_flag[
i], 1,
i);
1570
1571 ue(slice_type, 0, 2);
1572
1573 if (
pps->output_flag_present_flag)
1574 flag(pic_output_flag);
1575
1576 if (
sps->separate_colour_plane_flag)
1577 u(2, colour_plane_id, 0, 2);
1578
1582 int dpb_slots_remaining;
1583
1584 ub(
sps->log2_max_pic_order_cnt_lsb_minus4 + 4, slice_pic_order_cnt_lsb);
1585
1586 flag(short_term_ref_pic_set_sps_flag);
1587 if (!current->short_term_ref_pic_set_sps_flag) {
1589 sps->num_short_term_ref_pic_sets,
sps));
1590 rps = ¤t->short_term_ref_pic_set;
1591 }
else if (
sps->num_short_term_ref_pic_sets > 1) {
1592 unsigned int idx_size =
av_log2(
sps->num_short_term_ref_pic_sets - 1) + 1;
1593 u(idx_size, short_term_ref_pic_set_idx,
1594 0,
sps->num_short_term_ref_pic_sets - 1);
1595 rps = &
sps->st_ref_pic_set[current->short_term_ref_pic_set_idx];
1596 } else {
1597 infer(short_term_ref_pic_set_idx, 0);
1598 rps = &
sps->st_ref_pic_set[0];
1599 }
1600
1603 if (
pps->pps_curr_pic_ref_enabled_flag &&
1604 (
sps->sample_adaptive_offset_enabled_flag ||
1605 !
pps->pps_deblocking_filter_disabled_flag ||
1606 pps->deblocking_filter_override_enabled_flag)) {
1607 // This picture will occupy two DPB slots.
1608 if (dpb_slots_remaining == 0) {
1610 "short-term ref pic set contains too many pictures "
1611 "to use with current picture reference enabled.\n");
1613 }
1614 --dpb_slots_remaining;
1615 }
1616
1617 num_pic_total_curr = 0;
1620 ++num_pic_total_curr;
1623 ++num_pic_total_curr;
1624
1625 if (
sps->long_term_ref_pics_present_flag) {
1626 unsigned int idx_size;
1627
1628 if (
sps->num_long_term_ref_pics_sps > 0) {
1629 ue(num_long_term_sps, 0,
FFMIN(
sps->num_long_term_ref_pics_sps,
1630 dpb_slots_remaining));
1631 idx_size =
av_log2(
sps->num_long_term_ref_pics_sps - 1) + 1;
1632 dpb_slots_remaining -= current->num_long_term_sps;
1633 } else {
1634 infer(num_long_term_sps, 0);
1635 idx_size = 0;
1636 }
1637 ue(num_long_term_pics, 0, dpb_slots_remaining);
1638
1639 for (
i = 0;
i < current->num_long_term_sps +
1640 current->num_long_term_pics;
i++) {
1641 if (i < current->num_long_term_sps) {
1642 if (
sps->num_long_term_ref_pics_sps > 1)
1643 us(idx_size, lt_idx_sps[
i],
1644 0,
sps->num_long_term_ref_pics_sps - 1, 1,
i);
1645 if (
sps->used_by_curr_pic_lt_sps_flag[current->lt_idx_sps[
i]])
1646 ++num_pic_total_curr;
1647 } else {
1648 ubs(
sps->log2_max_pic_order_cnt_lsb_minus4 + 4, poc_lsb_lt[
i], 1,
i);
1649 flags(used_by_curr_pic_lt_flag[
i], 1,
i);
1650 if (current->used_by_curr_pic_lt_flag[
i])
1651 ++num_pic_total_curr;
1652 }
1653 flags(delta_poc_msb_present_flag[
i], 1,
i);
1654 if (current->delta_poc_msb_present_flag[
i])
1655 ues(delta_poc_msb_cycle_lt[
i], 0, UINT32_MAX - 1, 1,
i);
1656 else
1657 infer(delta_poc_msb_cycle_lt[
i], 0);
1658 }
1659 }
1660
1661 if (
sps->sps_temporal_mvp_enabled_flag)
1662 flag(slice_temporal_mvp_enabled_flag);
1663 else
1664 infer(slice_temporal_mvp_enabled_flag, 0);
1665
1666 if (
pps->pps_curr_pic_ref_enabled_flag)
1667 ++num_pic_total_curr;
1668 }
1669
1670 if (
sps->sample_adaptive_offset_enabled_flag) {
1671 flag(slice_sao_luma_flag);
1672 if (!
sps->separate_colour_plane_flag &&
sps->chroma_format_idc != 0)
1673 flag(slice_sao_chroma_flag);
1674 else
1675 infer(slice_sao_chroma_flag, 0);
1676 } else {
1677 infer(slice_sao_luma_flag, 0);
1678 infer(slice_sao_chroma_flag, 0);
1679 }
1680
1683 flag(num_ref_idx_active_override_flag);
1684 if (current->num_ref_idx_active_override_flag) {
1685 ue(num_ref_idx_l0_active_minus1, 0, 14);
1687 ue(num_ref_idx_l1_active_minus1, 0, 14);
1688 else
1689 infer(num_ref_idx_l1_active_minus1,
pps->num_ref_idx_l1_default_active_minus1);
1690 } else {
1691 infer(num_ref_idx_l0_active_minus1,
pps->num_ref_idx_l0_default_active_minus1);
1692 infer(num_ref_idx_l1_active_minus1,
pps->num_ref_idx_l1_default_active_minus1);
1693 }
1694
1695 if (
pps->lists_modification_present_flag && num_pic_total_curr > 1)
1697 num_pic_total_curr));
1698
1700 flag(mvd_l1_zero_flag);
1701 if (
pps->cabac_init_present_flag)
1702 flag(cabac_init_flag);
1703 else
1704 infer(cabac_init_flag, 0);
1705 if (current->slice_temporal_mvp_enabled_flag) {
1707 flag(collocated_from_l0_flag);
1708 else
1709 infer(collocated_from_l0_flag, 1);
1710 if (current->collocated_from_l0_flag) {
1711 if (current->num_ref_idx_l0_active_minus1 > 0)
1712 ue(collocated_ref_idx, 0, current->num_ref_idx_l0_active_minus1);
1713 else
1714 infer(collocated_ref_idx, 0);
1715 } else {
1716 if (current->num_ref_idx_l1_active_minus1 > 0)
1717 ue(collocated_ref_idx, 0, current->num_ref_idx_l1_active_minus1);
1718 else
1719 infer(collocated_ref_idx, 0);
1720 }
1721 }
1722
1723 if ((
pps->weighted_pred_flag && current->slice_type ==
HEVC_SLICE_P) ||
1726
1727 ue(five_minus_max_num_merge_cand, 0, 4);
1728 if (
sps->motion_vector_resolution_control_idc == 2)
1729 flag(use_integer_mv_flag);
1730 else
1731 infer(use_integer_mv_flag,
sps->motion_vector_resolution_control_idc);
1732 }
1733
1735 - 6 *
sps->bit_depth_luma_minus8 - (
pps->init_qp_minus26 + 26),
1736 + 51 - (
pps->init_qp_minus26 + 26));
1737 if (
pps->pps_slice_chroma_qp_offsets_present_flag) {
1738 se(slice_cb_qp_offset, -12, +12);
1739 se(slice_cr_qp_offset, -12, +12);
1740 } else {
1741 infer(slice_cb_qp_offset, 0);
1742 infer(slice_cr_qp_offset, 0);
1743 }
1744 if (
pps->pps_slice_act_qp_offsets_present_flag) {
1745 se(slice_act_y_qp_offset,
1746 -12 - (
pps->pps_act_y_qp_offset_plus5 - 5),
1747 +12 - (
pps->pps_act_y_qp_offset_plus5 - 5));
1748 se(slice_act_cb_qp_offset,
1749 -12 - (
pps->pps_act_cb_qp_offset_plus5 - 5),
1750 +12 - (
pps->pps_act_cb_qp_offset_plus5 - 5));
1751 se(slice_act_cr_qp_offset,
1752 -12 - (
pps->pps_act_cr_qp_offset_plus3 - 3),
1753 +12 - (
pps->pps_act_cr_qp_offset_plus3 - 3));
1754 } else {
1755 infer(slice_act_y_qp_offset, 0);
1756 infer(slice_act_cb_qp_offset, 0);
1757 infer(slice_act_cr_qp_offset, 0);
1758 }
1759 if (
pps->chroma_qp_offset_list_enabled_flag)
1760 flag(cu_chroma_qp_offset_enabled_flag);
1761 else
1762 infer(cu_chroma_qp_offset_enabled_flag, 0);
1763
1764 if (
pps->deblocking_filter_override_enabled_flag)
1765 flag(deblocking_filter_override_flag);
1766 else
1767 infer(deblocking_filter_override_flag, 0);
1768 if (current->deblocking_filter_override_flag) {
1769 flag(slice_deblocking_filter_disabled_flag);
1770 if (!current->slice_deblocking_filter_disabled_flag) {
1771 se(slice_beta_offset_div2, -6, +6);
1772 se(slice_tc_offset_div2, -6, +6);
1773 } else {
1774 infer(slice_beta_offset_div2,
pps->pps_beta_offset_div2);
1775 infer(slice_tc_offset_div2,
pps->pps_tc_offset_div2);
1776 }
1777 } else {
1778 infer(slice_deblocking_filter_disabled_flag,
1779 pps->pps_deblocking_filter_disabled_flag);
1780 infer(slice_beta_offset_div2,
pps->pps_beta_offset_div2);
1781 infer(slice_tc_offset_div2,
pps->pps_tc_offset_div2);
1782 }
1783 if (
pps->pps_loop_filter_across_slices_enabled_flag &&
1784 (current->slice_sao_luma_flag || current->slice_sao_chroma_flag ||
1785 !current->slice_deblocking_filter_disabled_flag))
1786 flag(slice_loop_filter_across_slices_enabled_flag);
1787 else
1788 infer(slice_loop_filter_across_slices_enabled_flag,
1789 pps->pps_loop_filter_across_slices_enabled_flag);
1790 }
1791
1792 if (
pps->tiles_enabled_flag ||
pps->entropy_coding_sync_enabled_flag) {
1793 unsigned int num_entry_point_offsets_limit;
1794 if (!
pps->tiles_enabled_flag &&
pps->entropy_coding_sync_enabled_flag)
1795 num_entry_point_offsets_limit = pic_height_in_ctbs_y - 1;
1796 else if (
pps->tiles_enabled_flag && !
pps->entropy_coding_sync_enabled_flag)
1797 num_entry_point_offsets_limit =
1798 (
pps->num_tile_columns_minus1 + 1) * (
pps->num_tile_rows_minus1 + 1);
1799 else
1800 num_entry_point_offsets_limit =
1801 (
pps->num_tile_columns_minus1 + 1) * pic_height_in_ctbs_y - 1;
1802 ue(num_entry_point_offsets, 0, num_entry_point_offsets_limit);
1803
1806 "%"PRIu16".\n", current->num_entry_point_offsets);
1808 }
1809
1810 if (current->num_entry_point_offsets > 0) {
1811 ue(offset_len_minus1, 0, 31);
1812 for (
i = 0;
i < current->num_entry_point_offsets;
i++)
1813 ubs(current->offset_len_minus1 + 1, entry_point_offset_minus1[
i], 1,
i);
1814 }
1815 }
1816
1817 if (
pps->slice_segment_header_extension_present_flag) {
1818 ue(slice_segment_header_extension_length, 0, 256);
1819 for (
i = 0;
i < current->slice_segment_header_extension_length;
i++)
1820 us(8, slice_segment_header_extension_data_byte[
i], 0x00, 0xff, 1,
i);
1821 }
1822
1824
1825 return 0;
1826 }
1827
1831 {
1836
1837 #ifdef READ
1838 int start_pos, end_pos;
1840 #endif
1841
1842 HEADER(
"Buffering Period");
1843
1845
1851 }
1853
1854 if (!
sps->vui_parameters_present_flag ||
1855 !
sps->vui.vui_hrd_parameters_present_flag) {
1857 "HRD parameters to be present in SPS.\n");
1859 }
1860 hrd = &
sps->vui.hrd_parameters;
1864 "NAL or VCL HRD parameters to be present.\n");
1866 }
1867
1869 flag(irap_cpb_params_present_flag);
1870 else
1871 infer(irap_cpb_params_present_flag, 0);
1874 ub(length, cpb_delay_offset);
1876 ub(length, dpb_delay_offset);
1877 } else {
1878 infer(cpb_delay_offset, 0);
1879 infer(dpb_delay_offset, 0);
1880 }
1881
1882 flag(concatenation_flag);
1883
1885 ub(length, au_cpb_removal_delay_delta_minus1);
1886
1890
1891 ubs(length, nal_initial_cpb_removal_delay[
i], 1,
i);
1892 ubs(length, nal_initial_cpb_removal_offset[
i], 1,
i);
1893
1896 ubs(length, nal_initial_alt_cpb_removal_delay[
i], 1,
i);
1897 ubs(length, nal_initial_alt_cpb_removal_offset[
i], 1,
i);
1898 }
1899 }
1900 }
1904
1905 ubs(length, vcl_initial_cpb_removal_delay[
i], 1,
i);
1906 ubs(length, vcl_initial_cpb_removal_offset[
i], 1,
i);
1907
1910 ubs(length, vcl_initial_alt_cpb_removal_delay[
i], 1,
i);
1911 ubs(length, vcl_initial_alt_cpb_removal_offset[
i], 1,
i);
1912 }
1913 }
1914 }
1915
1916 #ifdef READ
1919 end_pos - start_pos))
1920 flag(use_alt_cpb_params_flag);
1921 else
1922 infer(use_alt_cpb_params_flag, 0);
1923 #else
1924 // If unknown extension data exists, then use_alt_cpb_params_flag is
1925 // coded in the bitstream and must be written even if it's 0.
1927 flag(use_alt_cpb_params_flag);
1928 // Ensure this bit is not the last in the payload by making the
1929 // more_data_in_payload() check evaluate to true, so it may not
1930 // be mistaken as something else by decoders.
1931 sei->extension_present = 1;
1932 }
1933 #endif
1934
1935 return 0;
1936 }
1937
1940 {
1944 int err, expected_source_scan_type,
i, length;
1945
1946 HEADER(
"Picture Timing");
1947
1951 "No active SPS for pic_timing.\n");
1953 }
1954
1955 expected_source_scan_type = 2 -
1956 2 *
sps->profile_tier_level.general_interlaced_source_flag -
1957 sps->profile_tier_level.general_progressive_source_flag;
1958
1959 if (
sps->vui.frame_field_info_present_flag) {
1960 u(4, pic_struct, 0, 12);
1961 u(2, source_scan_type,
1962 expected_source_scan_type >= 0 ? expected_source_scan_type : 0,
1963 expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1964 flag(duplicate_flag);
1965 } else {
1966 infer(pic_struct, 0);
1967 infer(source_scan_type,
1968 expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1969 infer(duplicate_flag, 0);
1970 }
1971
1972 if (
sps->vui_parameters_present_flag &&
1973 sps->vui.vui_hrd_parameters_present_flag)
1974 hrd = &
sps->vui.hrd_parameters;
1975 else
1980 ub(length, au_cpb_removal_delay_minus1);
1981
1983 ub(length, pic_dpb_output_delay);
1984
1987 ub(length, pic_dpb_output_du_delay);
1988 }
1989
1992 // Each decoding unit must contain at least one slice segment.
1994 flag(du_common_cpb_removal_delay_flag);
1995
1998 ub(length, du_common_cpb_removal_delay_increment_minus1);
1999
2001 ues(num_nalus_in_du_minus1[
i],
2004 i < current->num_decoding_units_minus1)
2005 ubs(length, du_cpb_removal_delay_increment_minus1[
i], 1,
i);
2006 }
2007 }
2008 }
2009
2010 return 0;
2011 }
2012
2016 {
2018
2019 HEADER(
"Pan-Scan Rectangle");
2020
2021 ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
2022 flag(pan_scan_rect_cancel_flag);
2023
2025 ue(pan_scan_cnt_minus1, 0, 2);
2026
2028 ses(pan_scan_rect_left_offset[
i], INT32_MIN + 1, INT32_MAX, 1,
i);
2029 ses(pan_scan_rect_right_offset[
i], INT32_MIN + 1, INT32_MAX, 1,
i);
2030 ses(pan_scan_rect_top_offset[
i], INT32_MIN + 1, INT32_MAX, 1,
i);
2031 ses(pan_scan_rect_bottom_offset[
i], INT32_MIN + 1, INT32_MAX, 1,
i);
2032 }
2033
2034 flag(pan_scan_rect_persistence_flag);
2035 }
2036
2037 return 0;
2038 }
2039
2043 {
2044 int err;
2045
2046 HEADER(
"Recovery Point");
2047
2048 se(recovery_poc_cnt, -32768, 32767);
2049
2050 flag(exact_match_flag);
2051 flag(broken_link_flag);
2052
2053 return 0;
2054 }
2055
2059 {
2063
2064 HEADER(
"Film Grain Characteristics");
2065
2066 flag(film_grain_characteristics_cancel_flag);
2068 int filmGrainBitDepth[3];
2069
2070 u(2, film_grain_model_id, 0, 1);
2071 flag(separate_colour_description_present_flag);
2073 ub(3, film_grain_bit_depth_luma_minus8);
2074 ub(3, film_grain_bit_depth_chroma_minus8);
2075 flag(film_grain_full_range_flag);
2076 ub(8, film_grain_colour_primaries);
2077 ub(8, film_grain_transfer_characteristics);
2078 ub(8, film_grain_matrix_coeffs);
2079 } else {
2082 "No active SPS for film_grain_characteristics.\n");
2084 }
2085 infer(film_grain_bit_depth_luma_minus8,
sps->bit_depth_luma_minus8);
2086 infer(film_grain_bit_depth_chroma_minus8,
sps->bit_depth_chroma_minus8);
2087 infer(film_grain_full_range_flag,
sps->vui.video_full_range_flag);
2088 infer(film_grain_colour_primaries,
sps->vui.colour_primaries);
2089 infer(film_grain_transfer_characteristics,
sps->vui.transfer_characteristics);
2090 infer(film_grain_matrix_coeffs,
sps->vui.matrix_coefficients);
2091 }
2092
2094 filmGrainBitDepth[1] =
2096
2097 u(2, blending_mode_id, 0, 1);
2098 ub(4, log2_scale_factor);
2099 for (
c = 0;
c < 3;
c++)
2100 flags(comp_model_present_flag[
c], 1,
c);
2101 for (
c = 0;
c < 3;
c++) {
2103 ubs(8, num_intensity_intervals_minus1[
c], 1,
c);
2104 us(3, num_model_values_minus1[
c], 0, 5, 1,
c);
2106 ubs(8, intensity_interval_lower_bound[
c][
i], 2,
c,
i);
2107 ubs(8, intensity_interval_upper_bound[
c][
i], 2,
c,
i);
2110 ((1 << filmGrainBitDepth[
c]) - 1) - current->
film_grain_model_id * (1 << (filmGrainBitDepth[
c] - 1)),
2112 }
2113 }
2114 }
2115 flag(film_grain_characteristics_persistence_flag);
2116 }
2117
2118 return 0;
2119 }
2120
2124 {
2125 int err;
2126
2127 HEADER(
"Display Orientation");
2128
2129 flag(display_orientation_cancel_flag);
2133 ub(16, anticlockwise_rotation);
2134 flag(display_orientation_persistence_flag);
2135 }
2136
2137 return 0;
2138 }
2139
2143 {
2147
2148 HEADER(
"Active Parameter Sets");
2149
2156 }
2158
2159 flag(self_contained_cvs_flag);
2160 flag(no_parameter_set_update_flag);
2161
2165
2166 for (
i =
vps->vps_base_layer_internal_flag;
2167 i <=
FFMIN(62,
vps->vps_max_layers_minus1);
i++) {
2169
2172 }
2173
2174 return 0;
2175 }
2176
2180 {
2184
2185 HEADER(
"Decoded Picture Hash");
2186
2189 "No active SPS for decoded picture hash.\n");
2191 }
2192
2193 u(8, hash_type, 0, 2);
2194
2195 for (
c = 0;
c < (
sps->chroma_format_idc == 0 ? 1 : 3);
c++) {
2197 for (
i = 0;
i < 16;
i++)
2198 us(8, picture_md5[
c][
i], 0x00, 0xff, 2,
c,
i);
2200 us(16, picture_crc[
c], 0x0000, 0xffff, 1,
c);
2202 us(32, picture_checksum[
c], 0x00000000, 0xffffffff, 1,
c);
2203 }
2204 }
2205
2206 return 0;
2207 }
2208
2211 {
2213
2215
2216 u(2, num_clock_ts, 1, 3);
2217
2219 flags(clock_timestamp_flag[
i], 1,
i);
2220
2222 flags(units_field_based_flag[
i], 1,
i);
2223 us(5, counting_type[
i], 0, 6, 1,
i);
2224 flags(full_timestamp_flag[
i], 1,
i);
2225 flags(discontinuity_flag[
i], 1,
i);
2226 flags(cnt_dropped_flag[
i], 1,
i);
2227
2228 ubs(9, n_frames[
i], 1,
i);
2229
2231 us(6, seconds_value[
i], 0, 59, 1,
i);
2232 us(6, minutes_value[
i], 0, 59, 1,
i);
2233 us(5, hours_value[
i], 0, 23, 1,
i);
2234 } else {
2237 us(6, seconds_value[
i], 0, 59, 1,
i);
2240 us(6, minutes_value[
i], 0, 59, 1,
i);
2243 us(5, hours_value[
i], 0, 23, 1,
i);
2244 }
2245 }
2246 }
2247
2248 ubs(5, time_offset_length[
i], 1,
i);
2251 else
2252 infer(time_offset_value[
i], 0);
2253 }
2254 }
2255
2256 return 0;
2257 }
2258
2262 {
2263 int err, length;
2264
2265 HEADER(
"Alpha Channel Information");
2266
2267 flag(alpha_channel_cancel_flag);
2269 ub(3, alpha_channel_use_idc);
2270 ub(3, alpha_channel_bit_depth_minus8);
2272 ub(length, alpha_transparent_value);
2273 ub(length, alpha_opaque_value);
2274 flag(alpha_channel_incr_flag);
2275 flag(alpha_channel_clip_flag);
2277 flag(alpha_channel_clip_type_flag);
2278 } else {
2279 infer(alpha_channel_use_idc, 2);
2280 infer(alpha_channel_incr_flag, 0);
2281 infer(alpha_channel_clip_flag, 0);
2282 }
2283
2284 return 0;
2285 }
2286
2290 {
2291 int length;
2293
2294 HEADER(
"Three Dimensional Reference Displays Information");
2295
2296 ue(prec_ref_display_width, 0, 31);
2297 flag(ref_viewing_distance_flag);
2299 ue(prec_ref_viewing_dist, 0, 31);
2300 ue(num_ref_displays_minus1, 0, 31);
2304 us(6, exponent_ref_display_width[
i], 0, 62, 1,
i);
2307 else
2310
2311 if (length > 32) {
2314 }
2315
2316 if (length)
2317 ubs(length, mantissa_ref_display_width[
i], 1,
i);
2318 else
2319 infer(mantissa_ref_display_width[
i], 0);
2321 us(6, exponent_ref_viewing_distance[
i], 0, 62, 1,
i);
2324 else
2327
2328 if (length > 32) {
2331 }
2332
2333 if (length)
2334 ubs(length, mantissa_ref_viewing_distance[
i], 1,
i);
2335 else
2336 infer(mantissa_ref_viewing_distance[
i], 0);
2337 }
2338 flags(additional_shift_present_flag[
i], 1,
i);
2340 us(10, num_sample_shift_plus512[
i], 0, 1023, 1,
i);
2341 }
2342 flag(three_dimensional_reference_displays_extension_flag);
2343
2344 return 0;
2345 }
2346
2349 {
2350 int err;
2351
2352 if (prefix)
2353 HEADER(
"Prefix Supplemental Enhancement Information");
2354 else
2355 HEADER(
"Suffix Supplemental Enhancement Information");
2356
2360
2362
2364
2365 return 0;
2366 }
2367
2368
2371 {
2372 int err;
2373
2375
2378
2379 #ifdef READ
2381 fixed(8, ff_byte, 0xff);
2382 ++current->filler_size;
2383 }
2384 #else
2385 {
2387 for (
i = 0;
i < current->filler_size;
i++)
2388 fixed(8, ff_byte, 0xff);
2389 }
2390 #endif
2391
2393
2394 return 0;
2395 }