FFmpeg
cbs_h265_syntax_template.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
20 {
21  int err;
22 
23  fixed(1, rbsp_stop_one_bit, 1);
24  while (byte_alignment(rw) != 0)
25  fixed(1, rbsp_alignment_zero_bit, 0);
26 
27  return 0;
28 }
29 
31  H265RawNALUnitHeader *current,
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
42  ub(6, nal_unit_type);
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);
55  while (byte_alignment(rw) != 0)
56  fixed(1, alignment_bit_equal_to_zero, 0);
57 
58  return 0;
59 }
60 
62  H265RawPSExtensionData *current)
63 {
64  int err;
65  size_t k;
66 #ifdef READ
68  uint8_t bit;
69  start = *rw;
70  for (k = 0; cbs_h2645_read_more_rbsp_data(rw); k++)
71  skip_bits(rw, 1);
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++) {
77  xu(1, extension_data, bit, 0, 1, 0);
78  current->data[k / 8] |= bit << (7 - k % 8);
79  }
80  }
81 #else
82  for (k = 0; k < current->bit_length; k++)
83  xu(1, extension_data, current->data[k / 8] >> (7 - k % 8) & 1, 0, 1, 0);
84 #endif
85  return 0;
86 }
87 
89  H265RawProfileTierLevel *current,
90  int profile_present_flag,
91  int max_num_sub_layers_minus1)
92 {
93  int err, i, j;
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])
110  if (profile_compatible(4) || profile_compatible(5) ||
113  profile_compatible(10)) {
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 
124  if (profile_compatible(5) || profile_compatible(9) ||
125  profile_compatible(10)) {
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  }
133  } else if (profile_compatible(2)) {
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 
143  if (profile_compatible(1) || profile_compatible(2) ||
146  flag(general_inbld_flag);
147  } else {
148  fixed(1, general_reserved_zero_bit, 0);
149  }
150 #undef profile_compatible
151  }
152 
153  ub(8, general_level_idc);
154 
155  for (i = 0; i < max_num_sub_layers_minus1; i++) {
156  flags(sub_layer_profile_present_flag[i], 1, i);
157  flags(sub_layer_level_present_flag[i], 1, i);
158  }
159 
160  if (max_num_sub_layers_minus1 > 0) {
161  for (i = max_num_sub_layers_minus1; i < 8; i++)
162  fixed(2, reserved_zero_2bits, 0);
163  }
164 
165  for (i = 0; i < max_num_sub_layers_minus1; i++) {
166  if (current->sub_layer_profile_present_flag[i]) {
167  us(2, sub_layer_profile_space[i], 0, 0, 1, i);
168  flags(sub_layer_tier_flag[i], 1, i);
169  ubs(5, sub_layer_profile_idc[i], 1, i);
170 
171  for (j = 0; j < 32; j++)
172  flags(sub_layer_profile_compatibility_flag[i][j], 2, i, j);
173 
174  flags(sub_layer_progressive_source_flag[i], 1, i);
175  flags(sub_layer_interlaced_source_flag[i], 1, i);
176  flags(sub_layer_non_packed_constraint_flag[i], 1, i);
177  flags(sub_layer_frame_only_constraint_flag[i], 1, i);
178 
179 #define profile_compatible(x) (current->sub_layer_profile_idc[i] == (x) || \
180  current->sub_layer_profile_compatibility_flag[i][x])
181  if (profile_compatible(4) || profile_compatible(5) ||
184  profile_compatible(10)) {
185  flags(sub_layer_max_12bit_constraint_flag[i], 1, i);
186  flags(sub_layer_max_10bit_constraint_flag[i], 1, i);
187  flags(sub_layer_max_8bit_constraint_flag[i], 1, i);
188  flags(sub_layer_max_422chroma_constraint_flag[i], 1, i);
189  flags(sub_layer_max_420chroma_constraint_flag[i], 1, i);
190  flags(sub_layer_max_monochrome_constraint_flag[i], 1, i);
191  flags(sub_layer_intra_constraint_flag[i], 1, i);
192  flags(sub_layer_one_picture_only_constraint_flag[i], 1, i);
193  flags(sub_layer_lower_bit_rate_constraint_flag[i], 1, i);
194 
195  if (profile_compatible(5)) {
196  flags(sub_layer_max_14bit_constraint_flag[i], 1, i);
197  fixed(24, sub_layer_reserved_zero_33bits, 0);
198  fixed( 9, sub_layer_reserved_zero_33bits, 0);
199  } else {
200  fixed(24, sub_layer_reserved_zero_34bits, 0);
201  fixed(10, sub_layer_reserved_zero_34bits, 0);
202  }
203  } else if (profile_compatible(2)) {
204  fixed(7, sub_layer_reserved_zero_7bits, 0);
205  flags(sub_layer_one_picture_only_constraint_flag[i], 1, i);
206  fixed(24, sub_layer_reserved_zero_43bits, 0);
207  fixed(11, sub_layer_reserved_zero_43bits, 0);
208  } else {
209  fixed(24, sub_layer_reserved_zero_43bits, 0);
210  fixed(19, sub_layer_reserved_zero_43bits, 0);
211  }
212 
213  if (profile_compatible(1) || profile_compatible(2) ||
216  flags(sub_layer_inbld_flag[i], 1, i);
217  } else {
218  fixed(1, sub_layer_reserved_zero_bit, 0);
219  }
220 #undef profile_compatible
221  }
222  if (current->sub_layer_level_present_flag[i])
223  ubs(8, sub_layer_level_idc[i], 1, i);
224  }
225 
226  return 0;
227 }
228 
231  int nal, int sub_layer_id)
232 {
234  int err, i;
235 
236  if (nal)
237  current = &hrd->nal_sub_layer_hrd_parameters[sub_layer_id];
238  else
239  current = &hrd->vcl_sub_layer_hrd_parameters[sub_layer_id];
240 
241  for (i = 0; i <= hrd->cpb_cnt_minus1[sub_layer_id]; i++) {
242  ues(bit_rate_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
243  ues(cpb_size_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
244  if (hrd->sub_pic_hrd_params_present_flag) {
245  ues(cpb_size_du_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
246  ues(bit_rate_du_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
247  }
248  flags(cbr_flag[i], 1, i);
249  }
250 
251  return 0;
252 }
253 
255  H265RawHRDParameters *current, int common_inf_present_flag,
256  int max_num_sub_layers_minus1)
257 {
258  int err, i;
259 
260  if (common_inf_present_flag) {
261  flag(nal_hrd_parameters_present_flag);
262  flag(vcl_hrd_parameters_present_flag);
263 
264  if (current->nal_hrd_parameters_present_flag ||
265  current->vcl_hrd_parameters_present_flag) {
266  flag(sub_pic_hrd_params_present_flag);
267  if (current->sub_pic_hrd_params_present_flag) {
268  ub(8, tick_divisor_minus2);
269  ub(5, du_cpb_removal_delay_increment_length_minus1);
270  flag(sub_pic_cpb_params_in_pic_timing_sei_flag);
271  ub(5, dpb_output_delay_du_length_minus1);
272  }
273 
274  ub(4, bit_rate_scale);
275  ub(4, cpb_size_scale);
276  if (current->sub_pic_hrd_params_present_flag)
277  ub(4, cpb_size_du_scale);
278 
279  ub(5, initial_cpb_removal_delay_length_minus1);
280  ub(5, au_cpb_removal_delay_length_minus1);
281  ub(5, dpb_output_delay_length_minus1);
282  } else {
283  infer(sub_pic_hrd_params_present_flag, 0);
284 
285  infer(initial_cpb_removal_delay_length_minus1, 23);
286  infer(au_cpb_removal_delay_length_minus1, 23);
287  infer(dpb_output_delay_length_minus1, 23);
288  }
289  }
290 
291  for (i = 0; i <= max_num_sub_layers_minus1; i++) {
292  flags(fixed_pic_rate_general_flag[i], 1, i);
293 
294  if (!current->fixed_pic_rate_general_flag[i])
295  flags(fixed_pic_rate_within_cvs_flag[i], 1, i);
296  else
297  infer(fixed_pic_rate_within_cvs_flag[i], 1);
298 
299  if (current->fixed_pic_rate_within_cvs_flag[i]) {
300  ues(elemental_duration_in_tc_minus1[i], 0, 2047, 1, i);
301  infer(low_delay_hrd_flag[i], 0);
302  } else
303  flags(low_delay_hrd_flag[i], 1, i);
304 
305  if (!current->low_delay_hrd_flag[i])
306  ues(cpb_cnt_minus1[i], 0, 31, 1, i);
307  else
308  infer(cpb_cnt_minus1[i], 0);
309 
310  if (current->nal_hrd_parameters_present_flag)
311  CHECK(FUNC(sub_layer_hrd_parameters)(ctx, rw, current, 0, i));
312  if (current->vcl_hrd_parameters_present_flag)
313  CHECK(FUNC(sub_layer_hrd_parameters)(ctx, rw, current, 1, i));
314  }
315 
316  return 0;
317 }
318 
320  H265RawVUI *current, const H265RawSPS *sps)
321 {
322  int err;
323 
324  flag(aspect_ratio_info_present_flag);
325  if (current->aspect_ratio_info_present_flag) {
326  ub(8, aspect_ratio_idc);
327  if (current->aspect_ratio_idc == 255) {
328  ub(16, sar_width);
329  ub(16, sar_height);
330  }
331  } else {
332  infer(aspect_ratio_idc, 0);
333  }
334 
335  flag(overscan_info_present_flag);
336  if (current->overscan_info_present_flag)
337  flag(overscan_appropriate_flag);
338 
339  flag(video_signal_type_present_flag);
340  if (current->video_signal_type_present_flag) {
341  ub(3, video_format);
342  flag(video_full_range_flag);
343  flag(colour_description_present_flag);
344  if (current->colour_description_present_flag) {
345  ub(8, colour_primaries);
347  ub(8, matrix_coefficients);
348  } else {
349  infer(colour_primaries, 2);
351  infer(matrix_coefficients, 2);
352  }
353  } else {
354  infer(video_format, 5);
355  infer(video_full_range_flag, 0);
356  infer(colour_primaries, 2);
358  infer(matrix_coefficients, 2);
359  }
360 
361  flag(chroma_loc_info_present_flag);
362  if (current->chroma_loc_info_present_flag) {
363  ue(chroma_sample_loc_type_top_field, 0, 5);
364  ue(chroma_sample_loc_type_bottom_field, 0, 5);
365  } else {
366  infer(chroma_sample_loc_type_top_field, 0);
367  infer(chroma_sample_loc_type_bottom_field, 0);
368  }
369 
370  flag(neutral_chroma_indication_flag);
371  flag(field_seq_flag);
372  flag(frame_field_info_present_flag);
373 
374  flag(default_display_window_flag);
375  if (current->default_display_window_flag) {
376  ue(def_disp_win_left_offset, 0, 16384);
377  ue(def_disp_win_right_offset, 0, 16384);
378  ue(def_disp_win_top_offset, 0, 16384);
379  ue(def_disp_win_bottom_offset, 0, 16384);
380  }
381 
382  flag(vui_timing_info_present_flag);
383  if (current->vui_timing_info_present_flag) {
384  u(32, vui_num_units_in_tick, 1, UINT32_MAX);
385  u(32, vui_time_scale, 1, UINT32_MAX);
386  flag(vui_poc_proportional_to_timing_flag);
387  if (current->vui_poc_proportional_to_timing_flag)
388  ue(vui_num_ticks_poc_diff_one_minus1, 0, UINT32_MAX - 1);
389 
390  flag(vui_hrd_parameters_present_flag);
391  if (current->vui_hrd_parameters_present_flag) {
392  CHECK(FUNC(hrd_parameters)(ctx, rw, &current->hrd_parameters,
393  1, sps->sps_max_sub_layers_minus1));
394  }
395  }
396 
397  flag(bitstream_restriction_flag);
398  if (current->bitstream_restriction_flag) {
399  flag(tiles_fixed_structure_flag);
400  flag(motion_vectors_over_pic_boundaries_flag);
401  flag(restricted_ref_pic_lists_flag);
402  ue(min_spatial_segmentation_idc, 0, 4095);
403  ue(max_bytes_per_pic_denom, 0, 16);
404  ue(max_bits_per_min_cu_denom, 0, 16);
405  ue(log2_max_mv_length_horizontal, 0, 16);
406  ue(log2_max_mv_length_vertical, 0, 16);
407  } else {
408  infer(tiles_fixed_structure_flag, 0);
409  infer(motion_vectors_over_pic_boundaries_flag, 1);
410  infer(min_spatial_segmentation_idc, 0);
411  infer(max_bytes_per_pic_denom, 2);
412  infer(max_bits_per_min_cu_denom, 1);
413  infer(log2_max_mv_length_horizontal, 15);
414  infer(log2_max_mv_length_vertical, 15);
415  }
416 
417  return 0;
418 }
419 
421  H265RawVPS *current)
422 {
423  int err, i, j;
424 
425  HEADER("Video Parameter Set");
426 
427  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_VPS));
428 
429  ub(4, vps_video_parameter_set_id);
430 
431  flag(vps_base_layer_internal_flag);
432  flag(vps_base_layer_available_flag);
433  u(6, vps_max_layers_minus1, 0, HEVC_MAX_LAYERS - 1);
434  u(3, vps_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS - 1);
435  flag(vps_temporal_id_nesting_flag);
436 
437  if (current->vps_max_sub_layers_minus1 == 0 &&
438  current->vps_temporal_id_nesting_flag != 1) {
439  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
440  "vps_temporal_id_nesting_flag must be 1 if "
441  "vps_max_sub_layers_minus1 is 0.\n");
442  return AVERROR_INVALIDDATA;
443  }
444 
445  fixed(16, vps_reserved_0xffff_16bits, 0xffff);
446 
447  CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
448  1, current->vps_max_sub_layers_minus1));
449 
450  flag(vps_sub_layer_ordering_info_present_flag);
451  for (i = (current->vps_sub_layer_ordering_info_present_flag ?
452  0 : current->vps_max_sub_layers_minus1);
453  i <= current->vps_max_sub_layers_minus1; i++) {
454  ues(vps_max_dec_pic_buffering_minus1[i],
455  0, HEVC_MAX_DPB_SIZE - 1, 1, i);
456  ues(vps_max_num_reorder_pics[i],
457  0, current->vps_max_dec_pic_buffering_minus1[i], 1, i);
458  ues(vps_max_latency_increase_plus1[i],
459  0, UINT32_MAX - 1, 1, i);
460  }
461  if (!current->vps_sub_layer_ordering_info_present_flag) {
462  for (i = 0; i < current->vps_max_sub_layers_minus1; i++) {
463  infer(vps_max_dec_pic_buffering_minus1[i],
464  current->vps_max_dec_pic_buffering_minus1[current->vps_max_sub_layers_minus1]);
465  infer(vps_max_num_reorder_pics[i],
466  current->vps_max_num_reorder_pics[current->vps_max_sub_layers_minus1]);
467  infer(vps_max_latency_increase_plus1[i],
468  current->vps_max_latency_increase_plus1[current->vps_max_sub_layers_minus1]);
469  }
470  }
471 
472  u(6, vps_max_layer_id, 0, HEVC_MAX_LAYERS - 1);
473  ue(vps_num_layer_sets_minus1, 0, HEVC_MAX_LAYER_SETS - 1);
474  for (i = 1; i <= current->vps_num_layer_sets_minus1; i++) {
475  for (j = 0; j <= current->vps_max_layer_id; j++)
476  flags(layer_id_included_flag[i][j], 2, i, j);
477  }
478  for (j = 0; j <= current->vps_max_layer_id; j++)
479  infer(layer_id_included_flag[0][j], j == 0);
480 
481  flag(vps_timing_info_present_flag);
482  if (current->vps_timing_info_present_flag) {
483  u(32, vps_num_units_in_tick, 1, UINT32_MAX);
484  u(32, vps_time_scale, 1, UINT32_MAX);
485  flag(vps_poc_proportional_to_timing_flag);
486  if (current->vps_poc_proportional_to_timing_flag)
487  ue(vps_num_ticks_poc_diff_one_minus1, 0, UINT32_MAX - 1);
488  ue(vps_num_hrd_parameters, 0, current->vps_num_layer_sets_minus1 + 1);
489  for (i = 0; i < current->vps_num_hrd_parameters; i++) {
490  ues(hrd_layer_set_idx[i],
491  current->vps_base_layer_internal_flag ? 0 : 1,
492  current->vps_num_layer_sets_minus1, 1, i);
493  if (i > 0)
494  flags(cprms_present_flag[i], 1, i);
495  else
496  infer(cprms_present_flag[0], 1);
497 
498  CHECK(FUNC(hrd_parameters)(ctx, rw, &current->hrd_parameters[i],
499  current->cprms_present_flag[i],
500  current->vps_max_sub_layers_minus1));
501  }
502  }
503 
504  flag(vps_extension_flag);
505  if (current->vps_extension_flag)
506  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
507 
509 
510  return 0;
511 }
512 
514  H265RawSTRefPicSet *current, int st_rps_idx,
515  const H265RawSPS *sps)
516 {
517  int err, i, j;
518 
519  if (st_rps_idx != 0)
520  flag(inter_ref_pic_set_prediction_flag);
521  else
522  infer(inter_ref_pic_set_prediction_flag, 0);
523 
524  if (current->inter_ref_pic_set_prediction_flag) {
525  unsigned int ref_rps_idx, num_delta_pocs;
526  const H265RawSTRefPicSet *ref;
527  int delta_rps, d_poc;
528  int ref_delta_poc_s0[HEVC_MAX_REFS], ref_delta_poc_s1[HEVC_MAX_REFS];
529  int delta_poc_s0[HEVC_MAX_REFS], delta_poc_s1[HEVC_MAX_REFS];
530  uint8_t used_by_curr_pic_s0[HEVC_MAX_REFS],
531  used_by_curr_pic_s1[HEVC_MAX_REFS];
532 
533  if (st_rps_idx == sps->num_short_term_ref_pic_sets)
534  ue(delta_idx_minus1, 0, st_rps_idx - 1);
535  else
536  infer(delta_idx_minus1, 0);
537 
538  ref_rps_idx = st_rps_idx - (current->delta_idx_minus1 + 1);
539  ref = &sps->st_ref_pic_set[ref_rps_idx];
540  num_delta_pocs = ref->num_negative_pics + ref->num_positive_pics;
541 
542  flag(delta_rps_sign);
543  ue(abs_delta_rps_minus1, 0, INT16_MAX);
544  delta_rps = (1 - 2 * current->delta_rps_sign) *
545  (current->abs_delta_rps_minus1 + 1);
546 
547  for (j = 0; j <= num_delta_pocs; j++) {
548  flags(used_by_curr_pic_flag[j], 1, j);
549  if (!current->used_by_curr_pic_flag[j])
550  flags(use_delta_flag[j], 1, j);
551  else
552  infer(use_delta_flag[j], 1);
553  }
554 
555  // Since the stored form of an RPS here is actually the delta-step
556  // form used when inter_ref_pic_set_prediction_flag is not set, we
557  // need to reconstruct that here in order to be able to refer to
558  // the RPS later (which is required for parsing, because we don't
559  // even know what syntax elements appear without it). Therefore,
560  // this code takes the delta-step form of the reference set, turns
561  // it into the delta-array form, applies the prediction process of
562  // 7.4.8, converts the result back to the delta-step form, and
563  // stores that as the current set for future use. Note that the
564  // inferences here mean that writers using prediction will need
565  // to fill in the delta-step values correctly as well - since the
566  // whole RPS prediction process is somewhat overly sophisticated,
567  // this hopefully forms a useful check for them to ensure their
568  // predicted form actually matches what was intended rather than
569  // an onerous additional requirement.
570 
571  d_poc = 0;
572  for (i = 0; i < ref->num_negative_pics; i++) {
573  d_poc -= ref->delta_poc_s0_minus1[i] + 1;
574  ref_delta_poc_s0[i] = d_poc;
575  }
576  d_poc = 0;
577  for (i = 0; i < ref->num_positive_pics; i++) {
578  d_poc += ref->delta_poc_s1_minus1[i] + 1;
579  ref_delta_poc_s1[i] = d_poc;
580  }
581 
582  i = 0;
583  for (j = ref->num_positive_pics - 1; j >= 0; j--) {
584  d_poc = ref_delta_poc_s1[j] + delta_rps;
585  if (d_poc < 0 && current->use_delta_flag[ref->num_negative_pics + j]) {
586  delta_poc_s0[i] = d_poc;
587  used_by_curr_pic_s0[i++] =
588  current->used_by_curr_pic_flag[ref->num_negative_pics + j];
589  }
590  }
591  if (delta_rps < 0 && current->use_delta_flag[num_delta_pocs]) {
592  delta_poc_s0[i] = delta_rps;
593  used_by_curr_pic_s0[i++] =
594  current->used_by_curr_pic_flag[num_delta_pocs];
595  }
596  for (j = 0; j < ref->num_negative_pics; j++) {
597  d_poc = ref_delta_poc_s0[j] + delta_rps;
598  if (d_poc < 0 && current->use_delta_flag[j]) {
599  delta_poc_s0[i] = d_poc;
600  used_by_curr_pic_s0[i++] = current->used_by_curr_pic_flag[j];
601  }
602  }
603 
604  if (i > 15)
605  return AVERROR_INVALIDDATA;
606  infer(num_negative_pics, i);
607  for (i = 0; i < current->num_negative_pics; i++) {
608  infer(delta_poc_s0_minus1[i],
609  -(delta_poc_s0[i] - (i == 0 ? 0 : delta_poc_s0[i - 1])) - 1);
610  infer(used_by_curr_pic_s0_flag[i], used_by_curr_pic_s0[i]);
611  }
612 
613  i = 0;
614  for (j = ref->num_negative_pics - 1; j >= 0; j--) {
615  d_poc = ref_delta_poc_s0[j] + delta_rps;
616  if (d_poc > 0 && current->use_delta_flag[j]) {
617  delta_poc_s1[i] = d_poc;
618  used_by_curr_pic_s1[i++] = current->used_by_curr_pic_flag[j];
619  }
620  }
621  if (delta_rps > 0 && current->use_delta_flag[num_delta_pocs]) {
622  delta_poc_s1[i] = delta_rps;
623  used_by_curr_pic_s1[i++] =
624  current->used_by_curr_pic_flag[num_delta_pocs];
625  }
626  for (j = 0; j < ref->num_positive_pics; j++) {
627  d_poc = ref_delta_poc_s1[j] + delta_rps;
628  if (d_poc > 0 && current->use_delta_flag[ref->num_negative_pics + j]) {
629  delta_poc_s1[i] = d_poc;
630  used_by_curr_pic_s1[i++] =
631  current->used_by_curr_pic_flag[ref->num_negative_pics + j];
632  }
633  }
634 
635  if (i + current->num_negative_pics > 15)
636  return AVERROR_INVALIDDATA;
637  infer(num_positive_pics, i);
638  for (i = 0; i < current->num_positive_pics; i++) {
639  infer(delta_poc_s1_minus1[i],
640  delta_poc_s1[i] - (i == 0 ? 0 : delta_poc_s1[i - 1]) - 1);
641  infer(used_by_curr_pic_s1_flag[i], used_by_curr_pic_s1[i]);
642  }
643 
644  } else {
645  ue(num_negative_pics, 0, 15);
646  ue(num_positive_pics, 0, 15 - current->num_negative_pics);
647 
648  for (i = 0; i < current->num_negative_pics; i++) {
649  ues(delta_poc_s0_minus1[i], 0, INT16_MAX, 1, i);
650  flags(used_by_curr_pic_s0_flag[i], 1, i);
651  }
652 
653  for (i = 0; i < current->num_positive_pics; i++) {
654  ues(delta_poc_s1_minus1[i], 0, INT16_MAX, 1, i);
655  flags(used_by_curr_pic_s1_flag[i], 1, i);
656  }
657  }
658 
659  return 0;
660 }
661 
663  H265RawScalingList *current)
664 {
665  int sizeId, matrixId;
666  int err, n, i;
667 
668  for (sizeId = 0; sizeId < 4; sizeId++) {
669  for (matrixId = 0; matrixId < 6; matrixId += (sizeId == 3 ? 3 : 1)) {
670  flags(scaling_list_pred_mode_flag[sizeId][matrixId],
671  2, sizeId, matrixId);
672  if (!current->scaling_list_pred_mode_flag[sizeId][matrixId]) {
673  ues(scaling_list_pred_matrix_id_delta[sizeId][matrixId],
674  0, sizeId == 3 ? matrixId / 3 : matrixId,
675  2, sizeId, matrixId);
676  } else {
677  n = FFMIN(64, 1 << (4 + (sizeId << 1)));
678  if (sizeId > 1) {
679  ses(scaling_list_dc_coef_minus8[sizeId - 2][matrixId], -7, +247,
680  2, sizeId - 2, matrixId);
681  }
682  for (i = 0; i < n; i++) {
683  ses(scaling_list_delta_coeff[sizeId][matrixId][i],
684  -128, +127, 3, sizeId, matrixId, i);
685  }
686  }
687  }
688  }
689 
690  return 0;
691 }
692 
694  H265RawSPS *current)
695 {
696  int err;
697 
698  flag(transform_skip_rotation_enabled_flag);
699  flag(transform_skip_context_enabled_flag);
700  flag(implicit_rdpcm_enabled_flag);
701  flag(explicit_rdpcm_enabled_flag);
702  flag(extended_precision_processing_flag);
703  flag(intra_smoothing_disabled_flag);
704  flag(high_precision_offsets_enabled_flag);
705  flag(persistent_rice_adaptation_enabled_flag);
706  flag(cabac_bypass_alignment_enabled_flag);
707 
708  return 0;
709 }
710 
712  H265RawSPS *current)
713 {
714  int err, comp, i;
715 
716  flag(sps_curr_pic_ref_enabled_flag);
717 
718  flag(palette_mode_enabled_flag);
719  if (current->palette_mode_enabled_flag) {
720  ue(palette_max_size, 0, 64);
721  ue(delta_palette_max_predictor_size, 0, 128);
722 
723  flag(sps_palette_predictor_initializer_present_flag);
724  if (current->sps_palette_predictor_initializer_present_flag) {
725  ue(sps_num_palette_predictor_initializer_minus1, 0, 127);
726  for (comp = 0; comp < (current->chroma_format_idc ? 3 : 1); comp++) {
727  int bit_depth = comp == 0 ? current->bit_depth_luma_minus8 + 8
728  : current->bit_depth_chroma_minus8 + 8;
729  for (i = 0; i <= current->sps_num_palette_predictor_initializer_minus1; i++)
730  ubs(bit_depth, sps_palette_predictor_initializers[comp][i], 2, comp, i);
731  }
732  }
733  }
734 
735  u(2, motion_vector_resolution_control_idc, 0, 2);
736  flag(intra_boundary_filtering_disable_flag);
737 
738  return 0;
739 }
740 
742  H265RawSPS *current)
743 {
745  const H265RawVPS *vps;
746  int err, i;
747  unsigned int min_cb_log2_size_y, ctb_log2_size_y,
748  min_cb_size_y, min_tb_log2_size_y;
749 
750  HEADER("Sequence Parameter Set");
751 
752  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_SPS));
753 
754  ub(4, sps_video_parameter_set_id);
755  h265->active_vps = vps = h265->vps[current->sps_video_parameter_set_id];
756 
757  u(3, sps_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS - 1);
758  flag(sps_temporal_id_nesting_flag);
759  if (vps) {
760  if (vps->vps_max_sub_layers_minus1 > current->sps_max_sub_layers_minus1) {
761  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
762  "sps_max_sub_layers_minus1 (%d) must be less than or equal to "
763  "vps_max_sub_layers_minus1 (%d).\n",
764  vps->vps_max_sub_layers_minus1,
765  current->sps_max_sub_layers_minus1);
766  return AVERROR_INVALIDDATA;
767  }
768  if (vps->vps_temporal_id_nesting_flag &&
769  !current->sps_temporal_id_nesting_flag) {
770  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
771  "sps_temporal_id_nesting_flag must be 1 if "
772  "vps_temporal_id_nesting_flag is 1.\n");
773  return AVERROR_INVALIDDATA;
774  }
775  }
776 
777  CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
778  1, current->sps_max_sub_layers_minus1));
779 
780  ue(sps_seq_parameter_set_id, 0, 15);
781 
782  ue(chroma_format_idc, 0, 3);
783  if (current->chroma_format_idc == 3)
784  flag(separate_colour_plane_flag);
785  else
786  infer(separate_colour_plane_flag, 0);
787 
788  ue(pic_width_in_luma_samples, 1, HEVC_MAX_WIDTH);
789  ue(pic_height_in_luma_samples, 1, HEVC_MAX_HEIGHT);
790 
791  flag(conformance_window_flag);
792  if (current->conformance_window_flag) {
793  ue(conf_win_left_offset, 0, current->pic_width_in_luma_samples);
794  ue(conf_win_right_offset, 0, current->pic_width_in_luma_samples);
795  ue(conf_win_top_offset, 0, current->pic_height_in_luma_samples);
796  ue(conf_win_bottom_offset, 0, current->pic_height_in_luma_samples);
797  } else {
798  infer(conf_win_left_offset, 0);
799  infer(conf_win_right_offset, 0);
800  infer(conf_win_top_offset, 0);
801  infer(conf_win_bottom_offset, 0);
802  }
803 
804  ue(bit_depth_luma_minus8, 0, 8);
805  ue(bit_depth_chroma_minus8, 0, 8);
806 
807  ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
808 
809  flag(sps_sub_layer_ordering_info_present_flag);
810  for (i = (current->sps_sub_layer_ordering_info_present_flag ?
811  0 : current->sps_max_sub_layers_minus1);
812  i <= current->sps_max_sub_layers_minus1; i++) {
813  ues(sps_max_dec_pic_buffering_minus1[i],
814  0, HEVC_MAX_DPB_SIZE - 1, 1, i);
815  ues(sps_max_num_reorder_pics[i],
816  0, current->sps_max_dec_pic_buffering_minus1[i], 1, i);
817  ues(sps_max_latency_increase_plus1[i],
818  0, UINT32_MAX - 1, 1, i);
819  }
820  if (!current->sps_sub_layer_ordering_info_present_flag) {
821  for (i = 0; i < current->sps_max_sub_layers_minus1; i++) {
822  infer(sps_max_dec_pic_buffering_minus1[i],
823  current->sps_max_dec_pic_buffering_minus1[current->sps_max_sub_layers_minus1]);
824  infer(sps_max_num_reorder_pics[i],
825  current->sps_max_num_reorder_pics[current->sps_max_sub_layers_minus1]);
826  infer(sps_max_latency_increase_plus1[i],
827  current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
828  }
829  }
830 
831  ue(log2_min_luma_coding_block_size_minus3, 0, 3);
832  min_cb_log2_size_y = current->log2_min_luma_coding_block_size_minus3 + 3;
833 
834  ue(log2_diff_max_min_luma_coding_block_size, 0, 3);
835  ctb_log2_size_y = min_cb_log2_size_y +
836  current->log2_diff_max_min_luma_coding_block_size;
837 
838  min_cb_size_y = 1 << min_cb_log2_size_y;
839  if (current->pic_width_in_luma_samples % min_cb_size_y ||
840  current->pic_height_in_luma_samples % min_cb_size_y) {
841  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid dimensions: %ux%u not divisible "
842  "by MinCbSizeY = %u.\n", current->pic_width_in_luma_samples,
843  current->pic_height_in_luma_samples, min_cb_size_y);
844  return AVERROR_INVALIDDATA;
845  }
846 
847  ue(log2_min_luma_transform_block_size_minus2, 0, min_cb_log2_size_y - 3);
848  min_tb_log2_size_y = current->log2_min_luma_transform_block_size_minus2 + 2;
849 
850  ue(log2_diff_max_min_luma_transform_block_size,
851  0, FFMIN(ctb_log2_size_y, 5) - min_tb_log2_size_y);
852 
853  ue(max_transform_hierarchy_depth_inter,
854  0, ctb_log2_size_y - min_tb_log2_size_y);
855  ue(max_transform_hierarchy_depth_intra,
856  0, ctb_log2_size_y - min_tb_log2_size_y);
857 
858  flag(scaling_list_enabled_flag);
859  if (current->scaling_list_enabled_flag) {
860  flag(sps_scaling_list_data_present_flag);
861  if (current->sps_scaling_list_data_present_flag)
862  CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
863  } else {
864  infer(sps_scaling_list_data_present_flag, 0);
865  }
866 
867  flag(amp_enabled_flag);
868  flag(sample_adaptive_offset_enabled_flag);
869 
870  flag(pcm_enabled_flag);
871  if (current->pcm_enabled_flag) {
872  u(4, pcm_sample_bit_depth_luma_minus1,
873  0, current->bit_depth_luma_minus8 + 8 - 1);
874  u(4, pcm_sample_bit_depth_chroma_minus1,
875  0, current->bit_depth_chroma_minus8 + 8 - 1);
876 
877  ue(log2_min_pcm_luma_coding_block_size_minus3,
878  FFMIN(min_cb_log2_size_y, 5) - 3, FFMIN(ctb_log2_size_y, 5) - 3);
879  ue(log2_diff_max_min_pcm_luma_coding_block_size,
880  0, FFMIN(ctb_log2_size_y, 5) - (current->log2_min_pcm_luma_coding_block_size_minus3 + 3));
881 
882  flag(pcm_loop_filter_disabled_flag);
883  }
884 
885  ue(num_short_term_ref_pic_sets, 0, HEVC_MAX_SHORT_TERM_REF_PIC_SETS);
886  for (i = 0; i < current->num_short_term_ref_pic_sets; i++)
887  CHECK(FUNC(st_ref_pic_set)(ctx, rw, &current->st_ref_pic_set[i], i, current));
888 
889  flag(long_term_ref_pics_present_flag);
890  if (current->long_term_ref_pics_present_flag) {
891  ue(num_long_term_ref_pics_sps, 0, HEVC_MAX_LONG_TERM_REF_PICS);
892  for (i = 0; i < current->num_long_term_ref_pics_sps; i++) {
893  ubs(current->log2_max_pic_order_cnt_lsb_minus4 + 4,
894  lt_ref_pic_poc_lsb_sps[i], 1, i);
895  flags(used_by_curr_pic_lt_sps_flag[i], 1, i);
896  }
897  }
898 
899  flag(sps_temporal_mvp_enabled_flag);
900  flag(strong_intra_smoothing_enabled_flag);
901 
902  flag(vui_parameters_present_flag);
903  if (current->vui_parameters_present_flag)
904  CHECK(FUNC(vui_parameters)(ctx, rw, &current->vui, current));
905 
906  flag(sps_extension_present_flag);
907  if (current->sps_extension_present_flag) {
908  flag(sps_range_extension_flag);
909  flag(sps_multilayer_extension_flag);
910  flag(sps_3d_extension_flag);
911  flag(sps_scc_extension_flag);
912  ub(4, sps_extension_4bits);
913  }
914 
915  if (current->sps_range_extension_flag)
916  CHECK(FUNC(sps_range_extension)(ctx, rw, current));
917  if (current->sps_multilayer_extension_flag)
918  return AVERROR_PATCHWELCOME;
919  if (current->sps_3d_extension_flag)
920  return AVERROR_PATCHWELCOME;
921  if (current->sps_scc_extension_flag)
922  CHECK(FUNC(sps_scc_extension)(ctx, rw, current));
923  if (current->sps_extension_4bits)
924  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
925 
927 
928  return 0;
929 }
930 
932  H265RawPPS *current)
933 {
935  const H265RawSPS *sps = h265->active_sps;
936  int err, i;
937 
938  if (current->transform_skip_enabled_flag)
939  ue(log2_max_transform_skip_block_size_minus2, 0, 3);
940  flag(cross_component_prediction_enabled_flag);
941 
942  flag(chroma_qp_offset_list_enabled_flag);
943  if (current->chroma_qp_offset_list_enabled_flag) {
944  ue(diff_cu_chroma_qp_offset_depth,
945  0, sps->log2_diff_max_min_luma_coding_block_size);
946  ue(chroma_qp_offset_list_len_minus1, 0, 5);
947  for (i = 0; i <= current->chroma_qp_offset_list_len_minus1; i++) {
948  ses(cb_qp_offset_list[i], -12, +12, 1, i);
949  ses(cr_qp_offset_list[i], -12, +12, 1, i);
950  }
951  }
952 
953  ue(log2_sao_offset_scale_luma, 0, FFMAX(0, sps->bit_depth_luma_minus8 - 2));
954  ue(log2_sao_offset_scale_chroma, 0, FFMAX(0, sps->bit_depth_chroma_minus8 - 2));
955 
956  return 0;
957 }
958 
960  H265RawPPS *current)
961 {
962  int err, comp, i;
963 
964  flag(pps_curr_pic_ref_enabled_flag);
965 
966  flag(residual_adaptive_colour_transform_enabled_flag);
967  if (current->residual_adaptive_colour_transform_enabled_flag) {
968  flag(pps_slice_act_qp_offsets_present_flag);
969  se(pps_act_y_qp_offset_plus5, -7, +17);
970  se(pps_act_cb_qp_offset_plus5, -7, +17);
971  se(pps_act_cr_qp_offset_plus3, -9, +15);
972  } else {
973  infer(pps_slice_act_qp_offsets_present_flag, 0);
974  infer(pps_act_y_qp_offset_plus5, 0);
975  infer(pps_act_cb_qp_offset_plus5, 0);
976  infer(pps_act_cr_qp_offset_plus3, 0);
977  }
978 
979  flag(pps_palette_predictor_initializer_present_flag);
980  if (current->pps_palette_predictor_initializer_present_flag) {
981  ue(pps_num_palette_predictor_initializer, 0, 128);
982  if (current->pps_num_palette_predictor_initializer > 0) {
983  flag(monochrome_palette_flag);
984  ue(luma_bit_depth_entry_minus8, 0, 8);
985  if (!current->monochrome_palette_flag)
986  ue(chroma_bit_depth_entry_minus8, 0, 8);
987  for (comp = 0; comp < (current->monochrome_palette_flag ? 1 : 3); comp++) {
988  int bit_depth = comp == 0 ? current->luma_bit_depth_entry_minus8 + 8
989  : current->chroma_bit_depth_entry_minus8 + 8;
990  for (i = 0; i < current->pps_num_palette_predictor_initializer; i++)
991  ubs(bit_depth, pps_palette_predictor_initializers[comp][i], 2, comp, i);
992  }
993  }
994  }
995 
996  return 0;
997 }
998 
1000  H265RawPPS *current)
1001 {
1003  const H265RawSPS *sps;
1004  int err, i;
1005 
1006  HEADER("Picture Parameter Set");
1007 
1008  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_PPS));
1009 
1010  ue(pps_pic_parameter_set_id, 0, 63);
1011  ue(pps_seq_parameter_set_id, 0, 15);
1012  sps = h265->sps[current->pps_seq_parameter_set_id];
1013  if (!sps) {
1014  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1015  current->pps_seq_parameter_set_id);
1016  return AVERROR_INVALIDDATA;
1017  }
1018  h265->active_sps = sps;
1019 
1020  flag(dependent_slice_segments_enabled_flag);
1021  flag(output_flag_present_flag);
1022  ub(3, num_extra_slice_header_bits);
1023  flag(sign_data_hiding_enabled_flag);
1024  flag(cabac_init_present_flag);
1025 
1026  ue(num_ref_idx_l0_default_active_minus1, 0, 14);
1027  ue(num_ref_idx_l1_default_active_minus1, 0, 14);
1028 
1029  se(init_qp_minus26, -(26 + 6 * sps->bit_depth_luma_minus8), +25);
1030 
1031  flag(constrained_intra_pred_flag);
1032  flag(transform_skip_enabled_flag);
1033  flag(cu_qp_delta_enabled_flag);
1034  if (current->cu_qp_delta_enabled_flag)
1035  ue(diff_cu_qp_delta_depth,
1036  0, sps->log2_diff_max_min_luma_coding_block_size);
1037  else
1038  infer(diff_cu_qp_delta_depth, 0);
1039 
1040  se(pps_cb_qp_offset, -12, +12);
1041  se(pps_cr_qp_offset, -12, +12);
1042  flag(pps_slice_chroma_qp_offsets_present_flag);
1043 
1044  flag(weighted_pred_flag);
1045  flag(weighted_bipred_flag);
1046 
1047  flag(transquant_bypass_enabled_flag);
1048  flag(tiles_enabled_flag);
1049  flag(entropy_coding_sync_enabled_flag);
1050 
1051  if (current->tiles_enabled_flag) {
1052  ue(num_tile_columns_minus1, 0, HEVC_MAX_TILE_COLUMNS);
1053  ue(num_tile_rows_minus1, 0, HEVC_MAX_TILE_ROWS);
1054  flag(uniform_spacing_flag);
1055  if (!current->uniform_spacing_flag) {
1056  for (i = 0; i < current->num_tile_columns_minus1; i++)
1057  ues(column_width_minus1[i], 0, sps->pic_width_in_luma_samples, 1, i);
1058  for (i = 0; i < current->num_tile_rows_minus1; i++)
1059  ues(row_height_minus1[i], 0, sps->pic_height_in_luma_samples, 1, i);
1060  }
1061  flag(loop_filter_across_tiles_enabled_flag);
1062  } else {
1063  infer(num_tile_columns_minus1, 0);
1064  infer(num_tile_rows_minus1, 0);
1065  }
1066 
1067  flag(pps_loop_filter_across_slices_enabled_flag);
1068  flag(deblocking_filter_control_present_flag);
1069  if (current->deblocking_filter_control_present_flag) {
1070  flag(deblocking_filter_override_enabled_flag);
1071  flag(pps_deblocking_filter_disabled_flag);
1072  if (!current->pps_deblocking_filter_disabled_flag) {
1073  se(pps_beta_offset_div2, -6, +6);
1074  se(pps_tc_offset_div2, -6, +6);
1075  } else {
1076  infer(pps_beta_offset_div2, 0);
1077  infer(pps_tc_offset_div2, 0);
1078  }
1079  } else {
1080  infer(deblocking_filter_override_enabled_flag, 0);
1081  infer(pps_deblocking_filter_disabled_flag, 0);
1082  infer(pps_beta_offset_div2, 0);
1083  infer(pps_tc_offset_div2, 0);
1084  }
1085 
1086  flag(pps_scaling_list_data_present_flag);
1087  if (current->pps_scaling_list_data_present_flag)
1088  CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
1089 
1090  flag(lists_modification_present_flag);
1091 
1092  ue(log2_parallel_merge_level_minus2,
1093  0, (sps->log2_min_luma_coding_block_size_minus3 + 3 +
1094  sps->log2_diff_max_min_luma_coding_block_size - 2));
1095 
1096  flag(slice_segment_header_extension_present_flag);
1097 
1098  flag(pps_extension_present_flag);
1099  if (current->pps_extension_present_flag) {
1100  flag(pps_range_extension_flag);
1101  flag(pps_multilayer_extension_flag);
1102  flag(pps_3d_extension_flag);
1103  flag(pps_scc_extension_flag);
1104  ub(4, pps_extension_4bits);
1105  }
1106  if (current->pps_range_extension_flag)
1107  CHECK(FUNC(pps_range_extension)(ctx, rw, current));
1108  if (current->pps_multilayer_extension_flag)
1109  return AVERROR_PATCHWELCOME;
1110  if (current->pps_3d_extension_flag)
1111  return AVERROR_PATCHWELCOME;
1112  if (current->pps_scc_extension_flag)
1113  CHECK(FUNC(pps_scc_extension)(ctx, rw, current));
1114  if (current->pps_extension_4bits)
1115  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
1116 
1118 
1119  return 0;
1120 }
1121 
1123  H265RawAUD *current)
1124 {
1125  int err;
1126 
1127  HEADER("Access Unit Delimiter");
1128 
1129  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_AUD));
1130 
1131  u(3, pic_type, 0, 2);
1132 
1134 
1135  return 0;
1136 }
1137 
1139  H265RawSliceHeader *current,
1140  unsigned int num_pic_total_curr)
1141 {
1142  unsigned int entry_size;
1143  int err, i;
1144 
1145  entry_size = av_log2(num_pic_total_curr - 1) + 1;
1146 
1147  flag(ref_pic_list_modification_flag_l0);
1148  if (current->ref_pic_list_modification_flag_l0) {
1149  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++)
1150  us(entry_size, list_entry_l0[i], 0, num_pic_total_curr - 1, 1, i);
1151  }
1152 
1153  if (current->slice_type == HEVC_SLICE_B) {
1154  flag(ref_pic_list_modification_flag_l1);
1155  if (current->ref_pic_list_modification_flag_l1) {
1156  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++)
1157  us(entry_size, list_entry_l1[i], 0, num_pic_total_curr - 1, 1, i);
1158  }
1159  }
1160 
1161  return 0;
1162 }
1163 
1165  H265RawSliceHeader *current)
1166 {
1168  const H265RawSPS *sps = h265->active_sps;
1169  int err, i, j;
1170  int chroma = !sps->separate_colour_plane_flag &&
1171  sps->chroma_format_idc != 0;
1172 
1173  ue(luma_log2_weight_denom, 0, 7);
1174  if (chroma)
1175  se(delta_chroma_log2_weight_denom, -7, 7);
1176  else
1177  infer(delta_chroma_log2_weight_denom, 0);
1178 
1179  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1180  if (1 /* is not same POC and same layer_id */)
1181  flags(luma_weight_l0_flag[i], 1, i);
1182  else
1183  infer(luma_weight_l0_flag[i], 0);
1184  }
1185  if (chroma) {
1186  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1187  if (1 /* is not same POC and same layer_id */)
1188  flags(chroma_weight_l0_flag[i], 1, i);
1189  else
1190  infer(chroma_weight_l0_flag[i], 0);
1191  }
1192  }
1193 
1194  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1195  if (current->luma_weight_l0_flag[i]) {
1196  ses(delta_luma_weight_l0[i], -128, +127, 1, i);
1197  ses(luma_offset_l0[i],
1198  -(1 << (sps->bit_depth_luma_minus8 + 8 - 1)),
1199  ((1 << (sps->bit_depth_luma_minus8 + 8 - 1)) - 1), 1, i);
1200  } else {
1201  infer(delta_luma_weight_l0[i], 0);
1202  infer(luma_offset_l0[i], 0);
1203  }
1204  if (current->chroma_weight_l0_flag[i]) {
1205  for (j = 0; j < 2; j++) {
1206  ses(delta_chroma_weight_l0[i][j], -128, +127, 2, i, j);
1207  ses(chroma_offset_l0[i][j],
1208  -(4 << (sps->bit_depth_chroma_minus8 + 8 - 1)),
1209  ((4 << (sps->bit_depth_chroma_minus8 + 8 - 1)) - 1), 2, i, j);
1210  }
1211  } else {
1212  for (j = 0; j < 2; j++) {
1213  infer(delta_chroma_weight_l0[i][j], 0);
1214  infer(chroma_offset_l0[i][j], 0);
1215  }
1216  }
1217  }
1218 
1219  if (current->slice_type == HEVC_SLICE_B) {
1220  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1221  if (1 /* RefPicList1[i] is not CurrPic, nor is it in a different layer */)
1222  flags(luma_weight_l1_flag[i], 1, i);
1223  else
1224  infer(luma_weight_l1_flag[i], 0);
1225  }
1226  if (chroma) {
1227  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1228  if (1 /* RefPicList1[i] is not CurrPic, nor is it in a different layer */)
1229  flags(chroma_weight_l1_flag[i], 1, i);
1230  else
1231  infer(chroma_weight_l1_flag[i], 0);
1232  }
1233  }
1234 
1235  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1236  if (current->luma_weight_l1_flag[i]) {
1237  ses(delta_luma_weight_l1[i], -128, +127, 1, i);
1238  ses(luma_offset_l1[i],
1239  -(1 << (sps->bit_depth_luma_minus8 + 8 - 1)),
1240  ((1 << (sps->bit_depth_luma_minus8 + 8 - 1)) - 1), 1, i);
1241  } else {
1242  infer(delta_luma_weight_l1[i], 0);
1243  infer(luma_offset_l1[i], 0);
1244  }
1245  if (current->chroma_weight_l1_flag[i]) {
1246  for (j = 0; j < 2; j++) {
1247  ses(delta_chroma_weight_l1[i][j], -128, +127, 2, i, j);
1248  ses(chroma_offset_l1[i][j],
1249  -(4 << (sps->bit_depth_chroma_minus8 + 8 - 1)),
1250  ((4 << (sps->bit_depth_chroma_minus8 + 8 - 1)) - 1), 2, i, j);
1251  }
1252  } else {
1253  for (j = 0; j < 2; j++) {
1254  infer(delta_chroma_weight_l1[i][j], 0);
1255  infer(chroma_offset_l1[i][j], 0);
1256  }
1257  }
1258  }
1259  }
1260 
1261  return 0;
1262 }
1263 
1265  H265RawSliceHeader *current)
1266 {
1268  const H265RawSPS *sps;
1269  const H265RawPPS *pps;
1270  unsigned int min_cb_log2_size_y, ctb_log2_size_y, ctb_size_y;
1271  unsigned int pic_width_in_ctbs_y, pic_height_in_ctbs_y, pic_size_in_ctbs_y;
1272  unsigned int num_pic_total_curr = 0;
1273  int err, i;
1274 
1275  HEADER("Slice Segment Header");
1276 
1277  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, -1));
1278 
1279  flag(first_slice_segment_in_pic_flag);
1280 
1281  if (current->nal_unit_header.nal_unit_type >= HEVC_NAL_BLA_W_LP &&
1282  current->nal_unit_header.nal_unit_type <= HEVC_NAL_IRAP_VCL23)
1283  flag(no_output_of_prior_pics_flag);
1284 
1285  ue(slice_pic_parameter_set_id, 0, 63);
1286 
1287  pps = h265->pps[current->slice_pic_parameter_set_id];
1288  if (!pps) {
1289  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
1290  current->slice_pic_parameter_set_id);
1291  return AVERROR_INVALIDDATA;
1292  }
1293  h265->active_pps = pps;
1294 
1295  sps = h265->sps[pps->pps_seq_parameter_set_id];
1296  if (!sps) {
1297  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1298  pps->pps_seq_parameter_set_id);
1299  return AVERROR_INVALIDDATA;
1300  }
1301  h265->active_sps = sps;
1302 
1303  min_cb_log2_size_y = sps->log2_min_luma_coding_block_size_minus3 + 3;
1304  ctb_log2_size_y = min_cb_log2_size_y + sps->log2_diff_max_min_luma_coding_block_size;
1305  ctb_size_y = 1 << ctb_log2_size_y;
1306  pic_width_in_ctbs_y =
1307  (sps->pic_width_in_luma_samples + ctb_size_y - 1) / ctb_size_y;
1308  pic_height_in_ctbs_y =
1309  (sps->pic_height_in_luma_samples + ctb_size_y - 1) / ctb_size_y;
1310  pic_size_in_ctbs_y = pic_width_in_ctbs_y * pic_height_in_ctbs_y;
1311 
1312  if (!current->first_slice_segment_in_pic_flag) {
1313  unsigned int address_size = av_log2(pic_size_in_ctbs_y - 1) + 1;
1314  if (pps->dependent_slice_segments_enabled_flag)
1315  flag(dependent_slice_segment_flag);
1316  else
1317  infer(dependent_slice_segment_flag, 0);
1318  u(address_size, slice_segment_address, 0, pic_size_in_ctbs_y - 1);
1319  } else {
1320  infer(dependent_slice_segment_flag, 0);
1321  }
1322 
1323  if (!current->dependent_slice_segment_flag) {
1324  for (i = 0; i < pps->num_extra_slice_header_bits; i++)
1325  flags(slice_reserved_flag[i], 1, i);
1326 
1327  ue(slice_type, 0, 2);
1328 
1329  if (pps->output_flag_present_flag)
1330  flag(pic_output_flag);
1331 
1332  if (sps->separate_colour_plane_flag)
1333  u(2, colour_plane_id, 0, 2);
1334 
1335  if (current->nal_unit_header.nal_unit_type != HEVC_NAL_IDR_W_RADL &&
1336  current->nal_unit_header.nal_unit_type != HEVC_NAL_IDR_N_LP) {
1337  const H265RawSTRefPicSet *rps;
1338 
1339  ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, slice_pic_order_cnt_lsb);
1340 
1341  flag(short_term_ref_pic_set_sps_flag);
1342  if (!current->short_term_ref_pic_set_sps_flag) {
1343  CHECK(FUNC(st_ref_pic_set)(ctx, rw, &current->short_term_ref_pic_set,
1344  sps->num_short_term_ref_pic_sets, sps));
1345  rps = &current->short_term_ref_pic_set;
1346  } else if (sps->num_short_term_ref_pic_sets > 1) {
1347  unsigned int idx_size = av_log2(sps->num_short_term_ref_pic_sets - 1) + 1;
1348  u(idx_size, short_term_ref_pic_set_idx,
1349  0, sps->num_short_term_ref_pic_sets - 1);
1350  rps = &sps->st_ref_pic_set[current->short_term_ref_pic_set_idx];
1351  } else {
1352  infer(short_term_ref_pic_set_idx, 0);
1353  rps = &sps->st_ref_pic_set[0];
1354  }
1355 
1356  num_pic_total_curr = 0;
1357  for (i = 0; i < rps->num_negative_pics; i++)
1358  if (rps->used_by_curr_pic_s0_flag[i])
1359  ++num_pic_total_curr;
1360  for (i = 0; i < rps->num_positive_pics; i++)
1361  if (rps->used_by_curr_pic_s1_flag[i])
1362  ++num_pic_total_curr;
1363 
1364  if (sps->long_term_ref_pics_present_flag) {
1365  unsigned int idx_size;
1366 
1367  if (sps->num_long_term_ref_pics_sps > 0) {
1368  ue(num_long_term_sps, 0, sps->num_long_term_ref_pics_sps);
1369  idx_size = av_log2(sps->num_long_term_ref_pics_sps - 1) + 1;
1370  } else {
1371  infer(num_long_term_sps, 0);
1372  idx_size = 0;
1373  }
1374  ue(num_long_term_pics, 0, HEVC_MAX_REFS - current->num_long_term_sps);
1375 
1376  for (i = 0; i < current->num_long_term_sps +
1377  current->num_long_term_pics; i++) {
1378  if (i < current->num_long_term_sps) {
1379  if (sps->num_long_term_ref_pics_sps > 1)
1380  us(idx_size, lt_idx_sps[i],
1381  0, sps->num_long_term_ref_pics_sps - 1, 1, i);
1382  if (sps->used_by_curr_pic_lt_sps_flag[current->lt_idx_sps[i]])
1383  ++num_pic_total_curr;
1384  } else {
1385  ubs(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, poc_lsb_lt[i], 1, i);
1386  flags(used_by_curr_pic_lt_flag[i], 1, i);
1387  if (current->used_by_curr_pic_lt_flag[i])
1388  ++num_pic_total_curr;
1389  }
1390  flags(delta_poc_msb_present_flag[i], 1, i);
1391  if (current->delta_poc_msb_present_flag[i])
1392  ues(delta_poc_msb_cycle_lt[i], 0, UINT32_MAX - 1, 1, i);
1393  else
1394  infer(delta_poc_msb_cycle_lt[i], 0);
1395  }
1396  }
1397 
1398  if (sps->sps_temporal_mvp_enabled_flag)
1399  flag(slice_temporal_mvp_enabled_flag);
1400  else
1401  infer(slice_temporal_mvp_enabled_flag, 0);
1402 
1403  if (pps->pps_curr_pic_ref_enabled_flag)
1404  ++num_pic_total_curr;
1405  }
1406 
1407  if (sps->sample_adaptive_offset_enabled_flag) {
1408  flag(slice_sao_luma_flag);
1409  if (!sps->separate_colour_plane_flag && sps->chroma_format_idc != 0)
1410  flag(slice_sao_chroma_flag);
1411  else
1412  infer(slice_sao_chroma_flag, 0);
1413  } else {
1414  infer(slice_sao_luma_flag, 0);
1415  infer(slice_sao_chroma_flag, 0);
1416  }
1417 
1418  if (current->slice_type == HEVC_SLICE_P ||
1419  current->slice_type == HEVC_SLICE_B) {
1420  flag(num_ref_idx_active_override_flag);
1421  if (current->num_ref_idx_active_override_flag) {
1422  ue(num_ref_idx_l0_active_minus1, 0, 14);
1423  if (current->slice_type == HEVC_SLICE_B)
1424  ue(num_ref_idx_l1_active_minus1, 0, 14);
1425  else
1426  infer(num_ref_idx_l1_active_minus1, pps->num_ref_idx_l1_default_active_minus1);
1427  } else {
1428  infer(num_ref_idx_l0_active_minus1, pps->num_ref_idx_l0_default_active_minus1);
1429  infer(num_ref_idx_l1_active_minus1, pps->num_ref_idx_l1_default_active_minus1);
1430  }
1431 
1432  if (pps->lists_modification_present_flag && num_pic_total_curr > 1)
1433  CHECK(FUNC(ref_pic_lists_modification)(ctx, rw, current,
1434  num_pic_total_curr));
1435 
1436  if (current->slice_type == HEVC_SLICE_B)
1437  flag(mvd_l1_zero_flag);
1438  if (pps->cabac_init_present_flag)
1439  flag(cabac_init_flag);
1440  else
1441  infer(cabac_init_flag, 0);
1442  if (current->slice_temporal_mvp_enabled_flag) {
1443  if (current->slice_type == HEVC_SLICE_B)
1444  flag(collocated_from_l0_flag);
1445  else
1446  infer(collocated_from_l0_flag, 1);
1447  if (current->collocated_from_l0_flag) {
1448  if (current->num_ref_idx_l0_active_minus1 > 0)
1449  ue(collocated_ref_idx, 0, current->num_ref_idx_l0_active_minus1);
1450  else
1451  infer(collocated_ref_idx, 0);
1452  } else {
1453  if (current->num_ref_idx_l1_active_minus1 > 0)
1454  ue(collocated_ref_idx, 0, current->num_ref_idx_l1_active_minus1);
1455  else
1456  infer(collocated_ref_idx, 0);
1457  }
1458  }
1459 
1460  if ((pps->weighted_pred_flag && current->slice_type == HEVC_SLICE_P) ||
1461  (pps->weighted_bipred_flag && current->slice_type == HEVC_SLICE_B))
1462  CHECK(FUNC(pred_weight_table)(ctx, rw, current));
1463 
1464  ue(five_minus_max_num_merge_cand, 0, 4);
1465  if (sps->motion_vector_resolution_control_idc == 2)
1466  flag(use_integer_mv_flag);
1467  else
1468  infer(use_integer_mv_flag, sps->motion_vector_resolution_control_idc);
1469  }
1470 
1471  se(slice_qp_delta,
1472  - 6 * sps->bit_depth_luma_minus8 - (pps->init_qp_minus26 + 26),
1473  + 51 - (pps->init_qp_minus26 + 26));
1474  if (pps->pps_slice_chroma_qp_offsets_present_flag) {
1475  se(slice_cb_qp_offset, -12, +12);
1476  se(slice_cr_qp_offset, -12, +12);
1477  } else {
1478  infer(slice_cb_qp_offset, 0);
1479  infer(slice_cr_qp_offset, 0);
1480  }
1481  if (pps->pps_slice_act_qp_offsets_present_flag) {
1482  se(slice_act_y_qp_offset,
1483  -12 - (pps->pps_act_y_qp_offset_plus5 - 5),
1484  +12 - (pps->pps_act_y_qp_offset_plus5 - 5));
1485  se(slice_act_cb_qp_offset,
1486  -12 - (pps->pps_act_cb_qp_offset_plus5 - 5),
1487  +12 - (pps->pps_act_cb_qp_offset_plus5 - 5));
1488  se(slice_act_cr_qp_offset,
1489  -12 - (pps->pps_act_cr_qp_offset_plus3 - 3),
1490  +12 - (pps->pps_act_cr_qp_offset_plus3 - 3));
1491  } else {
1492  infer(slice_act_y_qp_offset, 0);
1493  infer(slice_act_cb_qp_offset, 0);
1494  infer(slice_act_cr_qp_offset, 0);
1495  }
1496  if (pps->chroma_qp_offset_list_enabled_flag)
1497  flag(cu_chroma_qp_offset_enabled_flag);
1498  else
1499  infer(cu_chroma_qp_offset_enabled_flag, 0);
1500 
1501  if (pps->deblocking_filter_override_enabled_flag)
1502  flag(deblocking_filter_override_flag);
1503  else
1504  infer(deblocking_filter_override_flag, 0);
1505  if (current->deblocking_filter_override_flag) {
1506  flag(slice_deblocking_filter_disabled_flag);
1507  if (!current->slice_deblocking_filter_disabled_flag) {
1508  se(slice_beta_offset_div2, -6, +6);
1509  se(slice_tc_offset_div2, -6, +6);
1510  } else {
1511  infer(slice_beta_offset_div2, pps->pps_beta_offset_div2);
1512  infer(slice_tc_offset_div2, pps->pps_tc_offset_div2);
1513  }
1514  } else {
1515  infer(slice_deblocking_filter_disabled_flag,
1516  pps->pps_deblocking_filter_disabled_flag);
1517  infer(slice_beta_offset_div2, pps->pps_beta_offset_div2);
1518  infer(slice_tc_offset_div2, pps->pps_tc_offset_div2);
1519  }
1520  if (pps->pps_loop_filter_across_slices_enabled_flag &&
1521  (current->slice_sao_luma_flag || current->slice_sao_chroma_flag ||
1522  !current->slice_deblocking_filter_disabled_flag))
1523  flag(slice_loop_filter_across_slices_enabled_flag);
1524  else
1525  infer(slice_loop_filter_across_slices_enabled_flag,
1526  pps->pps_loop_filter_across_slices_enabled_flag);
1527  }
1528 
1529  if (pps->tiles_enabled_flag || pps->entropy_coding_sync_enabled_flag) {
1530  unsigned int num_entry_point_offsets_limit;
1531  if (!pps->tiles_enabled_flag && pps->entropy_coding_sync_enabled_flag)
1532  num_entry_point_offsets_limit = pic_height_in_ctbs_y - 1;
1533  else if (pps->tiles_enabled_flag && !pps->entropy_coding_sync_enabled_flag)
1534  num_entry_point_offsets_limit =
1535  (pps->num_tile_columns_minus1 + 1) * (pps->num_tile_rows_minus1 + 1);
1536  else
1537  num_entry_point_offsets_limit =
1538  (pps->num_tile_columns_minus1 + 1) * pic_height_in_ctbs_y - 1;
1539  ue(num_entry_point_offsets, 0, num_entry_point_offsets_limit);
1540 
1541  if (current->num_entry_point_offsets > HEVC_MAX_ENTRY_POINT_OFFSETS) {
1542  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: "
1543  "%"PRIu16".\n", current->num_entry_point_offsets);
1544  return AVERROR_PATCHWELCOME;
1545  }
1546 
1547  if (current->num_entry_point_offsets > 0) {
1548  ue(offset_len_minus1, 0, 31);
1549  for (i = 0; i < current->num_entry_point_offsets; i++)
1550  ubs(current->offset_len_minus1 + 1, entry_point_offset_minus1[i], 1, i);
1551  }
1552  }
1553 
1554  if (pps->slice_segment_header_extension_present_flag) {
1555  ue(slice_segment_header_extension_length, 0, 256);
1556  for (i = 0; i < current->slice_segment_header_extension_length; i++)
1557  us(8, slice_segment_header_extension_data_byte[i], 0x00, 0xff, 1, i);
1558  }
1559 
1560  CHECK(FUNC(byte_alignment)(ctx, rw));
1561 
1562  return 0;
1563 }
1564 
1566  H265RawSEIBufferingPeriod *current,
1567  uint32_t *payload_size)
1568 {
1570  const H265RawSPS *sps;
1571  const H265RawHRDParameters *hrd;
1572  int err, i, length;
1573 
1574 #ifdef READ
1575  int start_pos, end_pos, bits_left;
1576  start_pos = get_bits_count(rw);
1577 #endif
1578 
1579  HEADER("Buffering Period");
1580 
1581  ue(bp_seq_parameter_set_id, 0, HEVC_MAX_SPS_COUNT - 1);
1582 
1583  sps = h265->sps[current->bp_seq_parameter_set_id];
1584  if (!sps) {
1585  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1586  current->bp_seq_parameter_set_id);
1587  return AVERROR_INVALIDDATA;
1588  }
1589  h265->active_sps = sps;
1590 
1591  if (!sps->vui_parameters_present_flag ||
1592  !sps->vui.vui_hrd_parameters_present_flag) {
1593  av_log(ctx->log_ctx, AV_LOG_ERROR, "Buffering period SEI requires "
1594  "HRD parameters to be present in SPS.\n");
1595  return AVERROR_INVALIDDATA;
1596  }
1597  hrd = &sps->vui.hrd_parameters;
1598  if (!hrd->nal_hrd_parameters_present_flag &&
1600  av_log(ctx->log_ctx, AV_LOG_ERROR, "Buffering period SEI requires "
1601  "NAL or VCL HRD parameters to be present.\n");
1602  return AVERROR_INVALIDDATA;
1603  }
1604 
1606  flag(irap_cpb_params_present_flag);
1607  else
1608  infer(irap_cpb_params_present_flag, 0);
1609  if (current->irap_cpb_params_present_flag) {
1611  ub(length, cpb_delay_offset);
1613  ub(length, dpb_delay_offset);
1614  } else {
1615  infer(cpb_delay_offset, 0);
1616  infer(dpb_delay_offset, 0);
1617  }
1618 
1619  flag(concatenation_flag);
1620 
1622  ub(length, au_cpb_removal_delay_delta_minus1);
1623 
1625  for (i = 0; i <= hrd->cpb_cnt_minus1[0]; i++) {
1627 
1628  ubs(length, nal_initial_cpb_removal_delay[i], 1, i);
1629  ubs(length, nal_initial_cpb_removal_offset[i], 1, i);
1630 
1632  current->irap_cpb_params_present_flag) {
1633  ubs(length, nal_initial_alt_cpb_removal_delay[i], 1, i);
1634  ubs(length, nal_initial_alt_cpb_removal_offset[i], 1, i);
1635  }
1636  }
1637  }
1639  for (i = 0; i <= hrd->cpb_cnt_minus1[0]; i++) {
1641 
1642  ubs(length, vcl_initial_cpb_removal_delay[i], 1, i);
1643  ubs(length, vcl_initial_cpb_removal_offset[i], 1, i);
1644 
1646  current->irap_cpb_params_present_flag) {
1647  ubs(length, vcl_initial_alt_cpb_removal_delay[i], 1, i);
1648  ubs(length, vcl_initial_alt_cpb_removal_offset[i], 1, i);
1649  }
1650  }
1651  }
1652 
1653 #ifdef READ
1654  // payload_extension_present() - true if we are before the last 1-bit
1655  // in the payload structure, which must be in the last byte.
1656  end_pos = get_bits_count(rw);
1657  bits_left = *payload_size * 8 - (end_pos - start_pos);
1658  if (bits_left > 0 &&
1659  (bits_left > 7 || ff_ctz(show_bits(rw, bits_left)) < bits_left - 1))
1660  flag(use_alt_cpb_params_flag);
1661  else
1662  infer(use_alt_cpb_params_flag, 0);
1663 #else
1664  if (current->use_alt_cpb_params_flag)
1665  flag(use_alt_cpb_params_flag);
1666 #endif
1667 
1668  return 0;
1669 }
1670 
1672  H265RawSEIPicTiming *current)
1673 {
1675  const H265RawSPS *sps;
1676  const H265RawHRDParameters *hrd;
1677  int err, expected_source_scan_type, i, length;
1678 
1679  HEADER("Picture Timing");
1680 
1681  sps = h265->active_sps;
1682  if (!sps) {
1683  av_log(ctx->log_ctx, AV_LOG_ERROR,
1684  "No active SPS for pic_timing.\n");
1685  return AVERROR_INVALIDDATA;
1686  }
1687 
1688  expected_source_scan_type = 2 -
1689  2 * sps->profile_tier_level.general_interlaced_source_flag -
1690  sps->profile_tier_level.general_progressive_source_flag;
1691 
1692  if (sps->vui.frame_field_info_present_flag) {
1693  u(4, pic_struct, 0, 12);
1694  u(2, source_scan_type,
1695  expected_source_scan_type >= 0 ? expected_source_scan_type : 0,
1696  expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1697  flag(duplicate_flag);
1698  } else {
1699  infer(pic_struct, 0);
1700  infer(source_scan_type,
1701  expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1702  infer(duplicate_flag, 0);
1703  }
1704 
1705  if (sps->vui_parameters_present_flag &&
1706  sps->vui.vui_hrd_parameters_present_flag)
1707  hrd = &sps->vui.hrd_parameters;
1708  else
1709  hrd = NULL;
1710  if (hrd && (hrd->nal_hrd_parameters_present_flag ||
1713  ub(length, au_cpb_removal_delay_minus1);
1714 
1716  ub(length, pic_dpb_output_delay);
1717 
1720  ub(length, pic_dpb_output_du_delay);
1721  }
1722 
1725  // Each decoding unit must contain at least one slice segment.
1726  ue(num_decoding_units_minus1, 0, HEVC_MAX_SLICE_SEGMENTS);
1727  flag(du_common_cpb_removal_delay_flag);
1728 
1730  if (current->du_common_cpb_removal_delay_flag)
1731  ub(length, du_common_cpb_removal_delay_increment_minus1);
1732 
1733  for (i = 0; i <= current->num_decoding_units_minus1; i++) {
1734  ues(num_nalus_in_du_minus1[i],
1735  0, HEVC_MAX_SLICE_SEGMENTS, 1, i);
1736  if (!current->du_common_cpb_removal_delay_flag &&
1737  i < current->num_decoding_units_minus1)
1738  ubs(length, du_cpb_removal_delay_increment_minus1[i], 1, i);
1739  }
1740  }
1741  }
1742 
1743  return 0;
1744 }
1745 
1747  H265RawSEIPanScanRect *current)
1748 {
1749  int err, i;
1750 
1751  HEADER("Pan-Scan Rectangle");
1752 
1753  ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
1754  flag(pan_scan_rect_cancel_flag);
1755 
1756  if (!current->pan_scan_rect_cancel_flag) {
1757  ue(pan_scan_cnt_minus1, 0, 2);
1758 
1759  for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
1760  ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1761  ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1762  ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1763  ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1764  }
1765 
1766  flag(pan_scan_rect_persistence_flag);
1767  }
1768 
1769  return 0;
1770 }
1771 
1774  uint32_t *payload_size)
1775 {
1776  int err, i, j;
1777 
1778  HEADER("User Data Registered ITU-T T.35");
1779 
1780  u(8, itu_t_t35_country_code, 0x00, 0xff);
1781  if (current->itu_t_t35_country_code != 0xff)
1782  i = 1;
1783  else {
1784  u(8, itu_t_t35_country_code_extension_byte, 0x00, 0xff);
1785  i = 2;
1786  }
1787 
1788 #ifdef READ
1789  if (*payload_size < i) {
1790  av_log(ctx->log_ctx, AV_LOG_ERROR,
1791  "Invalid SEI user data registered payload.\n");
1792  return AVERROR_INVALIDDATA;
1793  }
1794  current->data_length = *payload_size - i;
1795 #else
1796  *payload_size = i + current->data_length;
1797 #endif
1798 
1799  allocate(current->data, current->data_length);
1800  for (j = 0; j < current->data_length; j++)
1801  xu(8, itu_t_t35_payload_byte[i], current->data[j], 0x00, 0xff, 1, i + j);
1802 
1803  return 0;
1804 }
1805 
1808  uint32_t *payload_size)
1809 {
1810  int err, i;
1811 
1812  HEADER("User Data Unregistered");
1813 
1814 #ifdef READ
1815  if (*payload_size < 16) {
1816  av_log(ctx->log_ctx, AV_LOG_ERROR,
1817  "Invalid SEI user data unregistered payload.\n");
1818  return AVERROR_INVALIDDATA;
1819  }
1820  current->data_length = *payload_size - 16;
1821 #else
1822  *payload_size = 16 + current->data_length;
1823 #endif
1824 
1825  for (i = 0; i < 16; i++)
1826  us(8, uuid_iso_iec_11578[i], 0x00, 0xff, 1, i);
1827 
1828  allocate(current->data, current->data_length);
1829 
1830  for (i = 0; i < current->data_length; i++)
1831  xu(8, user_data_payload_byte[i], current->data[i], 0x00, 0xff, 1, i);
1832 
1833  return 0;
1834 }
1835 
1837  H265RawSEIRecoveryPoint *current)
1838 {
1839  int err;
1840 
1841  HEADER("Recovery Point");
1842 
1843  se(recovery_poc_cnt, -32768, 32767);
1844 
1845  flag(exact_match_flag);
1846  flag(broken_link_flag);
1847 
1848  return 0;
1849 }
1850 
1853 {
1854  int err;
1855 
1856  HEADER("Display Orientation");
1857 
1858  flag(display_orientation_cancel_flag);
1859  if (!current->display_orientation_cancel_flag) {
1860  flag(hor_flip);
1861  flag(ver_flip);
1862  ub(16, anticlockwise_rotation);
1863  flag(display_orientation_persistence_flag);
1864  }
1865 
1866  return 0;
1867 }
1868 
1871 {
1873  const H265RawVPS *vps;
1874  int err, i;
1875 
1876  HEADER("Active Parameter Sets");
1877 
1878  u(4, active_video_parameter_set_id, 0, HEVC_MAX_VPS_COUNT);
1879  vps = h265->vps[current->active_video_parameter_set_id];
1880  if (!vps) {
1881  av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available for active "
1882  "parameter sets.\n", current->active_video_parameter_set_id);
1883  return AVERROR_INVALIDDATA;
1884  }
1885  h265->active_vps = vps;
1886 
1887  flag(self_contained_cvs_flag);
1888  flag(no_parameter_set_update_flag);
1889 
1890  ue(num_sps_ids_minus1, 0, HEVC_MAX_SPS_COUNT - 1);
1891  for (i = 0; i <= current->num_sps_ids_minus1; i++)
1892  ues(active_seq_parameter_set_id[i], 0, HEVC_MAX_SPS_COUNT - 1, 1, i);
1893 
1894  for (i = vps->vps_base_layer_internal_flag;
1895  i <= FFMIN(62, vps->vps_max_layers_minus1); i++) {
1896  ues(layer_sps_idx[i], 0, current->num_sps_ids_minus1, 1, i);
1897 
1898  if (i == 0)
1899  h265->active_sps = h265->sps[current->active_seq_parameter_set_id[current->layer_sps_idx[0]]];
1900  }
1901 
1902  return 0;
1903 }
1904 
1907 {
1909  const H265RawSPS *sps = h265->active_sps;
1910  int err, c, i;
1911 
1912  HEADER("Decoded Picture Hash");
1913 
1914  if (!sps) {
1915  av_log(ctx->log_ctx, AV_LOG_ERROR,
1916  "No active SPS for decoded picture hash.\n");
1917  return AVERROR_INVALIDDATA;
1918  }
1919 
1920  u(8, hash_type, 0, 2);
1921 
1922  for (c = 0; c < (sps->chroma_format_idc == 0 ? 1 : 3); c++) {
1923  if (current->hash_type == 0) {
1924  for (i = 0; i < 16; i++)
1925  us(8, picture_md5[c][i], 0x00, 0xff, 2, c, i);
1926  } else if (current->hash_type == 1) {
1927  us(16, picture_crc[c], 0x0000, 0xffff, 1, c);
1928  } else if (current->hash_type == 2) {
1929  us(32, picture_checksum[c], 0x00000000, 0xffffffff, 1, c);
1930  }
1931  }
1932 
1933  return 0;
1934 }
1935 
1937  H265RawSEITimeCode *current)
1938 {
1939  int err, i;
1940 
1941  HEADER("Time Code");
1942 
1943  u(2, num_clock_ts, 1, 3);
1944 
1945  for (i = 0; i < current->num_clock_ts; i++) {
1946  flags(clock_timestamp_flag[i], 1, i);
1947 
1948  if (current->clock_timestamp_flag[i]) {
1949  flags(units_field_based_flag[i], 1, i);
1950  us(5, counting_type[i], 0, 6, 1, i);
1951  flags(full_timestamp_flag[i], 1, i);
1952  flags(discontinuity_flag[i], 1, i);
1953  flags(cnt_dropped_flag[i], 1, i);
1954 
1955  ubs(9, n_frames[i], 1, i);
1956 
1957  if (current->full_timestamp_flag[i]) {
1958  us(6, seconds_value[i], 0, 59, 1, i);
1959  us(6, minutes_value[i], 0, 59, 1, i);
1960  us(5, hours_value[i], 0, 23, 1, i);
1961  } else {
1962  flags(seconds_flag[i], 1, i);
1963  if (current->seconds_flag[i]) {
1964  us(6, seconds_value[i], 0, 59, 1, i);
1965  flags(minutes_flag[i], 1, i);
1966  if (current->minutes_flag[i]) {
1967  us(6, minutes_value[i], 0, 59, 1, i);
1968  flags(hours_flag[i], 1, i);
1969  if (current->hours_flag[i])
1970  us(5, hours_value[i], 0, 23, 1, i);
1971  }
1972  }
1973  }
1974 
1975  ubs(5, time_offset_length[i], 1, i);
1976  if (current->time_offset_length[i] > 0)
1977  ibs(current->time_offset_length[i], time_offset_value[i], 1, i);
1978  else
1979  infer(time_offset_value[i], 0);
1980  }
1981  }
1982 
1983  return 0;
1984 }
1985 
1988 {
1989  int err, c;
1990 
1991  HEADER("Mastering Display Colour Volume");
1992 
1993  for (c = 0; c < 3; c++) {
1994  us(16, display_primaries_x[c], 0, 50000, 1, c);
1995  us(16, display_primaries_y[c], 0, 50000, 1, c);
1996  }
1997 
1998  u(16, white_point_x, 0, 50000);
1999  u(16, white_point_y, 0, 50000);
2000 
2001  u(32, max_display_mastering_luminance,
2002  1, MAX_UINT_BITS(32));
2003  u(32, min_display_mastering_luminance,
2004  0, current->max_display_mastering_luminance - 1);
2005 
2006  return 0;
2007 }
2008 
2011 {
2012  int err;
2013 
2014  HEADER("Content Light Level");
2015 
2016  ub(16, max_content_light_level);
2017  ub(16, max_pic_average_light_level);
2018 
2019  return 0;
2020 }
2021 
2023  RWContext *rw,
2025 {
2026  int err;
2027 
2028  HEADER("Alternative Transfer Characteristics");
2029 
2030  ub(8, preferred_transfer_characteristics);
2031 
2032  return 0;
2033 }
2034 
2036  RWContext *rw,
2037  H265RawSEIAlphaChannelInfo *current)
2038 {
2039  int err, length;
2040 
2041  HEADER("Alpha Channel Information");
2042 
2043  flag(alpha_channel_cancel_flag);
2044  if (!current->alpha_channel_cancel_flag) {
2045  ub(3, alpha_channel_use_idc);
2046  ub(3, alpha_channel_bit_depth_minus8);
2047  length = current->alpha_channel_bit_depth_minus8 + 9;
2048  ub(length, alpha_transparent_value);
2049  ub(length, alpha_opaque_value);
2050  flag(alpha_channel_incr_flag);
2051  flag(alpha_channel_clip_flag);
2052  if (current->alpha_channel_clip_flag)
2053  flag(alpha_channel_clip_type_flag);
2054  } else {
2055  infer(alpha_channel_use_idc, 2);
2056  infer(alpha_channel_incr_flag, 0);
2057  infer(alpha_channel_clip_flag, 0);
2058  }
2059 
2060  return 0;
2061 }
2062 
2064  H265RawSEIPayload *current, int prefix)
2065 {
2066  int err, i;
2067  int start_position, end_position;
2068 
2069 #ifdef READ
2070  start_position = get_bits_count(rw);
2071 #else
2072  start_position = put_bits_count(rw);
2073 #endif
2074 
2075  switch (current->payload_type) {
2076 #define SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid) do { \
2077  if (prefix && !prefix_valid) { \
2078  av_log(ctx->log_ctx, AV_LOG_ERROR, "SEI type %s invalid " \
2079  "as prefix SEI!\n", #name); \
2080  return AVERROR_INVALIDDATA; \
2081  } \
2082  if (!prefix && !suffix_valid) { \
2083  av_log(ctx->log_ctx, AV_LOG_ERROR, "SEI type %s invalid " \
2084  "as suffix SEI!\n", #name); \
2085  return AVERROR_INVALIDDATA; \
2086  } \
2087  } while (0)
2088 #define SEI_TYPE_N(type, prefix_valid, suffix_valid, name) \
2089  case HEVC_SEI_TYPE_ ## type: \
2090  SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid); \
2091  CHECK(FUNC(sei_ ## name)(ctx, rw, &current->payload.name)); \
2092  break
2093 #define SEI_TYPE_S(type, prefix_valid, suffix_valid, name) \
2094  case HEVC_SEI_TYPE_ ## type: \
2095  SEI_TYPE_CHECK_VALID(name, prefix_valid, suffix_valid); \
2096  CHECK(FUNC(sei_ ## name)(ctx, rw, &current->payload.name, \
2097  &current->payload_size)); \
2098  break
2099 
2100  SEI_TYPE_S(BUFFERING_PERIOD, 1, 0, buffering_period);
2101  SEI_TYPE_N(PICTURE_TIMING, 1, 0, pic_timing);
2102  SEI_TYPE_N(PAN_SCAN_RECT, 1, 0, pan_scan_rect);
2103  SEI_TYPE_S(USER_DATA_REGISTERED_ITU_T_T35,
2104  1, 1, user_data_registered);
2105  SEI_TYPE_S(USER_DATA_UNREGISTERED, 1, 1, user_data_unregistered);
2106  SEI_TYPE_N(RECOVERY_POINT, 1, 0, recovery_point);
2107  SEI_TYPE_N(DISPLAY_ORIENTATION, 1, 0, display_orientation);
2108  SEI_TYPE_N(ACTIVE_PARAMETER_SETS, 1, 0, active_parameter_sets);
2109  SEI_TYPE_N(DECODED_PICTURE_HASH, 0, 1, decoded_picture_hash);
2110  SEI_TYPE_N(TIME_CODE, 1, 0, time_code);
2111  SEI_TYPE_N(MASTERING_DISPLAY_INFO, 1, 0, mastering_display);
2112  SEI_TYPE_N(CONTENT_LIGHT_LEVEL_INFO, 1, 0, content_light_level);
2113  SEI_TYPE_N(ALTERNATIVE_TRANSFER_CHARACTERISTICS,
2114  1, 0, alternative_transfer_characteristics);
2115  SEI_TYPE_N(ALPHA_CHANNEL_INFO, 1, 0, alpha_channel_info);
2116 
2117 #undef SEI_TYPE
2118  default:
2119  {
2120 #ifdef READ
2121  current->payload.other.data_length = current->payload_size;
2122 #endif
2123  allocate(current->payload.other.data, current->payload.other.data_length);
2124 
2125  for (i = 0; i < current->payload_size; i++)
2126  xu(8, payload_byte[i], current->payload.other.data[i], 0, 255,
2127  1, i);
2128  }
2129  }
2130 
2131  if (byte_alignment(rw)) {
2132  fixed(1, bit_equal_to_one, 1);
2133  while (byte_alignment(rw))
2134  fixed(1, bit_equal_to_zero, 0);
2135  }
2136 
2137 #ifdef READ
2138  end_position = get_bits_count(rw);
2139  if (end_position < start_position + 8 * current->payload_size) {
2140  av_log(ctx->log_ctx, AV_LOG_ERROR, "Incorrect SEI payload length: "
2141  "header %"PRIu32" bits, actually %d bits.\n",
2142  8 * current->payload_size,
2143  end_position - start_position);
2144  return AVERROR_INVALIDDATA;
2145  }
2146 #else
2147  end_position = put_bits_count(rw);
2148  current->payload_size = (end_position - start_position) >> 3;
2149 #endif
2150 
2151  return 0;
2152 }
2153 
2155  H265RawSEI *current, int prefix)
2156 {
2157  int err, k;
2158 
2159  if (prefix)
2160  HEADER("Prefix Supplemental Enhancement Information");
2161  else
2162  HEADER("Suffix Supplemental Enhancement Information");
2163 
2164  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
2165  prefix ? HEVC_NAL_SEI_PREFIX
2166  : HEVC_NAL_SEI_SUFFIX));
2167 
2168 #ifdef READ
2169  for (k = 0; k < H265_MAX_SEI_PAYLOADS; k++) {
2170  uint32_t payload_type = 0;
2171  uint32_t payload_size = 0;
2172  uint32_t tmp;
2173 
2174  while (show_bits(rw, 8) == 0xff) {
2175  fixed(8, ff_byte, 0xff);
2176  payload_type += 255;
2177  }
2178  xu(8, last_payload_type_byte, tmp, 0, 254, 0);
2179  payload_type += tmp;
2180 
2181  while (show_bits(rw, 8) == 0xff) {
2182  fixed(8, ff_byte, 0xff);
2183  payload_size += 255;
2184  }
2185  xu(8, last_payload_size_byte, tmp, 0, 254, 0);
2186  payload_size += tmp;
2187 
2188  current->payload[k].payload_type = payload_type;
2189  current->payload[k].payload_size = payload_size;
2190 
2191  current->payload_count++;
2192  CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k], prefix));
2193 
2195  break;
2196  }
2197  if (k >= H265_MAX_SEI_PAYLOADS) {
2198  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many payloads in "
2199  "SEI message: found %d.\n", k);
2200  return AVERROR_INVALIDDATA;
2201  }
2202 #else
2203  for (k = 0; k < current->payload_count; k++) {
2204  PutBitContext start_state;
2205  uint32_t tmp;
2206  int need_size, i;
2207 
2208  // Somewhat clumsy: we write the payload twice when
2209  // we don't know the size in advance. This will mess
2210  // with trace output, but is otherwise harmless.
2211  start_state = *rw;
2212  need_size = !current->payload[k].payload_size;
2213  for (i = 0; i < 1 + need_size; i++) {
2214  *rw = start_state;
2215 
2216  tmp = current->payload[k].payload_type;
2217  while (tmp >= 255) {
2218  fixed(8, ff_byte, 0xff);
2219  tmp -= 255;
2220  }
2221  xu(8, last_payload_type_byte, tmp, 0, 254, 0);
2222 
2223  tmp = current->payload[k].payload_size;
2224  while (tmp >= 255) {
2225  fixed(8, ff_byte, 0xff);
2226  tmp -= 255;
2227  }
2228  xu(8, last_payload_size_byte, tmp, 0, 254, 0);
2229 
2230  CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k], prefix));
2231  }
2232  }
2233 #endif
2234 
2236 
2237  return 0;
2238 }
H265RawHRDParameters::au_cpb_removal_delay_length_minus1
uint8_t au_cpb_removal_delay_length_minus1
Definition: cbs_h265.h:123
CodedBitstreamH265Context::vps
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
Definition: cbs_h265.h:736
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
sps_scc_extension
static int FUNC() sps_scc_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
Definition: cbs_h265_syntax_template.c:711
H265RawSEITimeCode
Definition: cbs_h265.h:645
H265RawHRDParameters::dpb_output_delay_length_minus1
uint8_t dpb_output_delay_length_minus1
Definition: cbs_h265.h:124
ff_ctz
#define ff_ctz
Definition: intmath.h:106
profile_tier_level
static int FUNC() profile_tier_level(CodedBitstreamContext *ctx, RWContext *rw, H265RawProfileTierLevel *current, int profile_present_flag, int max_num_sub_layers_minus1)
Definition: cbs_h265_syntax_template.c:88
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
n
int n
Definition: avisynth_c.h:760
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
SEI_TYPE_N
#define SEI_TYPE_N(type, prefix_valid, suffix_valid, name)
sps_range_extension
static int FUNC() sps_range_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
Definition: cbs_h265_syntax_template.c:693
H265RawSEIActiveParameterSets
Definition: cbs_h265.h:629
se
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:263
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
HEADER
#define HEADER(name)
Definition: cbs_av1.c:537
ref_pic_lists_modification
static int FUNC() ref_pic_lists_modification(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current, unsigned int num_pic_total_curr)
Definition: cbs_h265_syntax_template.c:1138
H265RawVUI
Definition: cbs_h265.h:135
infer
#define infer(name, value)
Definition: cbs_av1.c:713
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
H265RawSEI
Definition: cbs_h265.h:720
sei_buffering_period
static int FUNC() sei_buffering_period(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIBufferingPeriod *current, uint32_t *payload_size)
Definition: cbs_h265_syntax_template.c:1565
sei_payload
static int FUNC() sei_payload(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPayload *current, int prefix)
Definition: cbs_h265_syntax_template.c:2063
CodedBitstreamH265Context::sps
H265RawSPS * sps[HEVC_MAX_SPS_COUNT]
Definition: cbs_h265.h:737
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:168
H265RawSTRefPicSet::used_by_curr_pic_s1_flag
uint8_t used_by_curr_pic_s1_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:242
chroma
static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)
Definition: vf_waveform.c:1511
H265RawSEIPanScanRect
Definition: cbs_h265.h:588
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:412
H265RawSEIDecodedPictureHash
Definition: cbs_h265.h:638
H265RawHRDParameters::sub_pic_hrd_params_present_flag
uint8_t sub_pic_hrd_params_present_flag
Definition: cbs_h265.h:112
ses
#define ses(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
sei_alternative_transfer_characteristics
static int FUNC() sei_alternative_transfer_characteristics(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIAlternativeTransferCharacteristics *current)
Definition: cbs_h265_syntax_template.c:2022
H265RawSPS
Definition: cbs_h265.h:252
H265RawVPS
Definition: cbs_h265.h:191
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
H265RawPPS
Definition: cbs_h265.h:354
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
vui_parameters
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H265RawVUI *current, const H265RawSPS *sps)
Definition: cbs_h265_syntax_template.c:319
sei_decoded_picture_hash
static int FUNC() sei_decoded_picture_hash(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDecodedPictureHash *current)
Definition: cbs_h265_syntax_template.c:1905
HEVC_MAX_DPB_SIZE
@ HEVC_MAX_DPB_SIZE
Definition: hevc.h:117
H265RawSTRefPicSet::used_by_curr_pic_s0_flag
uint8_t used_by_curr_pic_s0_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:240
st_ref_pic_set
static int FUNC() st_ref_pic_set(CodedBitstreamContext *ctx, RWContext *rw, H265RawSTRefPicSet *current, int st_rps_idx, const H265RawSPS *sps)
Definition: cbs_h265_syntax_template.c:513
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
start
void INT64 start
Definition: avisynth_c.h:767
HEVC_MAX_WIDTH
@ HEVC_MAX_WIDTH
Definition: hevc.h:138
H265RawHRDParameters::vcl_hrd_parameters_present_flag
uint8_t vcl_hrd_parameters_present_flag
Definition: cbs_h265.h:110
H265RawSEIPicTiming
Definition: cbs_h265.h:572
GetBitContext
Definition: get_bits.h:61
ub
#define ub(width, name)
Definition: cbs_h2645.c:254
slice_segment_header
static int FUNC() slice_segment_header(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current)
Definition: cbs_h265_syntax_template.c:1264
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:257
HEVC_MAX_ENTRY_POINT_OFFSETS
@ HEVC_MAX_ENTRY_POINT_OFFSETS
Definition: hevc.h:156
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:266
sei_content_light_level
static int FUNC() sei_content_light_level(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIContentLightLevelInfo *current)
Definition: cbs_h265_syntax_template.c:2009
nal_unit_header
static int FUNC() nal_unit_header(CodedBitstreamContext *ctx, RWContext *rw, H265RawNALUnitHeader *current, int expected_nal_unit_type)
Definition: cbs_h265_syntax_template.c:30
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
HEVC_MAX_SLICE_SEGMENTS
@ HEVC_MAX_SLICE_SEGMENTS
Definition: hevc.h:147
H265RawSEIUserDataRegistered
Definition: cbs_h265.h:599
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
profile_compatible
#define profile_compatible(x)
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
Definition: cbs_h265_syntax_template.c:741
H265_MAX_SEI_PAYLOADS
@ H265_MAX_SEI_PAYLOADS
Definition: cbs_h265.h:34
H265RawSTRefPicSet::num_positive_pics
uint8_t num_positive_pics
Definition: cbs_h265.h:238
ctx
AVFormatContext * ctx
Definition: movenc.c:48
H265RawSEIDisplayOrientation
Definition: cbs_h265.h:620
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:98
PutBitContext
Definition: put_bits.h:35
H265RawSEIRecoveryPoint
Definition: cbs_h265.h:614
HEVC_NAL_IDR_N_LP
@ HEVC_NAL_IDR_N_LP
Definition: hevc.h:49
sei_recovery_point
static int FUNC() sei_recovery_point(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIRecoveryPoint *current)
Definition: cbs_h265_syntax_template.c:1836
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
NULL
#define NULL
Definition: coverity.c:32
sei_mastering_display
static int FUNC() sei_mastering_display(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIMasteringDisplayColourVolume *current)
Definition: cbs_h265_syntax_template.c:1986
H265RawAUD
Definition: cbs_h265.h:445
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
HEVC_NAL_PPS
@ HEVC_NAL_PPS
Definition: hevc.h:63
HEVC_MAX_SPS_COUNT
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:112
HEVC_NAL_SEI_SUFFIX
@ HEVC_NAL_SEI_SUFFIX
Definition: hevc.h:69
pps_scc_extension
static int FUNC() pps_scc_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
Definition: cbs_h265_syntax_template.c:959
H265RawSEIUserDataUnregistered
Definition: cbs_h265.h:607
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:420
HEVC_MAX_LONG_TERM_REF_PICS
@ HEVC_MAX_LONG_TERM_REF_PICS
Definition: hevc.h:124
H265RawHRDParameters::sub_pic_cpb_params_in_pic_timing_sei_flag
uint8_t sub_pic_cpb_params_in_pic_timing_sei_flag
Definition: cbs_h265.h:115
H265RawNALUnitHeader
Definition: cbs_h265.h:37
H265RawHRDParameters::cpb_cnt_minus1
uint8_t cpb_cnt_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:130
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
H265RawSubLayerHRDParameters
Definition: cbs_h265.h:100
HEVC_MAX_VPS_COUNT
@ HEVC_MAX_VPS_COUNT
Definition: hevc.h:110
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H265RawAUD *current)
Definition: cbs_h265_syntax_template.c:1122
H265RawHRDParameters::dpb_output_delay_du_length_minus1
uint8_t dpb_output_delay_du_length_minus1
Definition: cbs_h265.h:116
HEVC_MAX_TILE_ROWS
@ HEVC_MAX_TILE_ROWS
Definition: hevc.h:142
sei_user_data_registered
static int FUNC() sei_user_data_registered(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIUserDataRegistered *current, uint32_t *payload_size)
Definition: cbs_h265_syntax_template.c:1772
sei_alpha_channel_info
static int FUNC() sei_alpha_channel_info(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIAlphaChannelInfo *current)
Definition: cbs_h265_syntax_template.c:2035
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current)
Definition: cbs_h265_syntax_template.c:1164
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
HEVC_NAL_IRAP_VCL23
@ HEVC_NAL_IRAP_VCL23
Definition: hevc.h:52
HEVC_NAL_BLA_W_LP
@ HEVC_NAL_BLA_W_LP
Definition: hevc.h:45
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:176
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
Definition: cbs_h265_syntax_template.c:999
H265RawHRDParameters
Definition: cbs_h265.h:108
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
H265RawHRDParameters::initial_cpb_removal_delay_length_minus1
uint8_t initial_cpb_removal_delay_length_minus1
Definition: cbs_h265.h:122
rbsp_trailing_bits
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h265_syntax_template.c:19
H265RawSEIPayload
Definition: cbs_h265.h:693
H265RawSliceHeader
Definition: cbs_h265.h:451
flag
#define flag(name)
Definition: cbs_av1.c:557
H265RawHRDParameters::du_cpb_removal_delay_increment_length_minus1
uint8_t du_cpb_removal_delay_increment_length_minus1
Definition: cbs_h265.h:114
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEI *current, int prefix)
Definition: cbs_h265_syntax_template.c:2154
HEVC_MAX_HEIGHT
@ HEVC_MAX_HEIGHT
Definition: hevc.h:139
H265RawSEIContentLightLevelInfo
Definition: cbs_h265.h:673
ubs
#define ubs(width, name, subs,...)
Definition: cbs_h2645.c:268
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
HEVC_MAX_SHORT_TERM_REF_PIC_SETS
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:122
byte_alignment
static int FUNC() byte_alignment(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h265_syntax_template.c:50
HEVC_SLICE_P
@ HEVC_SLICE_P
Definition: hevc.h:97
pps_range_extension
static int FUNC() pps_range_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
Definition: cbs_h265_syntax_template.c:931
uint8_t
uint8_t
Definition: audio_convert.c:194
H265RawSTRefPicSet
Definition: cbs_h265.h:227
H265RawProfileTierLevel
Definition: cbs_h265.h:43
H265RawScalingList
Definition: cbs_h265.h:245
H265RawHRDParameters::nal_hrd_parameters_present_flag
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h265.h:109
H265RawPSExtensionData
Definition: cbs_h265.h:185
CodedBitstreamH265Context::active_sps
const H265RawSPS * active_sps
Definition: cbs_h265.h:744
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
HEVC_NAL_IDR_W_RADL
@ HEVC_NAL_IDR_W_RADL
Definition: hevc.h:48
CodedBitstreamH265Context::pps
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
Definition: cbs_h265.h:738
sei_pan_scan_rect
static int FUNC() sei_pan_scan_rect(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPanScanRect *current)
Definition: cbs_h265_syntax_template.c:1746
scaling_list_data
static int FUNC() scaling_list_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawScalingList *current)
Definition: cbs_h265_syntax_template.c:662
sei_pic_timing
static int FUNC() sei_pic_timing(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPicTiming *current)
Definition: cbs_h265_syntax_template.c:1671
CodedBitstreamH265Context::active_pps
const H265RawPPS * active_pps
Definition: cbs_h265.h:745
HEVC_NAL_AUD
@ HEVC_NAL_AUD
Definition: hevc.h:64
H265RawSTRefPicSet::num_negative_pics
uint8_t num_negative_pics
Definition: cbs_h265.h:237
sei_user_data_unregistered
static int FUNC() sei_user_data_unregistered(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIUserDataUnregistered *current, uint32_t *payload_size)
Definition: cbs_h265_syntax_template.c:1806
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
sei_time_code
static int FUNC() sei_time_code(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEITimeCode *current)
Definition: cbs_h265_syntax_template.c:1936
H265RawSEIAlternativeTransferCharacteristics
Definition: cbs_h265.h:678
HEVC_MAX_LAYERS
@ HEVC_MAX_LAYERS
Definition: hevc.h:103
CodedBitstreamH265Context::active_vps
const H265RawVPS * active_vps
Definition: cbs_h265.h:743
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
HEVC_MAX_TILE_COLUMNS
@ HEVC_MAX_TILE_COLUMNS
Definition: hevc.h:144
HEVC_NAL_SPS
@ HEVC_NAL_SPS
Definition: hevc.h:62
hrd_parameters
static int FUNC() hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H265RawHRDParameters *current, int common_inf_present_flag, int max_num_sub_layers_minus1)
Definition: cbs_h265_syntax_template.c:254
sei_active_parameter_sets
static int FUNC() sei_active_parameter_sets(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIActiveParameterSets *current)
Definition: cbs_h265_syntax_template.c:1869
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:570
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
length
const char int length
Definition: avisynth_c.h:860
H265RawSEIMasteringDisplayColourVolume
Definition: cbs_h265.h:664
ues
#define ues(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:272
sub_layer_hrd_parameters
static int FUNC() sub_layer_hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H265RawHRDParameters *hrd, int nal, int sub_layer_id)
Definition: cbs_h265_syntax_template.c:229
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:374
RWContext
#define RWContext
Definition: cbs_av1.c:666
HEVC_NAL_SEI_PREFIX
@ HEVC_NAL_SEI_PREFIX
Definition: hevc.h:68
SEI_TYPE_S
#define SEI_TYPE_S(type, prefix_valid, suffix_valid, name)
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1370
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ibs
#define ibs(width, name, subs,...)
Definition: cbs_h2645.c:276
H265RawSEIBufferingPeriod
Definition: cbs_h265.h:551
sei_display_orientation
static int FUNC() sei_display_orientation(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDisplayOrientation *current)
Definition: cbs_h265_syntax_template.c:1851
HEVC_MAX_LAYER_SETS
@ HEVC_MAX_LAYER_SETS
Definition: hevc.h:107
H265RawSEIAlphaChannelInfo
Definition: cbs_h265.h:682
cbs_h2645_read_more_rbsp_data
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
Definition: cbs_h2645.c:325
extension_data
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawPSExtensionData *current)
Definition: cbs_h265_syntax_template.c:61
CodedBitstreamH265Context
Definition: cbs_h265.h:727