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