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