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