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