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  H265RawExtensionData *current)
63 {
64  int err;
65  size_t k;
66 #ifdef READ
67  GetBitContext start;
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, num_ref_pics;
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  av_assert0(num_delta_pocs < HEVC_MAX_DPB_SIZE);
542 
543  flag(delta_rps_sign);
544  ue(abs_delta_rps_minus1, 0, INT16_MAX);
545  delta_rps = (1 - 2 * current->delta_rps_sign) *
546  (current->abs_delta_rps_minus1 + 1);
547 
548  num_ref_pics = 0;
549  for (j = 0; j <= num_delta_pocs; j++) {
550  flags(used_by_curr_pic_flag[j], 1, j);
551  if (!current->used_by_curr_pic_flag[j])
552  flags(use_delta_flag[j], 1, j);
553  else
554  infer(use_delta_flag[j], 1);
555  if (current->use_delta_flag[j])
556  ++num_ref_pics;
557  }
558  if (num_ref_pics >= HEVC_MAX_DPB_SIZE) {
559  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
560  "short-term ref pic set %d "
561  "contains too many pictures.\n", st_rps_idx);
562  return AVERROR_INVALIDDATA;
563  }
564 
565  // Since the stored form of an RPS here is actually the delta-step
566  // form used when inter_ref_pic_set_prediction_flag is not set, we
567  // need to reconstruct that here in order to be able to refer to
568  // the RPS later (which is required for parsing, because we don't
569  // even know what syntax elements appear without it). Therefore,
570  // this code takes the delta-step form of the reference set, turns
571  // it into the delta-array form, applies the prediction process of
572  // 7.4.8, converts the result back to the delta-step form, and
573  // stores that as the current set for future use. Note that the
574  // inferences here mean that writers using prediction will need
575  // to fill in the delta-step values correctly as well - since the
576  // whole RPS prediction process is somewhat overly sophisticated,
577  // this hopefully forms a useful check for them to ensure their
578  // predicted form actually matches what was intended rather than
579  // an onerous additional requirement.
580 
581  d_poc = 0;
582  for (i = 0; i < ref->num_negative_pics; i++) {
583  d_poc -= ref->delta_poc_s0_minus1[i] + 1;
584  ref_delta_poc_s0[i] = d_poc;
585  }
586  d_poc = 0;
587  for (i = 0; i < ref->num_positive_pics; i++) {
588  d_poc += ref->delta_poc_s1_minus1[i] + 1;
589  ref_delta_poc_s1[i] = d_poc;
590  }
591 
592  i = 0;
593  for (j = ref->num_positive_pics - 1; j >= 0; j--) {
594  d_poc = ref_delta_poc_s1[j] + delta_rps;
595  if (d_poc < 0 && current->use_delta_flag[ref->num_negative_pics + j]) {
596  delta_poc_s0[i] = d_poc;
597  used_by_curr_pic_s0[i++] =
598  current->used_by_curr_pic_flag[ref->num_negative_pics + j];
599  }
600  }
601  if (delta_rps < 0 && current->use_delta_flag[num_delta_pocs]) {
602  delta_poc_s0[i] = delta_rps;
603  used_by_curr_pic_s0[i++] =
604  current->used_by_curr_pic_flag[num_delta_pocs];
605  }
606  for (j = 0; j < ref->num_negative_pics; j++) {
607  d_poc = ref_delta_poc_s0[j] + delta_rps;
608  if (d_poc < 0 && current->use_delta_flag[j]) {
609  delta_poc_s0[i] = d_poc;
610  used_by_curr_pic_s0[i++] = current->used_by_curr_pic_flag[j];
611  }
612  }
613 
614  infer(num_negative_pics, i);
615  for (i = 0; i < current->num_negative_pics; i++) {
616  infer(delta_poc_s0_minus1[i],
617  -(delta_poc_s0[i] - (i == 0 ? 0 : delta_poc_s0[i - 1])) - 1);
618  infer(used_by_curr_pic_s0_flag[i], used_by_curr_pic_s0[i]);
619  }
620 
621  i = 0;
622  for (j = ref->num_negative_pics - 1; j >= 0; j--) {
623  d_poc = ref_delta_poc_s0[j] + delta_rps;
624  if (d_poc > 0 && current->use_delta_flag[j]) {
625  delta_poc_s1[i] = d_poc;
626  used_by_curr_pic_s1[i++] = current->used_by_curr_pic_flag[j];
627  }
628  }
629  if (delta_rps > 0 && current->use_delta_flag[num_delta_pocs]) {
630  delta_poc_s1[i] = delta_rps;
631  used_by_curr_pic_s1[i++] =
632  current->used_by_curr_pic_flag[num_delta_pocs];
633  }
634  for (j = 0; j < ref->num_positive_pics; j++) {
635  d_poc = ref_delta_poc_s1[j] + delta_rps;
636  if (d_poc > 0 && current->use_delta_flag[ref->num_negative_pics + j]) {
637  delta_poc_s1[i] = d_poc;
638  used_by_curr_pic_s1[i++] =
639  current->used_by_curr_pic_flag[ref->num_negative_pics + j];
640  }
641  }
642 
643  infer(num_positive_pics, i);
644  for (i = 0; i < current->num_positive_pics; i++) {
645  infer(delta_poc_s1_minus1[i],
646  delta_poc_s1[i] - (i == 0 ? 0 : delta_poc_s1[i - 1]) - 1);
647  infer(used_by_curr_pic_s1_flag[i], used_by_curr_pic_s1[i]);
648  }
649 
650  } else {
651  ue(num_negative_pics, 0, 15);
652  ue(num_positive_pics, 0, 15 - current->num_negative_pics);
653 
654  for (i = 0; i < current->num_negative_pics; i++) {
655  ues(delta_poc_s0_minus1[i], 0, INT16_MAX, 1, i);
656  flags(used_by_curr_pic_s0_flag[i], 1, i);
657  }
658 
659  for (i = 0; i < current->num_positive_pics; i++) {
660  ues(delta_poc_s1_minus1[i], 0, INT16_MAX, 1, i);
661  flags(used_by_curr_pic_s1_flag[i], 1, i);
662  }
663  }
664 
665  return 0;
666 }
667 
669  H265RawScalingList *current)
670 {
671  int sizeId, matrixId;
672  int err, n, i;
673 
674  for (sizeId = 0; sizeId < 4; sizeId++) {
675  for (matrixId = 0; matrixId < 6; matrixId += (sizeId == 3 ? 3 : 1)) {
676  flags(scaling_list_pred_mode_flag[sizeId][matrixId],
677  2, sizeId, matrixId);
678  if (!current->scaling_list_pred_mode_flag[sizeId][matrixId]) {
679  ues(scaling_list_pred_matrix_id_delta[sizeId][matrixId],
680  0, sizeId == 3 ? matrixId / 3 : matrixId,
681  2, sizeId, matrixId);
682  } else {
683  n = FFMIN(64, 1 << (4 + (sizeId << 1)));
684  if (sizeId > 1) {
685  ses(scaling_list_dc_coef_minus8[sizeId - 2][matrixId], -7, +247,
686  2, sizeId - 2, matrixId);
687  }
688  for (i = 0; i < n; i++) {
689  ses(scaling_list_delta_coeff[sizeId][matrixId][i],
690  -128, +127, 3, sizeId, matrixId, i);
691  }
692  }
693  }
694  }
695 
696  return 0;
697 }
698 
700  H265RawSPS *current)
701 {
702  int err;
703 
704  flag(transform_skip_rotation_enabled_flag);
705  flag(transform_skip_context_enabled_flag);
706  flag(implicit_rdpcm_enabled_flag);
707  flag(explicit_rdpcm_enabled_flag);
708  flag(extended_precision_processing_flag);
709  flag(intra_smoothing_disabled_flag);
710  flag(high_precision_offsets_enabled_flag);
711  flag(persistent_rice_adaptation_enabled_flag);
712  flag(cabac_bypass_alignment_enabled_flag);
713 
714  return 0;
715 }
716 
718  H265RawSPS *current)
719 {
720  int err, comp, i;
721 
722  flag(sps_curr_pic_ref_enabled_flag);
723 
724  flag(palette_mode_enabled_flag);
725  if (current->palette_mode_enabled_flag) {
726  ue(palette_max_size, 0, 64);
727  ue(delta_palette_max_predictor_size, 0, 128);
728 
729  flag(sps_palette_predictor_initializer_present_flag);
730  if (current->sps_palette_predictor_initializer_present_flag) {
731  ue(sps_num_palette_predictor_initializer_minus1, 0, 128);
732  for (comp = 0; comp < (current->chroma_format_idc ? 3 : 1); comp++) {
733  int bit_depth = comp == 0 ? current->bit_depth_luma_minus8 + 8
734  : current->bit_depth_chroma_minus8 + 8;
735  for (i = 0; i <= current->sps_num_palette_predictor_initializer_minus1; i++)
736  ubs(bit_depth, sps_palette_predictor_initializers[comp][i], 2, comp, i);
737  }
738  }
739  }
740 
741  u(2, motion_vector_resolution_control_idc, 0, 2);
742  flag(intra_boundary_filtering_disable_flag);
743 
744  return 0;
745 }
746 
748  RWContext *rw, H265RawVUI *current,
749  H265RawSPS *sps)
750 {
751  infer(aspect_ratio_idc, 0);
752 
753  infer(video_format, 5);
754  infer(video_full_range_flag, 0);
755  infer(colour_primaries, 2);
757  infer(matrix_coefficients, 2);
758 
759  infer(chroma_sample_loc_type_top_field, 0);
760  infer(chroma_sample_loc_type_bottom_field, 0);
761 
762  infer(tiles_fixed_structure_flag, 0);
763  infer(motion_vectors_over_pic_boundaries_flag, 1);
764  infer(min_spatial_segmentation_idc, 0);
765  infer(max_bytes_per_pic_denom, 2);
766  infer(max_bits_per_min_cu_denom, 1);
767  infer(log2_max_mv_length_horizontal, 15);
768  infer(log2_max_mv_length_vertical, 15);
769 
770  return 0;
771 }
772 
774  H265RawSPS *current)
775 {
777  const H265RawVPS *vps;
778  int err, i;
779  unsigned int min_cb_log2_size_y, ctb_log2_size_y,
780  min_cb_size_y, min_tb_log2_size_y;
781 
782  HEADER("Sequence Parameter Set");
783 
784  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_SPS));
785 
786  ub(4, sps_video_parameter_set_id);
787  h265->active_vps = vps = h265->vps[current->sps_video_parameter_set_id];
788 
789  u(3, sps_max_sub_layers_minus1, 0, HEVC_MAX_SUB_LAYERS - 1);
790  flag(sps_temporal_id_nesting_flag);
791  if (vps) {
792  if (vps->vps_max_sub_layers_minus1 > current->sps_max_sub_layers_minus1) {
793  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
794  "sps_max_sub_layers_minus1 (%d) must be less than or equal to "
795  "vps_max_sub_layers_minus1 (%d).\n",
796  vps->vps_max_sub_layers_minus1,
797  current->sps_max_sub_layers_minus1);
798  return AVERROR_INVALIDDATA;
799  }
800  if (vps->vps_temporal_id_nesting_flag &&
801  !current->sps_temporal_id_nesting_flag) {
802  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
803  "sps_temporal_id_nesting_flag must be 1 if "
804  "vps_temporal_id_nesting_flag is 1.\n");
805  return AVERROR_INVALIDDATA;
806  }
807  }
808 
809  CHECK(FUNC(profile_tier_level)(ctx, rw, &current->profile_tier_level,
810  1, current->sps_max_sub_layers_minus1));
811 
812  ue(sps_seq_parameter_set_id, 0, 15);
813 
814  ue(chroma_format_idc, 0, 3);
815  if (current->chroma_format_idc == 3)
816  flag(separate_colour_plane_flag);
817  else
818  infer(separate_colour_plane_flag, 0);
819 
820  ue(pic_width_in_luma_samples, 1, HEVC_MAX_WIDTH);
821  ue(pic_height_in_luma_samples, 1, HEVC_MAX_HEIGHT);
822 
823  flag(conformance_window_flag);
824  if (current->conformance_window_flag) {
825  ue(conf_win_left_offset, 0, current->pic_width_in_luma_samples);
826  ue(conf_win_right_offset, 0, current->pic_width_in_luma_samples);
827  ue(conf_win_top_offset, 0, current->pic_height_in_luma_samples);
828  ue(conf_win_bottom_offset, 0, current->pic_height_in_luma_samples);
829  } else {
830  infer(conf_win_left_offset, 0);
831  infer(conf_win_right_offset, 0);
832  infer(conf_win_top_offset, 0);
833  infer(conf_win_bottom_offset, 0);
834  }
835 
836  ue(bit_depth_luma_minus8, 0, 8);
837  ue(bit_depth_chroma_minus8, 0, 8);
838 
839  ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
840 
841  flag(sps_sub_layer_ordering_info_present_flag);
842  for (i = (current->sps_sub_layer_ordering_info_present_flag ?
843  0 : current->sps_max_sub_layers_minus1);
844  i <= current->sps_max_sub_layers_minus1; i++) {
845  ues(sps_max_dec_pic_buffering_minus1[i],
846  0, HEVC_MAX_DPB_SIZE - 1, 1, i);
847  ues(sps_max_num_reorder_pics[i],
848  0, current->sps_max_dec_pic_buffering_minus1[i], 1, i);
849  ues(sps_max_latency_increase_plus1[i],
850  0, UINT32_MAX - 1, 1, i);
851  }
852  if (!current->sps_sub_layer_ordering_info_present_flag) {
853  for (i = 0; i < current->sps_max_sub_layers_minus1; i++) {
854  infer(sps_max_dec_pic_buffering_minus1[i],
855  current->sps_max_dec_pic_buffering_minus1[current->sps_max_sub_layers_minus1]);
856  infer(sps_max_num_reorder_pics[i],
857  current->sps_max_num_reorder_pics[current->sps_max_sub_layers_minus1]);
858  infer(sps_max_latency_increase_plus1[i],
859  current->sps_max_latency_increase_plus1[current->sps_max_sub_layers_minus1]);
860  }
861  }
862 
863  ue(log2_min_luma_coding_block_size_minus3, 0, 3);
864  min_cb_log2_size_y = current->log2_min_luma_coding_block_size_minus3 + 3;
865 
866  ue(log2_diff_max_min_luma_coding_block_size, 0, 3);
867  ctb_log2_size_y = min_cb_log2_size_y +
868  current->log2_diff_max_min_luma_coding_block_size;
869 
870  min_cb_size_y = 1 << min_cb_log2_size_y;
871  if (current->pic_width_in_luma_samples % min_cb_size_y ||
872  current->pic_height_in_luma_samples % min_cb_size_y) {
873  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid dimensions: %ux%u not divisible "
874  "by MinCbSizeY = %u.\n", current->pic_width_in_luma_samples,
875  current->pic_height_in_luma_samples, min_cb_size_y);
876  return AVERROR_INVALIDDATA;
877  }
878 
879  ue(log2_min_luma_transform_block_size_minus2, 0, min_cb_log2_size_y - 3);
880  min_tb_log2_size_y = current->log2_min_luma_transform_block_size_minus2 + 2;
881 
882  ue(log2_diff_max_min_luma_transform_block_size,
883  0, FFMIN(ctb_log2_size_y, 5) - min_tb_log2_size_y);
884 
885  ue(max_transform_hierarchy_depth_inter,
886  0, ctb_log2_size_y - min_tb_log2_size_y);
887  ue(max_transform_hierarchy_depth_intra,
888  0, ctb_log2_size_y - min_tb_log2_size_y);
889 
890  flag(scaling_list_enabled_flag);
891  if (current->scaling_list_enabled_flag) {
892  flag(sps_scaling_list_data_present_flag);
893  if (current->sps_scaling_list_data_present_flag)
894  CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
895  } else {
896  infer(sps_scaling_list_data_present_flag, 0);
897  }
898 
899  flag(amp_enabled_flag);
900  flag(sample_adaptive_offset_enabled_flag);
901 
902  flag(pcm_enabled_flag);
903  if (current->pcm_enabled_flag) {
904  u(4, pcm_sample_bit_depth_luma_minus1,
905  0, current->bit_depth_luma_minus8 + 8 - 1);
906  u(4, pcm_sample_bit_depth_chroma_minus1,
907  0, current->bit_depth_chroma_minus8 + 8 - 1);
908 
909  ue(log2_min_pcm_luma_coding_block_size_minus3,
910  FFMIN(min_cb_log2_size_y, 5) - 3, FFMIN(ctb_log2_size_y, 5) - 3);
911  ue(log2_diff_max_min_pcm_luma_coding_block_size,
912  0, FFMIN(ctb_log2_size_y, 5) - (current->log2_min_pcm_luma_coding_block_size_minus3 + 3));
913 
914  flag(pcm_loop_filter_disabled_flag);
915  }
916 
917  ue(num_short_term_ref_pic_sets, 0, HEVC_MAX_SHORT_TERM_REF_PIC_SETS);
918  for (i = 0; i < current->num_short_term_ref_pic_sets; i++)
919  CHECK(FUNC(st_ref_pic_set)(ctx, rw, &current->st_ref_pic_set[i], i, current));
920 
921  flag(long_term_ref_pics_present_flag);
922  if (current->long_term_ref_pics_present_flag) {
923  ue(num_long_term_ref_pics_sps, 0, HEVC_MAX_LONG_TERM_REF_PICS);
924  for (i = 0; i < current->num_long_term_ref_pics_sps; i++) {
925  ubs(current->log2_max_pic_order_cnt_lsb_minus4 + 4,
926  lt_ref_pic_poc_lsb_sps[i], 1, i);
927  flags(used_by_curr_pic_lt_sps_flag[i], 1, i);
928  }
929  }
930 
931  flag(sps_temporal_mvp_enabled_flag);
932  flag(strong_intra_smoothing_enabled_flag);
933 
934  flag(vui_parameters_present_flag);
935  if (current->vui_parameters_present_flag)
936  CHECK(FUNC(vui_parameters)(ctx, rw, &current->vui, current));
937  else
938  CHECK(FUNC(vui_parameters_default)(ctx, rw, &current->vui, current));
939 
940  flag(sps_extension_present_flag);
941  if (current->sps_extension_present_flag) {
942  flag(sps_range_extension_flag);
943  flag(sps_multilayer_extension_flag);
944  flag(sps_3d_extension_flag);
945  flag(sps_scc_extension_flag);
946  ub(4, sps_extension_4bits);
947  }
948 
949  if (current->sps_range_extension_flag)
950  CHECK(FUNC(sps_range_extension)(ctx, rw, current));
951  if (current->sps_multilayer_extension_flag)
952  return AVERROR_PATCHWELCOME;
953  if (current->sps_3d_extension_flag)
954  return AVERROR_PATCHWELCOME;
955  if (current->sps_scc_extension_flag)
956  CHECK(FUNC(sps_scc_extension)(ctx, rw, current));
957  if (current->sps_extension_4bits)
958  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
959 
961 
962  return 0;
963 }
964 
966  H265RawPPS *current)
967 {
969  const H265RawSPS *sps = h265->active_sps;
970  int err, i;
971 
972  if (current->transform_skip_enabled_flag)
973  ue(log2_max_transform_skip_block_size_minus2, 0, 3);
974  flag(cross_component_prediction_enabled_flag);
975 
976  flag(chroma_qp_offset_list_enabled_flag);
977  if (current->chroma_qp_offset_list_enabled_flag) {
978  ue(diff_cu_chroma_qp_offset_depth,
979  0, sps->log2_diff_max_min_luma_coding_block_size);
980  ue(chroma_qp_offset_list_len_minus1, 0, 5);
981  for (i = 0; i <= current->chroma_qp_offset_list_len_minus1; i++) {
982  ses(cb_qp_offset_list[i], -12, +12, 1, i);
983  ses(cr_qp_offset_list[i], -12, +12, 1, i);
984  }
985  }
986 
987  ue(log2_sao_offset_scale_luma, 0, FFMAX(0, sps->bit_depth_luma_minus8 - 2));
988  ue(log2_sao_offset_scale_chroma, 0, FFMAX(0, sps->bit_depth_chroma_minus8 - 2));
989 
990  return 0;
991 }
992 
994  H265RawPPS *current)
995 {
996  int err, comp, i;
997 
998  flag(pps_curr_pic_ref_enabled_flag);
999 
1000  flag(residual_adaptive_colour_transform_enabled_flag);
1001  if (current->residual_adaptive_colour_transform_enabled_flag) {
1002  flag(pps_slice_act_qp_offsets_present_flag);
1003  se(pps_act_y_qp_offset_plus5, -7, +17);
1004  se(pps_act_cb_qp_offset_plus5, -7, +17);
1005  se(pps_act_cr_qp_offset_plus3, -9, +15);
1006  } else {
1007  infer(pps_slice_act_qp_offsets_present_flag, 0);
1008  infer(pps_act_y_qp_offset_plus5, 0);
1009  infer(pps_act_cb_qp_offset_plus5, 0);
1010  infer(pps_act_cr_qp_offset_plus3, 0);
1011  }
1012 
1013  flag(pps_palette_predictor_initializer_present_flag);
1014  if (current->pps_palette_predictor_initializer_present_flag) {
1015  ue(pps_num_palette_predictor_initializer, 0, 128);
1016  if (current->pps_num_palette_predictor_initializer > 0) {
1017  flag(monochrome_palette_flag);
1018  ue(luma_bit_depth_entry_minus8, 0, 8);
1019  if (!current->monochrome_palette_flag)
1020  ue(chroma_bit_depth_entry_minus8, 0, 8);
1021  for (comp = 0; comp < (current->monochrome_palette_flag ? 1 : 3); comp++) {
1022  int bit_depth = comp == 0 ? current->luma_bit_depth_entry_minus8 + 8
1023  : current->chroma_bit_depth_entry_minus8 + 8;
1024  for (i = 0; i < current->pps_num_palette_predictor_initializer; i++)
1025  ubs(bit_depth, pps_palette_predictor_initializers[comp][i], 2, comp, i);
1026  }
1027  }
1028  }
1029 
1030  return 0;
1031 }
1032 
1034  H265RawPPS *current)
1035 {
1037  const H265RawSPS *sps;
1038  int err, i;
1039 
1040  HEADER("Picture Parameter Set");
1041 
1042  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_PPS));
1043 
1044  ue(pps_pic_parameter_set_id, 0, 63);
1045  ue(pps_seq_parameter_set_id, 0, 15);
1046  sps = h265->sps[current->pps_seq_parameter_set_id];
1047  if (!sps) {
1048  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1049  current->pps_seq_parameter_set_id);
1050  return AVERROR_INVALIDDATA;
1051  }
1052  h265->active_sps = sps;
1053 
1054  flag(dependent_slice_segments_enabled_flag);
1055  flag(output_flag_present_flag);
1056  ub(3, num_extra_slice_header_bits);
1057  flag(sign_data_hiding_enabled_flag);
1058  flag(cabac_init_present_flag);
1059 
1060  ue(num_ref_idx_l0_default_active_minus1, 0, 14);
1061  ue(num_ref_idx_l1_default_active_minus1, 0, 14);
1062 
1063  se(init_qp_minus26, -(26 + 6 * sps->bit_depth_luma_minus8), +25);
1064 
1065  flag(constrained_intra_pred_flag);
1066  flag(transform_skip_enabled_flag);
1067  flag(cu_qp_delta_enabled_flag);
1068  if (current->cu_qp_delta_enabled_flag)
1069  ue(diff_cu_qp_delta_depth,
1070  0, sps->log2_diff_max_min_luma_coding_block_size);
1071  else
1072  infer(diff_cu_qp_delta_depth, 0);
1073 
1074  se(pps_cb_qp_offset, -12, +12);
1075  se(pps_cr_qp_offset, -12, +12);
1076  flag(pps_slice_chroma_qp_offsets_present_flag);
1077 
1078  flag(weighted_pred_flag);
1079  flag(weighted_bipred_flag);
1080 
1081  flag(transquant_bypass_enabled_flag);
1082  flag(tiles_enabled_flag);
1083  flag(entropy_coding_sync_enabled_flag);
1084 
1085  if (current->tiles_enabled_flag) {
1086  ue(num_tile_columns_minus1, 0, HEVC_MAX_TILE_COLUMNS);
1087  ue(num_tile_rows_minus1, 0, HEVC_MAX_TILE_ROWS);
1088  flag(uniform_spacing_flag);
1089  if (!current->uniform_spacing_flag) {
1090  for (i = 0; i < current->num_tile_columns_minus1; i++)
1091  ues(column_width_minus1[i], 0, sps->pic_width_in_luma_samples, 1, i);
1092  for (i = 0; i < current->num_tile_rows_minus1; i++)
1093  ues(row_height_minus1[i], 0, sps->pic_height_in_luma_samples, 1, i);
1094  }
1095  flag(loop_filter_across_tiles_enabled_flag);
1096  } else {
1097  infer(num_tile_columns_minus1, 0);
1098  infer(num_tile_rows_minus1, 0);
1099  }
1100 
1101  flag(pps_loop_filter_across_slices_enabled_flag);
1102  flag(deblocking_filter_control_present_flag);
1103  if (current->deblocking_filter_control_present_flag) {
1104  flag(deblocking_filter_override_enabled_flag);
1105  flag(pps_deblocking_filter_disabled_flag);
1106  if (!current->pps_deblocking_filter_disabled_flag) {
1107  se(pps_beta_offset_div2, -6, +6);
1108  se(pps_tc_offset_div2, -6, +6);
1109  } else {
1110  infer(pps_beta_offset_div2, 0);
1111  infer(pps_tc_offset_div2, 0);
1112  }
1113  } else {
1114  infer(deblocking_filter_override_enabled_flag, 0);
1115  infer(pps_deblocking_filter_disabled_flag, 0);
1116  infer(pps_beta_offset_div2, 0);
1117  infer(pps_tc_offset_div2, 0);
1118  }
1119 
1120  flag(pps_scaling_list_data_present_flag);
1121  if (current->pps_scaling_list_data_present_flag)
1122  CHECK(FUNC(scaling_list_data)(ctx, rw, &current->scaling_list));
1123 
1124  flag(lists_modification_present_flag);
1125 
1126  ue(log2_parallel_merge_level_minus2,
1127  0, (sps->log2_min_luma_coding_block_size_minus3 + 3 +
1128  sps->log2_diff_max_min_luma_coding_block_size - 2));
1129 
1130  flag(slice_segment_header_extension_present_flag);
1131 
1132  flag(pps_extension_present_flag);
1133  if (current->pps_extension_present_flag) {
1134  flag(pps_range_extension_flag);
1135  flag(pps_multilayer_extension_flag);
1136  flag(pps_3d_extension_flag);
1137  flag(pps_scc_extension_flag);
1138  ub(4, pps_extension_4bits);
1139  }
1140  if (current->pps_range_extension_flag)
1141  CHECK(FUNC(pps_range_extension)(ctx, rw, current));
1142  if (current->pps_multilayer_extension_flag)
1143  return AVERROR_PATCHWELCOME;
1144  if (current->pps_3d_extension_flag)
1145  return AVERROR_PATCHWELCOME;
1146  if (current->pps_scc_extension_flag)
1147  CHECK(FUNC(pps_scc_extension)(ctx, rw, current));
1148  if (current->pps_extension_4bits)
1149  CHECK(FUNC(extension_data)(ctx, rw, &current->extension_data));
1150 
1152 
1153  return 0;
1154 }
1155 
1157  H265RawAUD *current)
1158 {
1159  int err;
1160 
1161  HEADER("Access Unit Delimiter");
1162 
1163  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, HEVC_NAL_AUD));
1164 
1165  u(3, pic_type, 0, 2);
1166 
1168 
1169  return 0;
1170 }
1171 
1173  H265RawSliceHeader *current,
1174  unsigned int num_pic_total_curr)
1175 {
1176  unsigned int entry_size;
1177  int err, i;
1178 
1179  entry_size = av_log2(num_pic_total_curr - 1) + 1;
1180 
1181  flag(ref_pic_list_modification_flag_l0);
1182  if (current->ref_pic_list_modification_flag_l0) {
1183  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++)
1184  us(entry_size, list_entry_l0[i], 0, num_pic_total_curr - 1, 1, i);
1185  }
1186 
1187  if (current->slice_type == HEVC_SLICE_B) {
1188  flag(ref_pic_list_modification_flag_l1);
1189  if (current->ref_pic_list_modification_flag_l1) {
1190  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++)
1191  us(entry_size, list_entry_l1[i], 0, num_pic_total_curr - 1, 1, i);
1192  }
1193  }
1194 
1195  return 0;
1196 }
1197 
1199  H265RawSliceHeader *current)
1200 {
1202  const H265RawSPS *sps = h265->active_sps;
1203  int err, i, j;
1204  int chroma = !sps->separate_colour_plane_flag &&
1205  sps->chroma_format_idc != 0;
1206 
1207  ue(luma_log2_weight_denom, 0, 7);
1208  if (chroma)
1209  se(delta_chroma_log2_weight_denom, -7, 7);
1210  else
1211  infer(delta_chroma_log2_weight_denom, 0);
1212 
1213  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1214  if (1 /* is not same POC and same layer_id */)
1215  flags(luma_weight_l0_flag[i], 1, i);
1216  else
1217  infer(luma_weight_l0_flag[i], 0);
1218  }
1219  if (chroma) {
1220  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1221  if (1 /* is not same POC and same layer_id */)
1222  flags(chroma_weight_l0_flag[i], 1, i);
1223  else
1224  infer(chroma_weight_l0_flag[i], 0);
1225  }
1226  }
1227 
1228  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1229  if (current->luma_weight_l0_flag[i]) {
1230  ses(delta_luma_weight_l0[i], -128, +127, 1, i);
1231  ses(luma_offset_l0[i],
1232  -(1 << (sps->bit_depth_luma_minus8 + 8 - 1)),
1233  ((1 << (sps->bit_depth_luma_minus8 + 8 - 1)) - 1), 1, i);
1234  } else {
1235  infer(delta_luma_weight_l0[i], 0);
1236  infer(luma_offset_l0[i], 0);
1237  }
1238  if (current->chroma_weight_l0_flag[i]) {
1239  for (j = 0; j < 2; j++) {
1240  ses(delta_chroma_weight_l0[i][j], -128, +127, 2, i, j);
1241  ses(chroma_offset_l0[i][j],
1242  -(4 << (sps->bit_depth_chroma_minus8 + 8 - 1)),
1243  ((4 << (sps->bit_depth_chroma_minus8 + 8 - 1)) - 1), 2, i, j);
1244  }
1245  } else {
1246  for (j = 0; j < 2; j++) {
1247  infer(delta_chroma_weight_l0[i][j], 0);
1248  infer(chroma_offset_l0[i][j], 0);
1249  }
1250  }
1251  }
1252 
1253  if (current->slice_type == HEVC_SLICE_B) {
1254  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1255  if (1 /* RefPicList1[i] is not CurrPic, nor is it in a different layer */)
1256  flags(luma_weight_l1_flag[i], 1, i);
1257  else
1258  infer(luma_weight_l1_flag[i], 0);
1259  }
1260  if (chroma) {
1261  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1262  if (1 /* RefPicList1[i] is not CurrPic, nor is it in a different layer */)
1263  flags(chroma_weight_l1_flag[i], 1, i);
1264  else
1265  infer(chroma_weight_l1_flag[i], 0);
1266  }
1267  }
1268 
1269  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1270  if (current->luma_weight_l1_flag[i]) {
1271  ses(delta_luma_weight_l1[i], -128, +127, 1, i);
1272  ses(luma_offset_l1[i],
1273  -(1 << (sps->bit_depth_luma_minus8 + 8 - 1)),
1274  ((1 << (sps->bit_depth_luma_minus8 + 8 - 1)) - 1), 1, i);
1275  } else {
1276  infer(delta_luma_weight_l1[i], 0);
1277  infer(luma_offset_l1[i], 0);
1278  }
1279  if (current->chroma_weight_l1_flag[i]) {
1280  for (j = 0; j < 2; j++) {
1281  ses(delta_chroma_weight_l1[i][j], -128, +127, 2, i, j);
1282  ses(chroma_offset_l1[i][j],
1283  -(4 << (sps->bit_depth_chroma_minus8 + 8 - 1)),
1284  ((4 << (sps->bit_depth_chroma_minus8 + 8 - 1)) - 1), 2, i, j);
1285  }
1286  } else {
1287  for (j = 0; j < 2; j++) {
1288  infer(delta_chroma_weight_l1[i][j], 0);
1289  infer(chroma_offset_l1[i][j], 0);
1290  }
1291  }
1292  }
1293  }
1294 
1295  return 0;
1296 }
1297 
1299  H265RawSliceHeader *current)
1300 {
1302  const H265RawSPS *sps;
1303  const H265RawPPS *pps;
1304  unsigned int min_cb_log2_size_y, ctb_log2_size_y, ctb_size_y;
1305  unsigned int pic_width_in_ctbs_y, pic_height_in_ctbs_y, pic_size_in_ctbs_y;
1306  unsigned int num_pic_total_curr = 0;
1307  int err, i;
1308 
1309  HEADER("Slice Segment Header");
1310 
1311  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header, -1));
1312 
1313  flag(first_slice_segment_in_pic_flag);
1314 
1315  if (current->nal_unit_header.nal_unit_type >= HEVC_NAL_BLA_W_LP &&
1316  current->nal_unit_header.nal_unit_type <= HEVC_NAL_RSV_IRAP_VCL23)
1317  flag(no_output_of_prior_pics_flag);
1318 
1319  ue(slice_pic_parameter_set_id, 0, 63);
1320 
1321  pps = h265->pps[current->slice_pic_parameter_set_id];
1322  if (!pps) {
1323  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
1324  current->slice_pic_parameter_set_id);
1325  return AVERROR_INVALIDDATA;
1326  }
1327  h265->active_pps = pps;
1328 
1329  sps = h265->sps[pps->pps_seq_parameter_set_id];
1330  if (!sps) {
1331  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1332  pps->pps_seq_parameter_set_id);
1333  return AVERROR_INVALIDDATA;
1334  }
1335  h265->active_sps = sps;
1336 
1337  min_cb_log2_size_y = sps->log2_min_luma_coding_block_size_minus3 + 3;
1338  ctb_log2_size_y = min_cb_log2_size_y + sps->log2_diff_max_min_luma_coding_block_size;
1339  ctb_size_y = 1 << ctb_log2_size_y;
1340  pic_width_in_ctbs_y =
1341  (sps->pic_width_in_luma_samples + ctb_size_y - 1) / ctb_size_y;
1342  pic_height_in_ctbs_y =
1343  (sps->pic_height_in_luma_samples + ctb_size_y - 1) / ctb_size_y;
1344  pic_size_in_ctbs_y = pic_width_in_ctbs_y * pic_height_in_ctbs_y;
1345 
1346  if (!current->first_slice_segment_in_pic_flag) {
1347  unsigned int address_size = av_log2(pic_size_in_ctbs_y - 1) + 1;
1348  if (pps->dependent_slice_segments_enabled_flag)
1349  flag(dependent_slice_segment_flag);
1350  else
1351  infer(dependent_slice_segment_flag, 0);
1352  u(address_size, slice_segment_address, 0, pic_size_in_ctbs_y - 1);
1353  } else {
1354  infer(dependent_slice_segment_flag, 0);
1355  }
1356 
1357  if (!current->dependent_slice_segment_flag) {
1358  for (i = 0; i < pps->num_extra_slice_header_bits; i++)
1359  flags(slice_reserved_flag[i], 1, i);
1360 
1361  ue(slice_type, 0, 2);
1362 
1363  if (pps->output_flag_present_flag)
1364  flag(pic_output_flag);
1365 
1366  if (sps->separate_colour_plane_flag)
1367  u(2, colour_plane_id, 0, 2);
1368 
1369  if (current->nal_unit_header.nal_unit_type != HEVC_NAL_IDR_W_RADL &&
1370  current->nal_unit_header.nal_unit_type != HEVC_NAL_IDR_N_LP) {
1371  const H265RawSTRefPicSet *rps;
1372  int dpb_slots_remaining;
1373 
1374  ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, slice_pic_order_cnt_lsb);
1375 
1376  flag(short_term_ref_pic_set_sps_flag);
1377  if (!current->short_term_ref_pic_set_sps_flag) {
1378  CHECK(FUNC(st_ref_pic_set)(ctx, rw, &current->short_term_ref_pic_set,
1379  sps->num_short_term_ref_pic_sets, sps));
1380  rps = &current->short_term_ref_pic_set;
1381  } else if (sps->num_short_term_ref_pic_sets > 1) {
1382  unsigned int idx_size = av_log2(sps->num_short_term_ref_pic_sets - 1) + 1;
1383  u(idx_size, short_term_ref_pic_set_idx,
1384  0, sps->num_short_term_ref_pic_sets - 1);
1385  rps = &sps->st_ref_pic_set[current->short_term_ref_pic_set_idx];
1386  } else {
1387  infer(short_term_ref_pic_set_idx, 0);
1388  rps = &sps->st_ref_pic_set[0];
1389  }
1390 
1391  dpb_slots_remaining = HEVC_MAX_DPB_SIZE - 1 -
1393  if (pps->pps_curr_pic_ref_enabled_flag &&
1394  (sps->sample_adaptive_offset_enabled_flag ||
1395  !pps->pps_deblocking_filter_disabled_flag ||
1396  pps->deblocking_filter_override_enabled_flag)) {
1397  // This picture will occupy two DPB slots.
1398  if (dpb_slots_remaining == 0) {
1399  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid stream: "
1400  "short-term ref pic set contains too many pictures "
1401  "to use with current picture reference enabled.\n");
1402  return AVERROR_INVALIDDATA;
1403  }
1404  --dpb_slots_remaining;
1405  }
1406 
1407  num_pic_total_curr = 0;
1408  for (i = 0; i < rps->num_negative_pics; i++)
1409  if (rps->used_by_curr_pic_s0_flag[i])
1410  ++num_pic_total_curr;
1411  for (i = 0; i < rps->num_positive_pics; i++)
1412  if (rps->used_by_curr_pic_s1_flag[i])
1413  ++num_pic_total_curr;
1414 
1415  if (sps->long_term_ref_pics_present_flag) {
1416  unsigned int idx_size;
1417 
1418  if (sps->num_long_term_ref_pics_sps > 0) {
1419  ue(num_long_term_sps, 0, FFMIN(sps->num_long_term_ref_pics_sps,
1420  dpb_slots_remaining));
1421  idx_size = av_log2(sps->num_long_term_ref_pics_sps - 1) + 1;
1422  dpb_slots_remaining -= current->num_long_term_sps;
1423  } else {
1424  infer(num_long_term_sps, 0);
1425  idx_size = 0;
1426  }
1427  ue(num_long_term_pics, 0, dpb_slots_remaining);
1428 
1429  for (i = 0; i < current->num_long_term_sps +
1430  current->num_long_term_pics; i++) {
1431  if (i < current->num_long_term_sps) {
1432  if (sps->num_long_term_ref_pics_sps > 1)
1433  us(idx_size, lt_idx_sps[i],
1434  0, sps->num_long_term_ref_pics_sps - 1, 1, i);
1435  if (sps->used_by_curr_pic_lt_sps_flag[current->lt_idx_sps[i]])
1436  ++num_pic_total_curr;
1437  } else {
1438  ubs(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, poc_lsb_lt[i], 1, i);
1439  flags(used_by_curr_pic_lt_flag[i], 1, i);
1440  if (current->used_by_curr_pic_lt_flag[i])
1441  ++num_pic_total_curr;
1442  }
1443  flags(delta_poc_msb_present_flag[i], 1, i);
1444  if (current->delta_poc_msb_present_flag[i])
1445  ues(delta_poc_msb_cycle_lt[i], 0, UINT32_MAX - 1, 1, i);
1446  else
1447  infer(delta_poc_msb_cycle_lt[i], 0);
1448  }
1449  }
1450 
1451  if (sps->sps_temporal_mvp_enabled_flag)
1452  flag(slice_temporal_mvp_enabled_flag);
1453  else
1454  infer(slice_temporal_mvp_enabled_flag, 0);
1455 
1456  if (pps->pps_curr_pic_ref_enabled_flag)
1457  ++num_pic_total_curr;
1458  }
1459 
1460  if (sps->sample_adaptive_offset_enabled_flag) {
1461  flag(slice_sao_luma_flag);
1462  if (!sps->separate_colour_plane_flag && sps->chroma_format_idc != 0)
1463  flag(slice_sao_chroma_flag);
1464  else
1465  infer(slice_sao_chroma_flag, 0);
1466  } else {
1467  infer(slice_sao_luma_flag, 0);
1468  infer(slice_sao_chroma_flag, 0);
1469  }
1470 
1471  if (current->slice_type == HEVC_SLICE_P ||
1472  current->slice_type == HEVC_SLICE_B) {
1473  flag(num_ref_idx_active_override_flag);
1474  if (current->num_ref_idx_active_override_flag) {
1475  ue(num_ref_idx_l0_active_minus1, 0, 14);
1476  if (current->slice_type == HEVC_SLICE_B)
1477  ue(num_ref_idx_l1_active_minus1, 0, 14);
1478  else
1479  infer(num_ref_idx_l1_active_minus1, pps->num_ref_idx_l1_default_active_minus1);
1480  } else {
1481  infer(num_ref_idx_l0_active_minus1, pps->num_ref_idx_l0_default_active_minus1);
1482  infer(num_ref_idx_l1_active_minus1, pps->num_ref_idx_l1_default_active_minus1);
1483  }
1484 
1485  if (pps->lists_modification_present_flag && num_pic_total_curr > 1)
1486  CHECK(FUNC(ref_pic_lists_modification)(ctx, rw, current,
1487  num_pic_total_curr));
1488 
1489  if (current->slice_type == HEVC_SLICE_B)
1490  flag(mvd_l1_zero_flag);
1491  if (pps->cabac_init_present_flag)
1492  flag(cabac_init_flag);
1493  else
1494  infer(cabac_init_flag, 0);
1495  if (current->slice_temporal_mvp_enabled_flag) {
1496  if (current->slice_type == HEVC_SLICE_B)
1497  flag(collocated_from_l0_flag);
1498  else
1499  infer(collocated_from_l0_flag, 1);
1500  if (current->collocated_from_l0_flag) {
1501  if (current->num_ref_idx_l0_active_minus1 > 0)
1502  ue(collocated_ref_idx, 0, current->num_ref_idx_l0_active_minus1);
1503  else
1504  infer(collocated_ref_idx, 0);
1505  } else {
1506  if (current->num_ref_idx_l1_active_minus1 > 0)
1507  ue(collocated_ref_idx, 0, current->num_ref_idx_l1_active_minus1);
1508  else
1509  infer(collocated_ref_idx, 0);
1510  }
1511  }
1512 
1513  if ((pps->weighted_pred_flag && current->slice_type == HEVC_SLICE_P) ||
1514  (pps->weighted_bipred_flag && current->slice_type == HEVC_SLICE_B))
1515  CHECK(FUNC(pred_weight_table)(ctx, rw, current));
1516 
1517  ue(five_minus_max_num_merge_cand, 0, 4);
1518  if (sps->motion_vector_resolution_control_idc == 2)
1519  flag(use_integer_mv_flag);
1520  else
1521  infer(use_integer_mv_flag, sps->motion_vector_resolution_control_idc);
1522  }
1523 
1524  se(slice_qp_delta,
1525  - 6 * sps->bit_depth_luma_minus8 - (pps->init_qp_minus26 + 26),
1526  + 51 - (pps->init_qp_minus26 + 26));
1527  if (pps->pps_slice_chroma_qp_offsets_present_flag) {
1528  se(slice_cb_qp_offset, -12, +12);
1529  se(slice_cr_qp_offset, -12, +12);
1530  } else {
1531  infer(slice_cb_qp_offset, 0);
1532  infer(slice_cr_qp_offset, 0);
1533  }
1534  if (pps->pps_slice_act_qp_offsets_present_flag) {
1535  se(slice_act_y_qp_offset,
1536  -12 - (pps->pps_act_y_qp_offset_plus5 - 5),
1537  +12 - (pps->pps_act_y_qp_offset_plus5 - 5));
1538  se(slice_act_cb_qp_offset,
1539  -12 - (pps->pps_act_cb_qp_offset_plus5 - 5),
1540  +12 - (pps->pps_act_cb_qp_offset_plus5 - 5));
1541  se(slice_act_cr_qp_offset,
1542  -12 - (pps->pps_act_cr_qp_offset_plus3 - 3),
1543  +12 - (pps->pps_act_cr_qp_offset_plus3 - 3));
1544  } else {
1545  infer(slice_act_y_qp_offset, 0);
1546  infer(slice_act_cb_qp_offset, 0);
1547  infer(slice_act_cr_qp_offset, 0);
1548  }
1549  if (pps->chroma_qp_offset_list_enabled_flag)
1550  flag(cu_chroma_qp_offset_enabled_flag);
1551  else
1552  infer(cu_chroma_qp_offset_enabled_flag, 0);
1553 
1554  if (pps->deblocking_filter_override_enabled_flag)
1555  flag(deblocking_filter_override_flag);
1556  else
1557  infer(deblocking_filter_override_flag, 0);
1558  if (current->deblocking_filter_override_flag) {
1559  flag(slice_deblocking_filter_disabled_flag);
1560  if (!current->slice_deblocking_filter_disabled_flag) {
1561  se(slice_beta_offset_div2, -6, +6);
1562  se(slice_tc_offset_div2, -6, +6);
1563  } else {
1564  infer(slice_beta_offset_div2, pps->pps_beta_offset_div2);
1565  infer(slice_tc_offset_div2, pps->pps_tc_offset_div2);
1566  }
1567  } else {
1568  infer(slice_deblocking_filter_disabled_flag,
1569  pps->pps_deblocking_filter_disabled_flag);
1570  infer(slice_beta_offset_div2, pps->pps_beta_offset_div2);
1571  infer(slice_tc_offset_div2, pps->pps_tc_offset_div2);
1572  }
1573  if (pps->pps_loop_filter_across_slices_enabled_flag &&
1574  (current->slice_sao_luma_flag || current->slice_sao_chroma_flag ||
1575  !current->slice_deblocking_filter_disabled_flag))
1576  flag(slice_loop_filter_across_slices_enabled_flag);
1577  else
1578  infer(slice_loop_filter_across_slices_enabled_flag,
1579  pps->pps_loop_filter_across_slices_enabled_flag);
1580  }
1581 
1582  if (pps->tiles_enabled_flag || pps->entropy_coding_sync_enabled_flag) {
1583  unsigned int num_entry_point_offsets_limit;
1584  if (!pps->tiles_enabled_flag && pps->entropy_coding_sync_enabled_flag)
1585  num_entry_point_offsets_limit = pic_height_in_ctbs_y - 1;
1586  else if (pps->tiles_enabled_flag && !pps->entropy_coding_sync_enabled_flag)
1587  num_entry_point_offsets_limit =
1588  (pps->num_tile_columns_minus1 + 1) * (pps->num_tile_rows_minus1 + 1);
1589  else
1590  num_entry_point_offsets_limit =
1591  (pps->num_tile_columns_minus1 + 1) * pic_height_in_ctbs_y - 1;
1592  ue(num_entry_point_offsets, 0, num_entry_point_offsets_limit);
1593 
1594  if (current->num_entry_point_offsets > HEVC_MAX_ENTRY_POINT_OFFSETS) {
1595  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many entry points: "
1596  "%"PRIu16".\n", current->num_entry_point_offsets);
1597  return AVERROR_PATCHWELCOME;
1598  }
1599 
1600  if (current->num_entry_point_offsets > 0) {
1601  ue(offset_len_minus1, 0, 31);
1602  for (i = 0; i < current->num_entry_point_offsets; i++)
1603  ubs(current->offset_len_minus1 + 1, entry_point_offset_minus1[i], 1, i);
1604  }
1605  }
1606 
1607  if (pps->slice_segment_header_extension_present_flag) {
1608  ue(slice_segment_header_extension_length, 0, 256);
1609  for (i = 0; i < current->slice_segment_header_extension_length; i++)
1610  us(8, slice_segment_header_extension_data_byte[i], 0x00, 0xff, 1, i);
1611  }
1612 
1613  CHECK(FUNC(byte_alignment)(ctx, rw));
1614 
1615  return 0;
1616 }
1617 
1618 static int FUNC(sei_buffering_period)
1621 {
1623  const H265RawSPS *sps;
1624  const H265RawHRDParameters *hrd;
1625  int err, i, length;
1626 
1627 #ifdef READ
1628  int start_pos, end_pos;
1629  start_pos = get_bits_count(rw);
1630 #endif
1631 
1632  HEADER("Buffering Period");
1633 
1634  ue(bp_seq_parameter_set_id, 0, HEVC_MAX_SPS_COUNT - 1);
1635 
1636  sps = h265->sps[current->bp_seq_parameter_set_id];
1637  if (!sps) {
1638  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1639  current->bp_seq_parameter_set_id);
1640  return AVERROR_INVALIDDATA;
1641  }
1642  h265->active_sps = sps;
1643 
1644  if (!sps->vui_parameters_present_flag ||
1645  !sps->vui.vui_hrd_parameters_present_flag) {
1646  av_log(ctx->log_ctx, AV_LOG_ERROR, "Buffering period SEI requires "
1647  "HRD parameters to be present in SPS.\n");
1648  return AVERROR_INVALIDDATA;
1649  }
1650  hrd = &sps->vui.hrd_parameters;
1651  if (!hrd->nal_hrd_parameters_present_flag &&
1653  av_log(ctx->log_ctx, AV_LOG_ERROR, "Buffering period SEI requires "
1654  "NAL or VCL HRD parameters to be present.\n");
1655  return AVERROR_INVALIDDATA;
1656  }
1657 
1659  flag(irap_cpb_params_present_flag);
1660  else
1661  infer(irap_cpb_params_present_flag, 0);
1662  if (current->irap_cpb_params_present_flag) {
1663  length = hrd->au_cpb_removal_delay_length_minus1 + 1;
1664  ub(length, cpb_delay_offset);
1665  length = hrd->dpb_output_delay_length_minus1 + 1;
1666  ub(length, dpb_delay_offset);
1667  } else {
1668  infer(cpb_delay_offset, 0);
1669  infer(dpb_delay_offset, 0);
1670  }
1671 
1672  flag(concatenation_flag);
1673 
1674  length = hrd->au_cpb_removal_delay_length_minus1 + 1;
1675  ub(length, au_cpb_removal_delay_delta_minus1);
1676 
1678  for (i = 0; i <= hrd->cpb_cnt_minus1[0]; i++) {
1679  length = hrd->initial_cpb_removal_delay_length_minus1 + 1;
1680 
1681  ubs(length, nal_initial_cpb_removal_delay[i], 1, i);
1682  ubs(length, nal_initial_cpb_removal_offset[i], 1, i);
1683 
1685  current->irap_cpb_params_present_flag) {
1686  ubs(length, nal_initial_alt_cpb_removal_delay[i], 1, i);
1687  ubs(length, nal_initial_alt_cpb_removal_offset[i], 1, i);
1688  }
1689  }
1690  }
1692  for (i = 0; i <= hrd->cpb_cnt_minus1[0]; i++) {
1693  length = hrd->initial_cpb_removal_delay_length_minus1 + 1;
1694 
1695  ubs(length, vcl_initial_cpb_removal_delay[i], 1, i);
1696  ubs(length, vcl_initial_cpb_removal_offset[i], 1, i);
1697 
1699  current->irap_cpb_params_present_flag) {
1700  ubs(length, vcl_initial_alt_cpb_removal_delay[i], 1, i);
1701  ubs(length, vcl_initial_alt_cpb_removal_offset[i], 1, i);
1702  }
1703  }
1704  }
1705 
1706 #ifdef READ
1707  end_pos = get_bits_count(rw);
1708  if (cbs_h265_payload_extension_present(rw, sei->payload_size,
1709  end_pos - start_pos))
1710  flag(use_alt_cpb_params_flag);
1711  else
1712  infer(use_alt_cpb_params_flag, 0);
1713 #else
1714  // If unknown extension data exists, then use_alt_cpb_params_flag is
1715  // coded in the bitstream and must be written even if it's 0.
1716  if (current->use_alt_cpb_params_flag || sei->extension_present) {
1717  flag(use_alt_cpb_params_flag);
1718  // Ensure this bit is not the last in the payload by making the
1719  // more_data_in_payload() check evaluate to true, so it may not
1720  // be mistaken as something else by decoders.
1721  sei->extension_present = 1;
1722  }
1723 #endif
1724 
1725  return 0;
1726 }
1727 
1728 static int FUNC(sei_pic_timing)
1731 {
1733  const H265RawSPS *sps;
1734  const H265RawHRDParameters *hrd;
1735  int err, expected_source_scan_type, i, length;
1736 
1737  HEADER("Picture Timing");
1738 
1739  sps = h265->active_sps;
1740  if (!sps) {
1741  av_log(ctx->log_ctx, AV_LOG_ERROR,
1742  "No active SPS for pic_timing.\n");
1743  return AVERROR_INVALIDDATA;
1744  }
1745 
1746  expected_source_scan_type = 2 -
1747  2 * sps->profile_tier_level.general_interlaced_source_flag -
1748  sps->profile_tier_level.general_progressive_source_flag;
1749 
1750  if (sps->vui.frame_field_info_present_flag) {
1751  u(4, pic_struct, 0, 12);
1752  u(2, source_scan_type,
1753  expected_source_scan_type >= 0 ? expected_source_scan_type : 0,
1754  expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1755  flag(duplicate_flag);
1756  } else {
1757  infer(pic_struct, 0);
1758  infer(source_scan_type,
1759  expected_source_scan_type >= 0 ? expected_source_scan_type : 2);
1760  infer(duplicate_flag, 0);
1761  }
1762 
1763  if (sps->vui_parameters_present_flag &&
1764  sps->vui.vui_hrd_parameters_present_flag)
1765  hrd = &sps->vui.hrd_parameters;
1766  else
1767  hrd = NULL;
1768  if (hrd && (hrd->nal_hrd_parameters_present_flag ||
1770  length = hrd->au_cpb_removal_delay_length_minus1 + 1;
1771  ub(length, au_cpb_removal_delay_minus1);
1772 
1773  length = hrd->dpb_output_delay_length_minus1 + 1;
1774  ub(length, pic_dpb_output_delay);
1775 
1777  length = hrd->dpb_output_delay_du_length_minus1 + 1;
1778  ub(length, pic_dpb_output_du_delay);
1779  }
1780 
1783  // Each decoding unit must contain at least one slice segment.
1784  ue(num_decoding_units_minus1, 0, HEVC_MAX_SLICE_SEGMENTS);
1785  flag(du_common_cpb_removal_delay_flag);
1786 
1788  if (current->du_common_cpb_removal_delay_flag)
1789  ub(length, du_common_cpb_removal_delay_increment_minus1);
1790 
1791  for (i = 0; i <= current->num_decoding_units_minus1; i++) {
1792  ues(num_nalus_in_du_minus1[i],
1793  0, HEVC_MAX_SLICE_SEGMENTS, 1, i);
1794  if (!current->du_common_cpb_removal_delay_flag &&
1795  i < current->num_decoding_units_minus1)
1796  ubs(length, du_cpb_removal_delay_increment_minus1[i], 1, i);
1797  }
1798  }
1799  }
1800 
1801  return 0;
1802 }
1803 
1804 static int FUNC(sei_pan_scan_rect)
1807 {
1808  int err, i;
1809 
1810  HEADER("Pan-Scan Rectangle");
1811 
1812  ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
1813  flag(pan_scan_rect_cancel_flag);
1814 
1815  if (!current->pan_scan_rect_cancel_flag) {
1816  ue(pan_scan_cnt_minus1, 0, 2);
1817 
1818  for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
1819  ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1820  ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1821  ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1822  ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
1823  }
1824 
1825  flag(pan_scan_rect_persistence_flag);
1826  }
1827 
1828  return 0;
1829 }
1830 
1831 static int FUNC(sei_recovery_point)
1834 {
1835  int err;
1836 
1837  HEADER("Recovery Point");
1838 
1839  se(recovery_poc_cnt, -32768, 32767);
1840 
1841  flag(exact_match_flag);
1842  flag(broken_link_flag);
1843 
1844  return 0;
1845 }
1846 
1847 static int FUNC(sei_display_orientation)
1850 {
1851  int err;
1852 
1853  HEADER("Display Orientation");
1854 
1855  flag(display_orientation_cancel_flag);
1856  if (!current->display_orientation_cancel_flag) {
1857  flag(hor_flip);
1858  flag(ver_flip);
1859  ub(16, anticlockwise_rotation);
1860  flag(display_orientation_persistence_flag);
1861  }
1862 
1863  return 0;
1864 }
1865 
1866 static int FUNC(sei_active_parameter_sets)
1869 {
1871  const H265RawVPS *vps;
1872  int err, i;
1873 
1874  HEADER("Active Parameter Sets");
1875 
1876  u(4, active_video_parameter_set_id, 0, HEVC_MAX_VPS_COUNT);
1877  vps = h265->vps[current->active_video_parameter_set_id];
1878  if (!vps) {
1879  av_log(ctx->log_ctx, AV_LOG_ERROR, "VPS id %d not available for active "
1880  "parameter sets.\n", current->active_video_parameter_set_id);
1881  return AVERROR_INVALIDDATA;
1882  }
1883  h265->active_vps = vps;
1884 
1885  flag(self_contained_cvs_flag);
1886  flag(no_parameter_set_update_flag);
1887 
1888  ue(num_sps_ids_minus1, 0, HEVC_MAX_SPS_COUNT - 1);
1889  for (i = 0; i <= current->num_sps_ids_minus1; i++)
1890  ues(active_seq_parameter_set_id[i], 0, HEVC_MAX_SPS_COUNT - 1, 1, i);
1891 
1892  for (i = vps->vps_base_layer_internal_flag;
1893  i <= FFMIN(62, vps->vps_max_layers_minus1); i++) {
1894  ues(layer_sps_idx[i], 0, current->num_sps_ids_minus1, 1, i);
1895 
1896  if (i == 0)
1897  h265->active_sps = h265->sps[current->active_seq_parameter_set_id[current->layer_sps_idx[0]]];
1898  }
1899 
1900  return 0;
1901 }
1902 
1903 static int FUNC(sei_decoded_picture_hash)
1906 {
1908  const H265RawSPS *sps = h265->active_sps;
1909  int err, c, i;
1910 
1911  HEADER("Decoded Picture Hash");
1912 
1913  if (!sps) {
1914  av_log(ctx->log_ctx, AV_LOG_ERROR,
1915  "No active SPS for decoded picture hash.\n");
1916  return AVERROR_INVALIDDATA;
1917  }
1918 
1919  u(8, hash_type, 0, 2);
1920 
1921  for (c = 0; c < (sps->chroma_format_idc == 0 ? 1 : 3); c++) {
1922  if (current->hash_type == 0) {
1923  for (i = 0; i < 16; i++)
1924  us(8, picture_md5[c][i], 0x00, 0xff, 2, c, i);
1925  } else if (current->hash_type == 1) {
1926  us(16, picture_crc[c], 0x0000, 0xffff, 1, c);
1927  } else if (current->hash_type == 2) {
1928  us(32, picture_checksum[c], 0x00000000, 0xffffffff, 1, c);
1929  }
1930  }
1931 
1932  return 0;
1933 }
1934 
1935 static int FUNC(sei_time_code)
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 
1986 static int FUNC(sei_alpha_channel_info)
1989 {
1990  int err, length;
1991 
1992  HEADER("Alpha Channel Information");
1993 
1994  flag(alpha_channel_cancel_flag);
1995  if (!current->alpha_channel_cancel_flag) {
1996  ub(3, alpha_channel_use_idc);
1997  ub(3, alpha_channel_bit_depth_minus8);
1998  length = current->alpha_channel_bit_depth_minus8 + 9;
1999  ub(length, alpha_transparent_value);
2000  ub(length, alpha_opaque_value);
2001  flag(alpha_channel_incr_flag);
2002  flag(alpha_channel_clip_flag);
2003  if (current->alpha_channel_clip_flag)
2004  flag(alpha_channel_clip_type_flag);
2005  } else {
2006  infer(alpha_channel_use_idc, 2);
2007  infer(alpha_channel_incr_flag, 0);
2008  infer(alpha_channel_clip_flag, 0);
2009  }
2010 
2011  return 0;
2012 }
2013 
2015  H265RawSEI *current, int prefix)
2016 {
2017  int err;
2018 
2019  if (prefix)
2020  HEADER("Prefix Supplemental Enhancement Information");
2021  else
2022  HEADER("Suffix Supplemental Enhancement Information");
2023 
2024  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
2025  prefix ? HEVC_NAL_SEI_PREFIX
2026  : HEVC_NAL_SEI_SUFFIX));
2027 
2028  CHECK(FUNC_SEI(message_list)(ctx, rw, &current->message_list, prefix));
2029 
2031 
2032  return 0;
2033 }
H265RawHRDParameters::au_cpb_removal_delay_length_minus1
uint8_t au_cpb_removal_delay_length_minus1
Definition: cbs_h265.h:115
CodedBitstreamH265Context::vps
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
Definition: cbs_h265.h:666
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
sps_scc_extension
static int FUNC() sps_scc_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
Definition: cbs_h265_syntax_template.c:717
HEVC_MAX_TILE_ROWS
@ HEVC_MAX_TILE_ROWS
Definition: hevc.h:142
H265RawSEITimeCode
Definition: cbs_h265.h:622
H265RawHRDParameters::dpb_output_delay_length_minus1
uint8_t dpb_output_delay_length_minus1
Definition: cbs_h265.h:116
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:85
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
sps_range_extension
static int FUNC() sps_range_extension(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
Definition: cbs_h265_syntax_template.c:699
sei_buffering_period
static int FUNC() sei_buffering_period(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIBufferingPeriod *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1619
H265RawSEIActiveParameterSets
Definition: cbs_h265.h:606
se
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:275
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
HEADER
#define HEADER(name)
Definition: cbs_av1.c:533
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:1172
H265RawVUI
Definition: cbs_h265.h:127
infer
#define infer(name, value)
Definition: cbs_av1.c:709
H265RawSEI
Definition: cbs_h265.h:652
H265RawExtensionData
Definition: cbs_h265.h:177
CodedBitstreamH265Context::sps
H265RawSPS * sps[HEVC_MAX_SPS_COUNT]
Definition: cbs_h265.h:667
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:170
H265RawSTRefPicSet::used_by_curr_pic_s1_flag
uint8_t used_by_curr_pic_s1_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:234
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:1624
vui_parameters_default
static int FUNC() vui_parameters_default(CodedBitstreamContext *ctx, RWContext *rw, H265RawVUI *current, H265RawSPS *sps)
Definition: cbs_h265_syntax_template.c:747
H265RawSEIPanScanRect
Definition: cbs_h265.h:580
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:432
H265RawSEIDecodedPictureHash
Definition: cbs_h265.h:615
H265RawHRDParameters::sub_pic_hrd_params_present_flag
uint8_t sub_pic_hrd_params_present_flag
Definition: cbs_h265.h:104
ses
#define ses(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:290
HEVC_MAX_SHORT_TERM_REF_PIC_SETS
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:122
sei_display_orientation
static int FUNC() sei_display_orientation(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDisplayOrientation *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1848
H265RawSPS
Definition: cbs_h265.h:244
H265RawVPS
Definition: cbs_h265.h:183
HEVC_MAX_LONG_TERM_REF_PICS
@ HEVC_MAX_LONG_TERM_REF_PICS
Definition: hevc.h:124
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
H265RawPPS
Definition: cbs_h265.h:346
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
H265RawSTRefPicSet::used_by_curr_pic_s0_flag
uint8_t used_by_curr_pic_s0_flag[HEVC_MAX_REFS]
Definition: cbs_h265.h:232
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 -
H265RawHRDParameters::vcl_hrd_parameters_present_flag
uint8_t vcl_hrd_parameters_present_flag
Definition: cbs_h265.h:102
H265RawSEIPicTiming
Definition: cbs_h265.h:564
GetBitContext
Definition: get_bits.h:61
ub
#define ub(width, name)
Definition: cbs_h2645.c:266
HEVC_MAX_ENTRY_POINT_OFFSETS
@ HEVC_MAX_ENTRY_POINT_OFFSETS
Definition: hevc.h:156
slice_segment_header
static int FUNC() slice_segment_header(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current)
Definition: cbs_h265_syntax_template.c:1298
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:269
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
message_list
static int FUNC() message_list(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessageList *current, int prefix)
Definition: cbs_sei_syntax_template.c:230
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:194
extension_data
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawExtensionData *current)
Definition: cbs_h265_syntax_template.c:61
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
sei_alpha_channel_info
static int FUNC() sei_alpha_channel_info(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIAlphaChannelInfo *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1987
profile_compatible
#define profile_compatible(x)
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H265RawSPS *current)
Definition: cbs_h265_syntax_template.c:773
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
HEVC_MAX_SLICE_SEGMENTS
@ HEVC_MAX_SLICE_SEGMENTS
Definition: hevc.h:147
H265RawSTRefPicSet::num_positive_pics
uint8_t num_positive_pics
Definition: cbs_h265.h:230
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FUNC_SEI
#define FUNC_SEI(name)
Definition: cbs_h2645.c:260
H265RawSEIDisplayOrientation
Definition: cbs_h265.h:597
H265RawSEIRecoveryPoint
Definition: cbs_h265.h:591
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
cbs_h265_payload_extension_present
static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size, int cur_pos)
Definition: cbs_h2645.c:238
HEVC_NAL_IDR_N_LP
@ HEVC_NAL_IDR_N_LP
Definition: hevc.h:49
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
NULL
#define NULL
Definition: coverity.c:32
H265RawAUD
Definition: cbs_h265.h:437
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
sei_decoded_picture_hash
static int FUNC() sei_decoded_picture_hash(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDecodedPictureHash *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1904
HEVC_MAX_WIDTH
@ HEVC_MAX_WIDTH
Definition: hevc.h:138
HEVC_MAX_LAYER_SETS
@ HEVC_MAX_LAYER_SETS
Definition: hevc.h:107
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:993
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:420
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:107
H265RawNALUnitHeader
Definition: cbs_h265.h:29
H265RawHRDParameters::cpb_cnt_minus1
uint8_t cpb_cnt_minus1[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:122
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:92
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H265RawAUD *current)
Definition: cbs_h265_syntax_template.c:1156
H265RawHRDParameters::dpb_output_delay_du_length_minus1
uint8_t dpb_output_delay_du_length_minus1
Definition: cbs_h265.h:108
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H265RawSliceHeader *current)
Definition: cbs_h265_syntax_template.c:1198
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
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:177
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H265RawPPS *current)
Definition: cbs_h265_syntax_template.c:1033
H265RawHRDParameters
Definition: cbs_h265.h:100
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
H265RawHRDParameters::initial_cpb_removal_delay_length_minus1
uint8_t initial_cpb_removal_delay_length_minus1
Definition: cbs_h265.h:114
sei_active_parameter_sets
static int FUNC() sei_active_parameter_sets(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIActiveParameterSets *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1867
rbsp_trailing_bits
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h265_syntax_template.c:19
HEVC_NAL_RSV_IRAP_VCL23
@ HEVC_NAL_RSV_IRAP_VCL23
Definition: hevc.h:52
sei_time_code
static int FUNC() sei_time_code(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEITimeCode *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1936
H265RawSliceHeader
Definition: cbs_h265.h:443
flag
#define flag(name)
Definition: cbs_av1.c:553
H265RawHRDParameters::du_cpb_removal_delay_increment_length_minus1
uint8_t du_cpb_removal_delay_increment_length_minus1
Definition: cbs_h265.h:106
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEI *current, int prefix)
Definition: cbs_h265_syntax_template.c:2014
i
int i
Definition: input.c:407
ubs
#define ubs(width, name, subs,...)
Definition: cbs_h2645.c:280
HEVC_MAX_HEIGHT
@ HEVC_MAX_HEIGHT
Definition: hevc.h:139
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:965
uint8_t
uint8_t
Definition: audio_convert.c:194
H265RawSTRefPicSet
Definition: cbs_h265.h:219
H265RawProfileTierLevel
Definition: cbs_h265.h:35
H265RawScalingList
Definition: cbs_h265.h:237
H265RawHRDParameters::nal_hrd_parameters_present_flag
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h265.h:101
CodedBitstreamH265Context::active_sps
const H265RawSPS * active_sps
Definition: cbs_h265.h:674
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
HEVC_NAL_IDR_W_RADL
@ HEVC_NAL_IDR_W_RADL
Definition: hevc.h:48
HEVC_MAX_SPS_COUNT
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:112
HEVC_MAX_TILE_COLUMNS
@ HEVC_MAX_TILE_COLUMNS
Definition: hevc.h:144
HEVC_MAX_VPS_COUNT
@ HEVC_MAX_VPS_COUNT
Definition: hevc.h:110
CodedBitstreamH265Context::pps
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
Definition: cbs_h265.h:668
scaling_list_data
static int FUNC() scaling_list_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawScalingList *current)
Definition: cbs_h265_syntax_template.c:668
HEVC_MAX_DPB_SIZE
@ HEVC_MAX_DPB_SIZE
Definition: hevc.h:117
SEIMessageState
Definition: cbs_sei.h:85
CodedBitstreamH265Context::active_pps
const H265RawPPS * active_pps
Definition: cbs_h265.h:675
HEVC_NAL_AUD
@ HEVC_NAL_AUD
Definition: hevc.h:64
H265RawSTRefPicSet::num_negative_pics
uint8_t num_negative_pics
Definition: cbs_h265.h:229
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
CodedBitstreamH265Context::active_vps
const H265RawVPS * active_vps
Definition: cbs_h265.h:673
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
sei_recovery_point
static int FUNC() sei_recovery_point(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIRecoveryPoint *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1832
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
HEVC_MAX_LAYERS
@ HEVC_MAX_LAYERS
Definition: hevc.h:103
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:566
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
sei_pic_timing
static int FUNC() sei_pic_timing(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPicTiming *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1729
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
sei_pan_scan_rect
static int FUNC() sei_pan_scan_rect(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIPanScanRect *current, SEIMessageState *sei)
Definition: cbs_h265_syntax_template.c:1805
ues
#define ues(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:284
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:392
RWContext
#define RWContext
Definition: cbs_av1.c:662
HEVC_NAL_SEI_PREFIX
@ HEVC_NAL_SEI_PREFIX
Definition: hevc.h:68
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1259
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ibs
#define ibs(width, name, subs,...)
Definition: cbs_h2645.c:288
H265RawSEIBufferingPeriod
Definition: cbs_h265.h:543
H265RawSEIAlphaChannelInfo
Definition: cbs_h265.h:641
cbs_h2645_read_more_rbsp_data
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
Definition: cbs_h2645.c:337
CodedBitstreamH265Context
Definition: cbs_h265.h:657