FFmpeg
cbs_h264_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  H264RawNALUnitHeader *current,
32  uint32_t valid_type_mask)
33 {
34  int err;
35 
36  fixed(1, forbidden_zero_bit, 0);
37  ub(2, nal_ref_idc);
38  ub(5, nal_unit_type);
39 
40  if (!(1 << current->nal_unit_type & valid_type_mask)) {
41  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid NAL unit type %d.\n",
42  current->nal_unit_type);
43  return AVERROR_INVALIDDATA;
44  }
45 
46  if (current->nal_unit_type == 14 ||
47  current->nal_unit_type == 20 ||
48  current->nal_unit_type == 21) {
49  if (current->nal_unit_type != 21)
50  flag(svc_extension_flag);
51  else
52  flag(avc_3d_extension_flag);
53 
54  if (current->svc_extension_flag) {
55  av_log(ctx->log_ctx, AV_LOG_ERROR, "SVC not supported.\n");
56  return AVERROR_PATCHWELCOME;
57 
58  } else if (current->avc_3d_extension_flag) {
59  av_log(ctx->log_ctx, AV_LOG_ERROR, "3DAVC not supported.\n");
60  return AVERROR_PATCHWELCOME;
61 
62  } else {
63  av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC not supported.\n");
64  return AVERROR_PATCHWELCOME;
65  }
66  }
67 
68  return 0;
69 }
70 
71 static int FUNC(scaling_list)(CodedBitstreamContext *ctx, RWContext *rw,
72  H264RawScalingList *current,
73  int size_of_scaling_list)
74 {
75  int err, i, scale;
76 
77  scale = 8;
78  for (i = 0; i < size_of_scaling_list; i++) {
79  ses(delta_scale[i], -128, +127, 1, i);
80  scale = (scale + current->delta_scale[i] + 256) % 256;
81  if (scale == 0)
82  break;
83  }
84 
85  return 0;
86 }
87 
88 static int FUNC(hrd_parameters)(CodedBitstreamContext *ctx, RWContext *rw,
89  H264RawHRD *current)
90 {
91  int err, i;
92 
93  ue(cpb_cnt_minus1, 0, 31);
94  ub(4, bit_rate_scale);
95  ub(4, cpb_size_scale);
96 
97  for (i = 0; i <= current->cpb_cnt_minus1; i++) {
98  ues(bit_rate_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
99  ues(cpb_size_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
100  flags(cbr_flag[i], 1, i);
101  }
102 
103  ub(5, initial_cpb_removal_delay_length_minus1);
104  ub(5, cpb_removal_delay_length_minus1);
105  ub(5, dpb_output_delay_length_minus1);
106  ub(5, time_offset_length);
107 
108  return 0;
109 }
110 
111 static int FUNC(vui_parameters)(CodedBitstreamContext *ctx, RWContext *rw,
112  H264RawVUI *current, H264RawSPS *sps)
113 {
114  int err;
115 
116  flag(aspect_ratio_info_present_flag);
117  if (current->aspect_ratio_info_present_flag) {
118  ub(8, aspect_ratio_idc);
119  if (current->aspect_ratio_idc == 255) {
120  ub(16, sar_width);
121  ub(16, sar_height);
122  }
123  } else {
124  infer(aspect_ratio_idc, 0);
125  }
126 
127  flag(overscan_info_present_flag);
128  if (current->overscan_info_present_flag)
129  flag(overscan_appropriate_flag);
130 
131  flag(video_signal_type_present_flag);
132  if (current->video_signal_type_present_flag) {
133  ub(3, video_format);
134  flag(video_full_range_flag);
135  flag(colour_description_present_flag);
136  if (current->colour_description_present_flag) {
137  ub(8, colour_primaries);
138  ub(8, transfer_characteristics);
139  ub(8, matrix_coefficients);
140  } else {
141  infer(colour_primaries, 2);
142  infer(transfer_characteristics, 2);
143  infer(matrix_coefficients, 2);
144  }
145  } else {
146  infer(video_format, 5);
147  infer(video_full_range_flag, 0);
148  infer(colour_primaries, 2);
149  infer(transfer_characteristics, 2);
150  infer(matrix_coefficients, 2);
151  }
152 
153  flag(chroma_loc_info_present_flag);
154  if (current->chroma_loc_info_present_flag) {
155  ue(chroma_sample_loc_type_top_field, 0, 5);
156  ue(chroma_sample_loc_type_bottom_field, 0, 5);
157  } else {
158  infer(chroma_sample_loc_type_top_field, 0);
159  infer(chroma_sample_loc_type_bottom_field, 0);
160  }
161 
162  flag(timing_info_present_flag);
163  if (current->timing_info_present_flag) {
164  u(32, num_units_in_tick, 1, UINT32_MAX);
165  u(32, time_scale, 1, UINT32_MAX);
166  flag(fixed_frame_rate_flag);
167  } else {
168  infer(fixed_frame_rate_flag, 0);
169  }
170 
171  flag(nal_hrd_parameters_present_flag);
172  if (current->nal_hrd_parameters_present_flag)
173  CHECK(FUNC(hrd_parameters)(ctx, rw, &current->nal_hrd_parameters));
174 
175  flag(vcl_hrd_parameters_present_flag);
176  if (current->vcl_hrd_parameters_present_flag)
177  CHECK(FUNC(hrd_parameters)(ctx, rw, &current->vcl_hrd_parameters));
178 
179  if (current->nal_hrd_parameters_present_flag ||
180  current->vcl_hrd_parameters_present_flag)
181  flag(low_delay_hrd_flag);
182  else
183  infer(low_delay_hrd_flag, 1 - current->fixed_frame_rate_flag);
184 
185  flag(pic_struct_present_flag);
186 
187  flag(bitstream_restriction_flag);
188  if (current->bitstream_restriction_flag) {
189  flag(motion_vectors_over_pic_boundaries_flag);
190  ue(max_bytes_per_pic_denom, 0, 16);
191  ue(max_bits_per_mb_denom, 0, 16);
192  // The current version of the standard constrains this to be in
193  // [0,15], but older versions allow 16.
194  ue(log2_max_mv_length_horizontal, 0, 16);
195  ue(log2_max_mv_length_vertical, 0, 16);
196  ue(max_num_reorder_frames, 0, H264_MAX_DPB_FRAMES);
197  ue(max_dec_frame_buffering, 0, H264_MAX_DPB_FRAMES);
198  } else {
199  infer(motion_vectors_over_pic_boundaries_flag, 1);
200  infer(max_bytes_per_pic_denom, 2);
201  infer(max_bits_per_mb_denom, 1);
202  infer(log2_max_mv_length_horizontal, 15);
203  infer(log2_max_mv_length_vertical, 15);
204 
205  if ((sps->profile_idc == 44 || sps->profile_idc == 86 ||
206  sps->profile_idc == 100 || sps->profile_idc == 110 ||
207  sps->profile_idc == 122 || sps->profile_idc == 244) &&
208  sps->constraint_set3_flag) {
209  infer(max_num_reorder_frames, 0);
210  infer(max_dec_frame_buffering, 0);
211  } else {
212  infer(max_num_reorder_frames, H264_MAX_DPB_FRAMES);
213  infer(max_dec_frame_buffering, H264_MAX_DPB_FRAMES);
214  }
215  }
216 
217  return 0;
218 }
219 
220 static int FUNC(vui_parameters_default)(CodedBitstreamContext *ctx,
221  RWContext *rw, H264RawVUI *current,
222  H264RawSPS *sps)
223 {
224  infer(aspect_ratio_idc, 0);
225 
226  infer(video_format, 5);
227  infer(video_full_range_flag, 0);
228  infer(colour_primaries, 2);
229  infer(transfer_characteristics, 2);
230  infer(matrix_coefficients, 2);
231 
232  infer(chroma_sample_loc_type_top_field, 0);
233  infer(chroma_sample_loc_type_bottom_field, 0);
234 
235  infer(fixed_frame_rate_flag, 0);
236  infer(low_delay_hrd_flag, 1);
237 
238  infer(pic_struct_present_flag, 0);
239 
240  infer(motion_vectors_over_pic_boundaries_flag, 1);
241  infer(max_bytes_per_pic_denom, 2);
242  infer(max_bits_per_mb_denom, 1);
243  infer(log2_max_mv_length_horizontal, 15);
244  infer(log2_max_mv_length_vertical, 15);
245 
246  if ((sps->profile_idc == 44 || sps->profile_idc == 86 ||
247  sps->profile_idc == 100 || sps->profile_idc == 110 ||
248  sps->profile_idc == 122 || sps->profile_idc == 244) &&
249  sps->constraint_set3_flag) {
250  infer(max_num_reorder_frames, 0);
251  infer(max_dec_frame_buffering, 0);
252  } else {
253  infer(max_num_reorder_frames, H264_MAX_DPB_FRAMES);
254  infer(max_dec_frame_buffering, H264_MAX_DPB_FRAMES);
255  }
256 
257  return 0;
258 }
259 
260 static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,
261  H264RawSPS *current)
262 {
263  int err, i;
264 
265  HEADER("Sequence Parameter Set");
266 
267  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
268  1 << H264_NAL_SPS));
269 
270  ub(8, profile_idc);
271 
272  flag(constraint_set0_flag);
273  flag(constraint_set1_flag);
274  flag(constraint_set2_flag);
275  flag(constraint_set3_flag);
276  flag(constraint_set4_flag);
277  flag(constraint_set5_flag);
278 
279  u(2, reserved_zero_2bits, 0, 0);
280 
281  ub(8, level_idc);
282 
283  ue(seq_parameter_set_id, 0, 31);
284 
285  if (current->profile_idc == 100 || current->profile_idc == 110 ||
286  current->profile_idc == 122 || current->profile_idc == 244 ||
287  current->profile_idc == 44 || current->profile_idc == 83 ||
288  current->profile_idc == 86 || current->profile_idc == 118 ||
289  current->profile_idc == 128 || current->profile_idc == 138) {
290  ue(chroma_format_idc, 0, 3);
291 
292  if (current->chroma_format_idc == 3)
293  flag(separate_colour_plane_flag);
294  else
295  infer(separate_colour_plane_flag, 0);
296 
297  ue(bit_depth_luma_minus8, 0, 6);
298  ue(bit_depth_chroma_minus8, 0, 6);
299 
300  flag(qpprime_y_zero_transform_bypass_flag);
301 
302  flag(seq_scaling_matrix_present_flag);
303  if (current->seq_scaling_matrix_present_flag) {
304  for (i = 0; i < ((current->chroma_format_idc != 3) ? 8 : 12); i++) {
305  flags(seq_scaling_list_present_flag[i], 1, i);
306  if (current->seq_scaling_list_present_flag[i]) {
307  if (i < 6)
308  CHECK(FUNC(scaling_list)(ctx, rw,
309  &current->scaling_list_4x4[i],
310  16));
311  else
312  CHECK(FUNC(scaling_list)(ctx, rw,
313  &current->scaling_list_8x8[i - 6],
314  64));
315  }
316  }
317  }
318  } else {
319  infer(chroma_format_idc, current->profile_idc == 183 ? 0 : 1);
320 
321  infer(separate_colour_plane_flag, 0);
322  infer(bit_depth_luma_minus8, 0);
323  infer(bit_depth_chroma_minus8, 0);
324  }
325 
326  ue(log2_max_frame_num_minus4, 0, 12);
327  ue(pic_order_cnt_type, 0, 2);
328 
329  if (current->pic_order_cnt_type == 0) {
330  ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
331  } else if (current->pic_order_cnt_type == 1) {
332  flag(delta_pic_order_always_zero_flag);
333  se(offset_for_non_ref_pic, INT32_MIN + 1, INT32_MAX);
334  se(offset_for_top_to_bottom_field, INT32_MIN + 1, INT32_MAX);
335  ue(num_ref_frames_in_pic_order_cnt_cycle, 0, 255);
336 
337  for (i = 0; i < current->num_ref_frames_in_pic_order_cnt_cycle; i++)
338  ses(offset_for_ref_frame[i], INT32_MIN + 1, INT32_MAX, 1, i);
339  }
340 
341  ue(max_num_ref_frames, 0, H264_MAX_DPB_FRAMES);
342  flag(gaps_in_frame_num_allowed_flag);
343 
344  ue(pic_width_in_mbs_minus1, 0, H264_MAX_MB_WIDTH);
345  ue(pic_height_in_map_units_minus1, 0, H264_MAX_MB_HEIGHT);
346 
347  flag(frame_mbs_only_flag);
348  if (!current->frame_mbs_only_flag)
349  flag(mb_adaptive_frame_field_flag);
350 
351  flag(direct_8x8_inference_flag);
352 
353  flag(frame_cropping_flag);
354  if (current->frame_cropping_flag) {
355  ue(frame_crop_left_offset, 0, H264_MAX_WIDTH);
356  ue(frame_crop_right_offset, 0, H264_MAX_WIDTH);
357  ue(frame_crop_top_offset, 0, H264_MAX_HEIGHT);
358  ue(frame_crop_bottom_offset, 0, H264_MAX_HEIGHT);
359  }
360 
361  flag(vui_parameters_present_flag);
362  if (current->vui_parameters_present_flag)
363  CHECK(FUNC(vui_parameters)(ctx, rw, &current->vui, current));
364  else
365  CHECK(FUNC(vui_parameters_default)(ctx, rw, &current->vui, current));
366 
367  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
368 
369  return 0;
370 }
371 
372 static int FUNC(sps_extension)(CodedBitstreamContext *ctx, RWContext *rw,
373  H264RawSPSExtension *current)
374 {
375  int err;
376 
377  HEADER("Sequence Parameter Set Extension");
378 
379  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
380  1 << H264_NAL_SPS_EXT));
381 
382  ue(seq_parameter_set_id, 0, 31);
383 
384  ue(aux_format_idc, 0, 3);
385 
386  if (current->aux_format_idc != 0) {
387  int bits;
388 
389  ue(bit_depth_aux_minus8, 0, 4);
390  flag(alpha_incr_flag);
391 
392  bits = current->bit_depth_aux_minus8 + 9;
393  ub(bits, alpha_opaque_value);
394  ub(bits, alpha_transparent_value);
395  }
396 
397  flag(additional_extension_flag);
398 
399  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
400 
401  return 0;
402 }
403 
404 static int FUNC(pps)(CodedBitstreamContext *ctx, RWContext *rw,
405  H264RawPPS *current)
406 {
407  CodedBitstreamH264Context *h264 = ctx->priv_data;
408  const H264RawSPS *sps;
409  int err, i;
410 
411  HEADER("Picture Parameter Set");
412 
413  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
414  1 << H264_NAL_PPS));
415 
416  ue(pic_parameter_set_id, 0, 255);
417  ue(seq_parameter_set_id, 0, 31);
418 
419  sps = h264->sps[current->seq_parameter_set_id];
420  if (!sps) {
421  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
422  current->seq_parameter_set_id);
423  return AVERROR_INVALIDDATA;
424  }
425 
426  flag(entropy_coding_mode_flag);
427  flag(bottom_field_pic_order_in_frame_present_flag);
428 
429  ue(num_slice_groups_minus1, 0, 7);
430  if (current->num_slice_groups_minus1 > 0) {
431  unsigned int pic_size;
432  int iGroup;
433 
434  pic_size = (sps->pic_width_in_mbs_minus1 + 1) *
435  (sps->pic_height_in_map_units_minus1 + 1);
436 
437  ue(slice_group_map_type, 0, 6);
438 
439  if (current->slice_group_map_type == 0) {
440  for (iGroup = 0; iGroup <= current->num_slice_groups_minus1; iGroup++)
441  ues(run_length_minus1[iGroup], 0, pic_size - 1, 1, iGroup);
442 
443  } else if (current->slice_group_map_type == 2) {
444  for (iGroup = 0; iGroup < current->num_slice_groups_minus1; iGroup++) {
445  ues(top_left[iGroup], 0, pic_size - 1, 1, iGroup);
446  ues(bottom_right[iGroup],
447  current->top_left[iGroup], pic_size - 1, 1, iGroup);
448  }
449  } else if (current->slice_group_map_type == 3 ||
450  current->slice_group_map_type == 4 ||
451  current->slice_group_map_type == 5) {
452  flag(slice_group_change_direction_flag);
453  ue(slice_group_change_rate_minus1, 0, pic_size - 1);
454  } else if (current->slice_group_map_type == 6) {
455  ue(pic_size_in_map_units_minus1, pic_size - 1, pic_size - 1);
456 
457  allocate(current->slice_group_id,
458  current->pic_size_in_map_units_minus1 + 1);
459  for (i = 0; i <= current->pic_size_in_map_units_minus1; i++)
460  us(av_log2(2 * current->num_slice_groups_minus1 + 1),
461  slice_group_id[i], 0, current->num_slice_groups_minus1, 1, i);
462  }
463  }
464 
465  ue(num_ref_idx_l0_default_active_minus1, 0, 31);
466  ue(num_ref_idx_l1_default_active_minus1, 0, 31);
467 
468  flag(weighted_pred_flag);
469  u(2, weighted_bipred_idc, 0, 2);
470 
471  se(pic_init_qp_minus26, -26 - 6 * sps->bit_depth_luma_minus8, +25);
472  se(pic_init_qs_minus26, -26, +25);
473  se(chroma_qp_index_offset, -12, +12);
474 
475  flag(deblocking_filter_control_present_flag);
476  flag(constrained_intra_pred_flag);
477  flag(redundant_pic_cnt_present_flag);
478 
479  if (more_rbsp_data(current->more_rbsp_data))
480  {
481  flag(transform_8x8_mode_flag);
482 
483  flag(pic_scaling_matrix_present_flag);
484  if (current->pic_scaling_matrix_present_flag) {
485  for (i = 0; i < 6 + (((sps->chroma_format_idc != 3) ? 2 : 6) *
486  current->transform_8x8_mode_flag); i++) {
487  flags(pic_scaling_list_present_flag[i], 1, i);
488  if (current->pic_scaling_list_present_flag[i]) {
489  if (i < 6)
490  CHECK(FUNC(scaling_list)(ctx, rw,
491  &current->scaling_list_4x4[i],
492  16));
493  else
494  CHECK(FUNC(scaling_list)(ctx, rw,
495  &current->scaling_list_8x8[i - 6],
496  64));
497  }
498  }
499  }
500 
501  se(second_chroma_qp_index_offset, -12, +12);
502  } else {
503  infer(transform_8x8_mode_flag, 0);
504  infer(pic_scaling_matrix_present_flag, 0);
505  infer(second_chroma_qp_index_offset, current->chroma_qp_index_offset);
506  }
507 
508  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
509 
510  return 0;
511 }
512 
513 static int FUNC(sei_buffering_period)(CodedBitstreamContext *ctx, RWContext *rw,
514  H264RawSEIBufferingPeriod *current)
515 {
516  CodedBitstreamH264Context *h264 = ctx->priv_data;
517  const H264RawSPS *sps;
518  int err, i, length;
519 
520  HEADER("Buffering Period");
521 
522  ue(seq_parameter_set_id, 0, 31);
523 
524  sps = h264->sps[current->seq_parameter_set_id];
525  if (!sps) {
526  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
527  current->seq_parameter_set_id);
528  return AVERROR_INVALIDDATA;
529  }
530  h264->active_sps = sps;
531 
532  if (sps->vui.nal_hrd_parameters_present_flag) {
533  for (i = 0; i <= sps->vui.nal_hrd_parameters.cpb_cnt_minus1; i++) {
534  length = sps->vui.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
535  xu(length, initial_cpb_removal_delay[SchedSelIdx],
536  current->nal.initial_cpb_removal_delay[i],
537  1, MAX_UINT_BITS(length), 1, i);
538  xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
539  current->nal.initial_cpb_removal_delay_offset[i],
540  0, MAX_UINT_BITS(length), 1, i);
541  }
542  }
543 
544  if (sps->vui.vcl_hrd_parameters_present_flag) {
545  for (i = 0; i <= sps->vui.vcl_hrd_parameters.cpb_cnt_minus1; i++) {
546  length = sps->vui.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
547  xu(length, initial_cpb_removal_delay[SchedSelIdx],
548  current->vcl.initial_cpb_removal_delay[i],
549  1, MAX_UINT_BITS(length), 1, i);
550  xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
551  current->vcl.initial_cpb_removal_delay_offset[i],
552  0, MAX_UINT_BITS(length), 1, i);
553  }
554  }
555 
556  return 0;
557 }
558 
559 static int FUNC(sei_pic_timestamp)(CodedBitstreamContext *ctx, RWContext *rw,
560  H264RawSEIPicTimestamp *current,
561  const H264RawSPS *sps)
562 {
563  uint8_t time_offset_length;
564  int err;
565 
566  u(2, ct_type, 0, 2);
567  flag(nuit_field_based_flag);
568  u(5, counting_type, 0, 6);
569  flag(full_timestamp_flag);
570  flag(discontinuity_flag);
571  flag(cnt_dropped_flag);
572  ub(8, n_frames);
573  if (current->full_timestamp_flag) {
574  u(6, seconds_value, 0, 59);
575  u(6, minutes_value, 0, 59);
576  u(5, hours_value, 0, 23);
577  } else {
578  flag(seconds_flag);
579  if (current->seconds_flag) {
580  u(6, seconds_value, 0, 59);
581  flag(minutes_flag);
582  if (current->minutes_flag) {
583  u(6, minutes_value, 0, 59);
584  flag(hours_flag);
585  if (current->hours_flag)
586  u(5, hours_value, 0, 23);
587  }
588  }
589  }
590 
591  if (sps->vui.nal_hrd_parameters_present_flag)
592  time_offset_length = sps->vui.nal_hrd_parameters.time_offset_length;
593  else if (sps->vui.vcl_hrd_parameters_present_flag)
594  time_offset_length = sps->vui.vcl_hrd_parameters.time_offset_length;
595  else
596  time_offset_length = 24;
597 
598  if (time_offset_length > 0)
599  ib(time_offset_length, time_offset);
600  else
601  infer(time_offset, 0);
602 
603  return 0;
604 }
605 
606 static int FUNC(sei_pic_timing)(CodedBitstreamContext *ctx, RWContext *rw,
607  H264RawSEIPicTiming *current)
608 {
609  CodedBitstreamH264Context *h264 = ctx->priv_data;
610  const H264RawSPS *sps;
611  int err;
612 
613  HEADER("Picture Timing");
614 
615  sps = h264->active_sps;
616  if (!sps) {
617  // If there is exactly one possible SPS but it is not yet active
618  // then just assume that it should be the active one.
619  int i, k = -1;
620  for (i = 0; i < H264_MAX_SPS_COUNT; i++) {
621  if (h264->sps[i]) {
622  if (k >= 0) {
623  k = -1;
624  break;
625  }
626  k = i;
627  }
628  }
629  if (k >= 0)
630  sps = h264->sps[k];
631  }
632  if (!sps) {
633  av_log(ctx->log_ctx, AV_LOG_ERROR,
634  "No active SPS for pic_timing.\n");
635  return AVERROR_INVALIDDATA;
636  }
637 
638  if (sps->vui.nal_hrd_parameters_present_flag ||
639  sps->vui.vcl_hrd_parameters_present_flag) {
640  const H264RawHRD *hrd;
641 
642  if (sps->vui.nal_hrd_parameters_present_flag)
643  hrd = &sps->vui.nal_hrd_parameters;
644  else if (sps->vui.vcl_hrd_parameters_present_flag)
645  hrd = &sps->vui.vcl_hrd_parameters;
646  else {
647  av_log(ctx->log_ctx, AV_LOG_ERROR,
648  "No HRD parameters for pic_timing.\n");
649  return AVERROR_INVALIDDATA;
650  }
651 
652  ub(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay);
653  ub(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay);
654  }
655 
656  if (sps->vui.pic_struct_present_flag) {
657  static const uint8_t num_clock_ts[9] = {
658  1, 1, 1, 2, 2, 3, 3, 2, 3
659  };
660  int i;
661 
662  u(4, pic_struct, 0, 8);
663  if (current->pic_struct > 8)
664  return AVERROR_INVALIDDATA;
665 
666  for (i = 0; i < num_clock_ts[current->pic_struct]; i++) {
667  flags(clock_timestamp_flag[i], 1, i);
668  if (current->clock_timestamp_flag[i])
669  CHECK(FUNC(sei_pic_timestamp)(ctx, rw,
670  &current->timestamp[i], sps));
671  }
672  }
673 
674  return 0;
675 }
676 
677 static int FUNC(sei_pan_scan_rect)(CodedBitstreamContext *ctx, RWContext *rw,
678  H264RawSEIPanScanRect *current)
679 {
680  int err, i;
681 
682  HEADER("Pan-Scan Rectangle");
683 
684  ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
685  flag(pan_scan_rect_cancel_flag);
686 
687  if (!current->pan_scan_rect_cancel_flag) {
688  ue(pan_scan_cnt_minus1, 0, 2);
689 
690  for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
691  ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
692  ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
693  ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
694  ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
695  }
696 
697  ue(pan_scan_rect_repetition_period, 0, 16384);
698  }
699 
700  return 0;
701 }
702 
703 static int FUNC(sei_user_data_registered)(CodedBitstreamContext *ctx, RWContext *rw,
704  H264RawSEIUserDataRegistered *current,
705  uint32_t *payload_size)
706 {
707  int err, i, j;
708 
709  HEADER("User Data Registered ITU-T T.35");
710 
711  u(8, itu_t_t35_country_code, 0x00, 0xff);
712  if (current->itu_t_t35_country_code != 0xff)
713  i = 1;
714  else {
715  u(8, itu_t_t35_country_code_extension_byte, 0x00, 0xff);
716  i = 2;
717  }
718 
719 #ifdef READ
720  if (*payload_size < i) {
721  av_log(ctx->log_ctx, AV_LOG_ERROR,
722  "Invalid SEI user data registered payload.\n");
723  return AVERROR_INVALIDDATA;
724  }
725  current->data_length = *payload_size - i;
726 #else
727  *payload_size = i + current->data_length;
728 #endif
729 
730  allocate(current->data, current->data_length);
731  for (j = 0; j < current->data_length; j++)
732  xu(8, itu_t_t35_payload_byte[i], current->data[j], 0x00, 0xff, 1, i + j);
733 
734  return 0;
735 }
736 
737 static int FUNC(sei_user_data_unregistered)(CodedBitstreamContext *ctx, RWContext *rw,
738  H264RawSEIUserDataUnregistered *current,
739  uint32_t *payload_size)
740 {
741  int err, i;
742 
743  HEADER("User Data Unregistered");
744 
745 #ifdef READ
746  if (*payload_size < 16) {
747  av_log(ctx->log_ctx, AV_LOG_ERROR,
748  "Invalid SEI user data unregistered payload.\n");
749  return AVERROR_INVALIDDATA;
750  }
751  current->data_length = *payload_size - 16;
752 #else
753  *payload_size = 16 + current->data_length;
754 #endif
755 
756  for (i = 0; i < 16; i++)
757  us(8, uuid_iso_iec_11578[i], 0x00, 0xff, 1, i);
758 
759  allocate(current->data, current->data_length);
760 
761  for (i = 0; i < current->data_length; i++)
762  xu(8, user_data_payload_byte[i], current->data[i], 0x00, 0xff, 1, i);
763 
764  return 0;
765 }
766 
767 static int FUNC(sei_recovery_point)(CodedBitstreamContext *ctx, RWContext *rw,
768  H264RawSEIRecoveryPoint *current)
769 {
770  int err;
771 
772  HEADER("Recovery Point");
773 
774  ue(recovery_frame_cnt, 0, 65535);
775  flag(exact_match_flag);
776  flag(broken_link_flag);
777  u(2, changing_slice_group_idc, 0, 2);
778 
779  return 0;
780 }
781 
782 static int FUNC(sei_display_orientation)(CodedBitstreamContext *ctx, RWContext *rw,
783  H264RawSEIDisplayOrientation *current)
784 {
785  int err;
786 
787  HEADER("Display Orientation");
788 
789  flag(display_orientation_cancel_flag);
790  if (!current->display_orientation_cancel_flag) {
791  flag(hor_flip);
792  flag(ver_flip);
793  ub(16, anticlockwise_rotation);
794  ue(display_orientation_repetition_period, 0, 16384);
795  flag(display_orientation_extension_flag);
796  }
797 
798  return 0;
799 }
800 
801 static int FUNC(sei_mastering_display_colour_volume)(CodedBitstreamContext *ctx, RWContext *rw,
802  H264RawSEIMasteringDisplayColourVolume *current)
803 {
804  int err, c;
805 
806  HEADER("Mastering Display Colour Volume");
807 
808  for (c = 0; c < 3; c++) {
809  us(16, display_primaries_x[c], 0, 50000, 1, c);
810  us(16, display_primaries_y[c], 0, 50000, 1, c);
811  }
812 
813  u(16, white_point_x, 0, 50000);
814  u(16, white_point_y, 0, 50000);
815 
816  u(32, max_display_mastering_luminance, 1, MAX_UINT_BITS(32));
817  u(32, min_display_mastering_luminance, 0, current->max_display_mastering_luminance - 1);
818 
819  return 0;
820 }
821 
822 static int FUNC(sei_alternative_transfer_characteristics)(CodedBitstreamContext *ctx,
823  RWContext *rw,
824  H264RawSEIAlternativeTransferCharacteristics *current)
825 {
826  int err;
827 
828  HEADER("Alternative Transfer Characteristics");
829 
830  ub(8, preferred_transfer_characteristics);
831 
832  return 0;
833 }
834 
835 static int FUNC(sei_payload)(CodedBitstreamContext *ctx, RWContext *rw,
836  H264RawSEIPayload *current)
837 {
838  int err, i;
839  int start_position, end_position;
840 
841 #ifdef READ
842  start_position = get_bits_count(rw);
843 #else
844  start_position = put_bits_count(rw);
845 #endif
846 
847  switch (current->payload_type) {
848  case H264_SEI_TYPE_BUFFERING_PERIOD:
849  CHECK(FUNC(sei_buffering_period)
850  (ctx, rw, &current->payload.buffering_period));
851  break;
852  case H264_SEI_TYPE_PIC_TIMING:
853  CHECK(FUNC(sei_pic_timing)
854  (ctx, rw, &current->payload.pic_timing));
855  break;
856  case H264_SEI_TYPE_PAN_SCAN_RECT:
857  CHECK(FUNC(sei_pan_scan_rect)
858  (ctx, rw, &current->payload.pan_scan_rect));
859  break;
860  case H264_SEI_TYPE_FILLER_PAYLOAD:
861  {
862  for (i = 0; i < current->payload_size; i++)
863  fixed(8, ff_byte, 0xff);
864  }
865  break;
866  case H264_SEI_TYPE_USER_DATA_REGISTERED:
867  CHECK(FUNC(sei_user_data_registered)
868  (ctx, rw, &current->payload.user_data_registered, &current->payload_size));
869  break;
870  case H264_SEI_TYPE_USER_DATA_UNREGISTERED:
871  CHECK(FUNC(sei_user_data_unregistered)
872  (ctx, rw, &current->payload.user_data_unregistered, &current->payload_size));
873  break;
874  case H264_SEI_TYPE_RECOVERY_POINT:
875  CHECK(FUNC(sei_recovery_point)
876  (ctx, rw, &current->payload.recovery_point));
877  break;
878  case H264_SEI_TYPE_DISPLAY_ORIENTATION:
879  CHECK(FUNC(sei_display_orientation)
880  (ctx, rw, &current->payload.display_orientation));
881  break;
882  case H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME:
883  CHECK(FUNC(sei_mastering_display_colour_volume)
884  (ctx, rw, &current->payload.mastering_display_colour_volume));
885  break;
886  case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:
887  CHECK(FUNC(sei_alternative_transfer_characteristics)
888  (ctx, rw, &current->payload.alternative_transfer_characteristics));
889  break;
890  default:
891  {
892 #ifdef READ
893  current->payload.other.data_length = current->payload_size;
894 #endif
895  allocate(current->payload.other.data, current->payload.other.data_length);
896  for (i = 0; i < current->payload.other.data_length; i++)
897  xu(8, payload_byte[i], current->payload.other.data[i], 0, 255, 1, i);
898  }
899  }
900 
901  if (byte_alignment(rw)) {
902  fixed(1, bit_equal_to_one, 1);
903  while (byte_alignment(rw))
904  fixed(1, bit_equal_to_zero, 0);
905  }
906 
907 #ifdef READ
908  end_position = get_bits_count(rw);
909  if (end_position < start_position + 8 * current->payload_size) {
910  av_log(ctx->log_ctx, AV_LOG_ERROR, "Incorrect SEI payload length: "
911  "header %"PRIu32" bits, actually %d bits.\n",
912  8 * current->payload_size,
913  end_position - start_position);
914  return AVERROR_INVALIDDATA;
915  }
916 #else
917  end_position = put_bits_count(rw);
918  current->payload_size = (end_position - start_position) / 8;
919 #endif
920 
921  return 0;
922 }
923 
924 static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,
925  H264RawSEI *current)
926 {
927  int err, k;
928 
929  HEADER("Supplemental Enhancement Information");
930 
931  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
932  1 << H264_NAL_SEI));
933 
934 #ifdef READ
935  for (k = 0; k < H264_MAX_SEI_PAYLOADS; k++) {
936  uint32_t payload_type = 0;
937  uint32_t payload_size = 0;
938  uint32_t tmp;
939 
940  while (show_bits(rw, 8) == 0xff) {
941  fixed(8, ff_byte, 0xff);
942  payload_type += 255;
943  }
944  xu(8, last_payload_type_byte, tmp, 0, 254, 0);
945  payload_type += tmp;
946 
947  while (show_bits(rw, 8) == 0xff) {
948  fixed(8, ff_byte, 0xff);
949  payload_size += 255;
950  }
951  xu(8, last_payload_size_byte, tmp, 0, 254, 0);
952  payload_size += tmp;
953 
954  current->payload[k].payload_type = payload_type;
955  current->payload[k].payload_size = payload_size;
956 
957  current->payload_count++;
958  CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k]));
959 
960  if (!cbs_h2645_read_more_rbsp_data(rw))
961  break;
962  }
963  if (k >= H264_MAX_SEI_PAYLOADS) {
964  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many payloads in "
965  "SEI message: found %d.\n", k);
966  return AVERROR_INVALIDDATA;
967  }
968 #else
969  for (k = 0; k < current->payload_count; k++) {
970  PutBitContext start_state;
971  uint32_t tmp;
972  int need_size, i;
973 
974  // Somewhat clumsy: we write the payload twice when
975  // we don't know the size in advance. This will mess
976  // with trace output, but is otherwise harmless.
977  start_state = *rw;
978  need_size = !current->payload[k].payload_size;
979  for (i = 0; i < 1 + need_size; i++) {
980  *rw = start_state;
981 
982  tmp = current->payload[k].payload_type;
983  while (tmp >= 255) {
984  fixed(8, ff_byte, 0xff);
985  tmp -= 255;
986  }
987  xu(8, last_payload_type_byte, tmp, 0, 254, 0);
988 
989  tmp = current->payload[k].payload_size;
990  while (tmp >= 255) {
991  fixed(8, ff_byte, 0xff);
992  tmp -= 255;
993  }
994  xu(8, last_payload_size_byte, tmp, 0, 254, 0);
995 
996  CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k]));
997  }
998  }
999 #endif
1000 
1001  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
1002 
1003  return 0;
1004 }
1005 
1006 static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw,
1007  H264RawAUD *current)
1008 {
1009  int err;
1010 
1011  HEADER("Access Unit Delimiter");
1012 
1013  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1014  1 << H264_NAL_AUD));
1015 
1016  ub(3, primary_pic_type);
1017 
1018  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
1019 
1020  return 0;
1021 }
1022 
1023 static int FUNC(ref_pic_list_modification)(CodedBitstreamContext *ctx, RWContext *rw,
1024  H264RawSliceHeader *current)
1025 {
1026  CodedBitstreamH264Context *h264 = ctx->priv_data;
1027  const H264RawSPS *sps = h264->active_sps;
1028  int err, i, mopn;
1029 
1030  if (current->slice_type % 5 != 2 &&
1031  current->slice_type % 5 != 4) {
1032  flag(ref_pic_list_modification_flag_l0);
1033  if (current->ref_pic_list_modification_flag_l0) {
1034  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
1035  xue(modification_of_pic_nums_idc,
1036  current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3, 0);
1037 
1038  mopn = current->rplm_l0[i].modification_of_pic_nums_idc;
1039  if (mopn == 3)
1040  break;
1041 
1042  if (mopn == 0 || mopn == 1)
1043  xue(abs_diff_pic_num_minus1,
1044  current->rplm_l0[i].abs_diff_pic_num_minus1,
1045  0, (1 + current->field_pic_flag) *
1046  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
1047  else if (mopn == 2)
1048  xue(long_term_pic_num,
1049  current->rplm_l0[i].long_term_pic_num,
1050  0, sps->max_num_ref_frames - 1, 0);
1051  }
1052  }
1053  }
1054 
1055  if (current->slice_type % 5 == 1) {
1056  flag(ref_pic_list_modification_flag_l1);
1057  if (current->ref_pic_list_modification_flag_l1) {
1058  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
1059  xue(modification_of_pic_nums_idc,
1060  current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3, 0);
1061 
1062  mopn = current->rplm_l1[i].modification_of_pic_nums_idc;
1063  if (mopn == 3)
1064  break;
1065 
1066  if (mopn == 0 || mopn == 1)
1067  xue(abs_diff_pic_num_minus1,
1068  current->rplm_l1[i].abs_diff_pic_num_minus1,
1069  0, (1 + current->field_pic_flag) *
1070  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
1071  else if (mopn == 2)
1072  xue(long_term_pic_num,
1073  current->rplm_l1[i].long_term_pic_num,
1074  0, sps->max_num_ref_frames - 1, 0);
1075  }
1076  }
1077  }
1078 
1079  return 0;
1080 }
1081 
1082 static int FUNC(pred_weight_table)(CodedBitstreamContext *ctx, RWContext *rw,
1083  H264RawSliceHeader *current)
1084 {
1085  CodedBitstreamH264Context *h264 = ctx->priv_data;
1086  const H264RawSPS *sps = h264->active_sps;
1087  int chroma;
1088  int err, i, j;
1089 
1090  ue(luma_log2_weight_denom, 0, 7);
1091 
1092  chroma = !sps->separate_colour_plane_flag && sps->chroma_format_idc != 0;
1093  if (chroma)
1094  ue(chroma_log2_weight_denom, 0, 7);
1095 
1096  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
1097  flags(luma_weight_l0_flag[i], 1, i);
1098  if (current->luma_weight_l0_flag[i]) {
1099  ses(luma_weight_l0[i], -128, +127, 1, i);
1100  ses(luma_offset_l0[i], -128, +127, 1, i);
1101  }
1102  if (chroma) {
1103  flags(chroma_weight_l0_flag[i], 1, i);
1104  if (current->chroma_weight_l0_flag[i]) {
1105  for (j = 0; j < 2; j++) {
1106  ses(chroma_weight_l0[i][j], -128, +127, 2, i, j);
1107  ses(chroma_offset_l0[i][j], -128, +127, 2, i, j);
1108  }
1109  }
1110  }
1111  }
1112 
1113  if (current->slice_type % 5 == 1) {
1114  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
1115  flags(luma_weight_l1_flag[i], 1, i);
1116  if (current->luma_weight_l1_flag[i]) {
1117  ses(luma_weight_l1[i], -128, +127, 1, i);
1118  ses(luma_offset_l1[i], -128, +127, 1, i);
1119  }
1120  if (chroma) {
1121  flags(chroma_weight_l1_flag[i], 1, i);
1122  if (current->chroma_weight_l1_flag[i]) {
1123  for (j = 0; j < 2; j++) {
1124  ses(chroma_weight_l1[i][j], -128, +127, 2, i, j);
1125  ses(chroma_offset_l1[i][j], -128, +127, 2, i, j);
1126  }
1127  }
1128  }
1129  }
1130  }
1131 
1132  return 0;
1133 }
1134 
1135 static int FUNC(dec_ref_pic_marking)(CodedBitstreamContext *ctx, RWContext *rw,
1136  H264RawSliceHeader *current, int idr_pic_flag)
1137 {
1138  CodedBitstreamH264Context *h264 = ctx->priv_data;
1139  const H264RawSPS *sps = h264->active_sps;
1140  int err, i;
1141  uint32_t mmco;
1142 
1143  if (idr_pic_flag) {
1144  flag(no_output_of_prior_pics_flag);
1145  flag(long_term_reference_flag);
1146  } else {
1147  flag(adaptive_ref_pic_marking_mode_flag);
1148  if (current->adaptive_ref_pic_marking_mode_flag) {
1149  for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {
1150  xue(memory_management_control_operation,
1151  current->mmco[i].memory_management_control_operation,
1152  0, 6, 0);
1153 
1154  mmco = current->mmco[i].memory_management_control_operation;
1155  if (mmco == 0)
1156  break;
1157 
1158  if (mmco == 1 || mmco == 3)
1159  xue(difference_of_pic_nums_minus1,
1160  current->mmco[i].difference_of_pic_nums_minus1,
1161  0, INT32_MAX, 0);
1162  if (mmco == 2)
1163  xue(long_term_pic_num,
1164  current->mmco[i].long_term_pic_num,
1165  0, sps->max_num_ref_frames - 1, 0);
1166  if (mmco == 3 || mmco == 6)
1167  xue(long_term_frame_idx,
1168  current->mmco[i].long_term_frame_idx,
1169  0, sps->max_num_ref_frames - 1, 0);
1170  if (mmco == 4)
1171  xue(max_long_term_frame_idx_plus1,
1172  current->mmco[i].max_long_term_frame_idx_plus1,
1173  0, sps->max_num_ref_frames, 0);
1174  }
1175  if (i == H264_MAX_MMCO_COUNT) {
1176  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many "
1177  "memory management control operations.\n");
1178  return AVERROR_INVALIDDATA;
1179  }
1180  }
1181  }
1182 
1183  return 0;
1184 }
1185 
1186 static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
1187  H264RawSliceHeader *current)
1188 {
1189  CodedBitstreamH264Context *h264 = ctx->priv_data;
1190  const H264RawSPS *sps;
1191  const H264RawPPS *pps;
1192  int err;
1193  int idr_pic_flag;
1194  int slice_type_i, slice_type_p, slice_type_b;
1195  int slice_type_si, slice_type_sp;
1196 
1197  HEADER("Slice Header");
1198 
1199  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1200  1 << H264_NAL_SLICE |
1201  1 << H264_NAL_IDR_SLICE |
1202  1 << H264_NAL_AUXILIARY_SLICE));
1203 
1204  if (current->nal_unit_header.nal_unit_type == H264_NAL_AUXILIARY_SLICE) {
1205  if (!h264->last_slice_nal_unit_type) {
1206  av_log(ctx->log_ctx, AV_LOG_ERROR, "Auxiliary slice "
1207  "is not decodable without the main picture "
1208  "in the same access unit.\n");
1209  return AVERROR_INVALIDDATA;
1210  }
1211  idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;
1212  } else {
1213  idr_pic_flag = current->nal_unit_header.nal_unit_type == H264_NAL_IDR_SLICE;
1214  }
1215 
1216  ue(first_mb_in_slice, 0, H264_MAX_MB_PIC_SIZE - 1);
1217  ue(slice_type, 0, 9);
1218 
1219  slice_type_i = current->slice_type % 5 == 2;
1220  slice_type_p = current->slice_type % 5 == 0;
1221  slice_type_b = current->slice_type % 5 == 1;
1222  slice_type_si = current->slice_type % 5 == 4;
1223  slice_type_sp = current->slice_type % 5 == 3;
1224 
1225  if (idr_pic_flag && !(slice_type_i || slice_type_si)) {
1226  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid slice type %d "
1227  "for IDR picture.\n", current->slice_type);
1228  return AVERROR_INVALIDDATA;
1229  }
1230 
1231  ue(pic_parameter_set_id, 0, 255);
1232 
1233  pps = h264->pps[current->pic_parameter_set_id];
1234  if (!pps) {
1235  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
1236  current->pic_parameter_set_id);
1237  return AVERROR_INVALIDDATA;
1238  }
1239  h264->active_pps = pps;
1240 
1241  sps = h264->sps[pps->seq_parameter_set_id];
1242  if (!sps) {
1243  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1244  pps->seq_parameter_set_id);
1245  return AVERROR_INVALIDDATA;
1246  }
1247  h264->active_sps = sps;
1248 
1249  if (sps->separate_colour_plane_flag)
1250  u(2, colour_plane_id, 0, 2);
1251 
1252  ub(sps->log2_max_frame_num_minus4 + 4, frame_num);
1253 
1254  if (!sps->frame_mbs_only_flag) {
1255  flag(field_pic_flag);
1256  if (current->field_pic_flag)
1257  flag(bottom_field_flag);
1258  else
1259  infer(bottom_field_flag, 0);
1260  } else {
1261  infer(field_pic_flag, 0);
1262  infer(bottom_field_flag, 0);
1263  }
1264 
1265  if (idr_pic_flag)
1266  ue(idr_pic_id, 0, 65535);
1267 
1268  if (sps->pic_order_cnt_type == 0) {
1269  ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb);
1270  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1271  !current->field_pic_flag)
1272  se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);
1273 
1274  } else if (sps->pic_order_cnt_type == 1) {
1275  if (!sps->delta_pic_order_always_zero_flag) {
1276  se(delta_pic_order_cnt[0], INT32_MIN + 1, INT32_MAX);
1277  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1278  !current->field_pic_flag)
1279  se(delta_pic_order_cnt[1], INT32_MIN + 1, INT32_MAX);
1280  else
1281  infer(delta_pic_order_cnt[1], 0);
1282  } else {
1283  infer(delta_pic_order_cnt[0], 0);
1284  infer(delta_pic_order_cnt[1], 0);
1285  }
1286  }
1287 
1288  if (pps->redundant_pic_cnt_present_flag)
1289  ue(redundant_pic_cnt, 0, 127);
1290  else
1291  infer(redundant_pic_cnt, 0);
1292 
1293  if (current->nal_unit_header.nal_unit_type != H264_NAL_AUXILIARY_SLICE
1294  && !current->redundant_pic_cnt)
1295  h264->last_slice_nal_unit_type =
1296  current->nal_unit_header.nal_unit_type;
1297 
1298  if (slice_type_b)
1299  flag(direct_spatial_mv_pred_flag);
1300 
1301  if (slice_type_p || slice_type_sp || slice_type_b) {
1302  flag(num_ref_idx_active_override_flag);
1303  if (current->num_ref_idx_active_override_flag) {
1304  ue(num_ref_idx_l0_active_minus1, 0, 31);
1305  if (slice_type_b)
1306  ue(num_ref_idx_l1_active_minus1, 0, 31);
1307  } else {
1308  infer(num_ref_idx_l0_active_minus1,
1309  pps->num_ref_idx_l0_default_active_minus1);
1310  infer(num_ref_idx_l1_active_minus1,
1311  pps->num_ref_idx_l1_default_active_minus1);
1312  }
1313  }
1314 
1315  if (current->nal_unit_header.nal_unit_type == 20 ||
1316  current->nal_unit_header.nal_unit_type == 21) {
1317  av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC / 3DAVC not supported.\n");
1318  return AVERROR_PATCHWELCOME;
1319  } else {
1320  CHECK(FUNC(ref_pic_list_modification)(ctx, rw, current));
1321  }
1322 
1323  if ((pps->weighted_pred_flag && (slice_type_p || slice_type_sp)) ||
1324  (pps->weighted_bipred_idc == 1 && slice_type_b)) {
1325  CHECK(FUNC(pred_weight_table)(ctx, rw, current));
1326  }
1327 
1328  if (current->nal_unit_header.nal_ref_idc != 0) {
1329  CHECK(FUNC(dec_ref_pic_marking)(ctx, rw, current, idr_pic_flag));
1330  }
1331 
1332  if (pps->entropy_coding_mode_flag &&
1333  !slice_type_i && !slice_type_si) {
1334  ue(cabac_init_idc, 0, 2);
1335  }
1336 
1337  se(slice_qp_delta, - 51 - 6 * sps->bit_depth_luma_minus8,
1338  + 51 + 6 * sps->bit_depth_luma_minus8);
1339  if (slice_type_sp || slice_type_si) {
1340  if (slice_type_sp)
1341  flag(sp_for_switch_flag);
1342  se(slice_qs_delta, -51, +51);
1343  }
1344 
1345  if (pps->deblocking_filter_control_present_flag) {
1346  ue(disable_deblocking_filter_idc, 0, 2);
1347  if (current->disable_deblocking_filter_idc != 1) {
1348  se(slice_alpha_c0_offset_div2, -6, +6);
1349  se(slice_beta_offset_div2, -6, +6);
1350  } else {
1351  infer(slice_alpha_c0_offset_div2, 0);
1352  infer(slice_beta_offset_div2, 0);
1353  }
1354  } else {
1355  infer(disable_deblocking_filter_idc, 0);
1356  infer(slice_alpha_c0_offset_div2, 0);
1357  infer(slice_beta_offset_div2, 0);
1358  }
1359 
1360  if (pps->num_slice_groups_minus1 > 0 &&
1361  pps->slice_group_map_type >= 3 &&
1362  pps->slice_group_map_type <= 5) {
1363  unsigned int pic_size, max, bits;
1364 
1365  pic_size = (sps->pic_width_in_mbs_minus1 + 1) *
1366  (sps->pic_height_in_map_units_minus1 + 1);
1367  max = (pic_size + pps->slice_group_change_rate_minus1) /
1368  (pps->slice_group_change_rate_minus1 + 1);
1369  bits = av_ceil_log2(max + 1);
1370 
1371  u(bits, slice_group_change_cycle, 0, max);
1372  }
1373 
1374  if (pps->entropy_coding_mode_flag) {
1375  while (byte_alignment(rw))
1376  fixed(1, cabac_alignment_one_bit, 1);
1377  }
1378 
1379  return 0;
1380 }
1381 
1382 static int FUNC(filler)(CodedBitstreamContext *ctx, RWContext *rw,
1383  H264RawFiller *current)
1384 {
1385  int err;
1386 
1387  HEADER("Filler Data");
1388 
1389  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1390  1 << H264_NAL_FILLER_DATA));
1391 
1392 #ifdef READ
1393  while (show_bits(rw, 8) == 0xff) {
1394  fixed(8, ff_byte, 0xff);
1395  ++current->filler_size;
1396  }
1397 #else
1398  {
1399  uint32_t i;
1400  for (i = 0; i < current->filler_size; i++)
1401  fixed(8, ff_byte, 0xff);
1402  }
1403 #endif
1404 
1405  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
1406 
1407  return 0;
1408 }
1409 
1410 static int FUNC(end_of_sequence)(CodedBitstreamContext *ctx, RWContext *rw,
1411  H264RawNALUnitHeader *current)
1412 {
1413  HEADER("End of Sequence");
1414 
1415  return FUNC(nal_unit_header)(ctx, rw, current,
1416  1 << H264_NAL_END_SEQUENCE);
1417 }
1418 
1419 static int FUNC(end_of_stream)(CodedBitstreamContext *ctx, RWContext *rw,
1420  H264RawNALUnitHeader *current)
1421 {
1422  HEADER("End of Stream");
1423 
1424  return FUNC(nal_unit_header)(ctx, rw, current,
1425  1 << H264_NAL_END_STREAM);
1426 }
H264_SEI_TYPE_BUFFERING_PERIOD
@ H264_SEI_TYPE_BUFFERING_PERIOD
buffering period (H.264, D.1.1)
Definition: h264_sei.h:28
xue
#define xue(name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:380
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
byte_alignment
#define byte_alignment(rw)
Definition: cbs_av1.c:722
H264_NAL_END_STREAM
@ H264_NAL_END_STREAM
Definition: h264.h:45
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
H264_SEI_TYPE_RECOVERY_POINT
@ H264_SEI_TYPE_RECOVERY_POINT
recovery point (frame # to decoder sync)
Definition: h264_sei.h:34
rbsp_trailing_bits
static int FUNC() rbsp_trailing_bits(CodedBitstreamContext *ctx, RWContext *rw)
Definition: cbs_h264_syntax_template.c:19
se
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:263
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
HEADER
#define HEADER(name)
Definition: cbs_av1.c:537
CodedBitstreamH264Context::pps
H264RawPPS * pps[H264_MAX_PPS_COUNT]
Definition: cbs_h264.h:454
infer
#define infer(name, value)
Definition: cbs_av1.c:713
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:168
level_idc
int level_idc
Definition: h264_levels.c:25
H264RawHRD::dpb_output_delay_length_minus1
uint8_t dpb_output_delay_length_minus1
Definition: cbs_h264.h:63
H264_MAX_MB_HEIGHT
@ H264_MAX_MB_HEIGHT
Definition: h264.h:107
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:1511
H264RawHRD
Definition: cbs_h264.h:52
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:412
max
#define max(a, b)
Definition: cuda_runtime.h:33
H264_NAL_AUXILIARY_SLICE
@ H264_NAL_AUXILIARY_SLICE
Definition: h264.h:53
sei_buffering_period
static int FUNC() sei_buffering_period(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIBufferingPeriod *current)
Definition: cbs_h264_syntax_template.c:513
H264_SEI_TYPE_USER_DATA_REGISTERED
@ H264_SEI_TYPE_USER_DATA_REGISTERED
registered user data as specified by Rec. ITU-T T.35
Definition: h264_sei.h:32
ses
#define ses(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
sei_alternative_transfer_characteristics
static int FUNC() sei_alternative_transfer_characteristics(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIAlternativeTransferCharacteristics *current)
Definition: cbs_h264_syntax_template.c:822
H264RawSEIPicTiming
Definition: cbs_h264.h:258
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
H264RawSEIAlternativeTransferCharacteristics
Definition: cbs_h264.h:317
sei_display_orientation
static int FUNC() sei_display_orientation(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIDisplayOrientation *current)
Definition: cbs_h264_syntax_template.c:782
CodedBitstreamH264Context::active_sps
const H264RawSPS * active_sps
Definition: cbs_h264.h:459
filler
static int FUNC() filler(CodedBitstreamContext *ctx, RWContext *rw, H264RawFiller *current)
Definition: cbs_h264_syntax_template.c:1382
ub
#define ub(width, name)
Definition: cbs_h2645.c:254
H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
@ H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
mastering display properties
Definition: h264_sei.h:38
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:257
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:266
H264RawSEIPicTimestamp
Definition: cbs_h264.h:241
H264RawSEIPayload
Definition: cbs_h264.h:321
H264_MAX_SPS_COUNT
@ H264_MAX_SPS_COUNT
Definition: h264.h:71
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
sei_mastering_display_colour_volume
static int FUNC() sei_mastering_display_colour_volume(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIMasteringDisplayColourVolume *current)
Definition: cbs_h264_syntax_template.c:801
H264RawSEIMasteringDisplayColourVolume
Definition: cbs_h264.h:308
H264_MAX_MMCO_COUNT
@ H264_MAX_MMCO_COUNT
Definition: h264.h:92
sei_payload
static int FUNC() sei_payload(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPayload *current)
Definition: cbs_h264_syntax_template.c:835
H264_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
H264_MAX_SEI_PAYLOADS
@ H264_MAX_SEI_PAYLOADS
Definition: cbs_h264.h:36
sps_extension
static int FUNC() sps_extension(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPSExtension *current)
Definition: cbs_h264_syntax_template.c:372
bits
uint8_t bits
Definition: vp3data.h:202
ctx
AVFormatContext * ctx
Definition: movenc.c:48
H264_MAX_MB_WIDTH
@ H264_MAX_MB_WIDTH
Definition: h264.h:106
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:98
PutBitContext
Definition: put_bits.h:35
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:1082
H264RawSEIUserDataUnregistered
Definition: cbs_h264.h:285
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
slice_header
static int FUNC() slice_header(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:1186
profile_idc
int profile_idc
Definition: h264_levels.c:52
end_of_stream
static int FUNC() end_of_stream(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1419
H264RawNALUnitHeader
Definition: cbs_h264.h:40
sei_user_data_unregistered
static int FUNC() sei_user_data_unregistered(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIUserDataUnregistered *current, uint32_t *payload_size)
Definition: cbs_h264_syntax_template.c:737
H264RawSEIPanScanRect
Definition: cbs_h264.h:266
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:924
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
CodedBitstreamH264Context
Definition: cbs_h264.h:445
hrd_parameters
static int FUNC() hrd_parameters(CodedBitstreamContext *ctx, RWContext *rw, H264RawHRD *current)
Definition: cbs_h264_syntax_template.c:88
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:1006
sei_pan_scan_rect
static int FUNC() sei_pan_scan_rect(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPanScanRect *current)
Definition: cbs_h264_syntax_template.c:677
H264RawSEIUserDataRegistered
Definition: cbs_h264.h:277
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:176
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
sei_pic_timing
static int FUNC() sei_pic_timing(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPicTiming *current)
Definition: cbs_h264_syntax_template.c:606
H264RawSEIDisplayOrientation
Definition: cbs_h264.h:299
H264_SEI_TYPE_USER_DATA_UNREGISTERED
@ H264_SEI_TYPE_USER_DATA_UNREGISTERED
unregistered user data
Definition: h264_sei.h:33
H264_SEI_TYPE_FILLER_PAYLOAD
@ H264_SEI_TYPE_FILLER_PAYLOAD
filler data
Definition: h264_sei.h:31
CodedBitstreamH264Context::active_pps
const H264RawPPS * active_pps
Definition: cbs_h264.h:460
H264RawSliceHeader
Definition: cbs_h264.h:351
ref_pic_list_modification
static int FUNC() ref_pic_list_modification(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:1023
sei_user_data_registered
static int FUNC() sei_user_data_registered(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIUserDataRegistered *current, uint32_t *payload_size)
Definition: cbs_h264_syntax_template.c:703
flag
#define flag(name)
Definition: cbs_av1.c:557
vui_parameters
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H264RawVUI *current, H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:111
H264_MAX_RPLM_COUNT
@ H264_MAX_RPLM_COUNT
Definition: h264.h:84
CodedBitstreamH264Context::last_slice_nal_unit_type
uint8_t last_slice_nal_unit_type
Definition: cbs_h264.h:465
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
uint8_t
uint8_t
Definition: audio_convert.c:194
H264_SEI_TYPE_DISPLAY_ORIENTATION
@ H264_SEI_TYPE_DISPLAY_ORIENTATION
display orientation
Definition: h264_sei.h:36
H264RawScalingList
Definition: cbs_h264.h:48
H264_SEI_TYPE_PAN_SCAN_RECT
@ H264_SEI_TYPE_PAN_SCAN_RECT
pan-scan rectangle
Definition: h264_sei.h:30
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
H264RawVUI
Definition: cbs_h264.h:67
H264RawSEI
Definition: cbs_h264.h:344
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
nal_unit_header
static int FUNC() nal_unit_header(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current, uint32_t valid_type_mask)
Definition: cbs_h264_syntax_template.c:30
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
H264RawHRD::cpb_removal_delay_length_minus1
uint8_t cpb_removal_delay_length_minus1
Definition: cbs_h264.h:62
dec_ref_pic_marking
static int FUNC() dec_ref_pic_marking(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current, int idr_pic_flag)
Definition: cbs_h264_syntax_template.c:1135
sei_recovery_point
static int FUNC() sei_recovery_point(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIRecoveryPoint *current)
Definition: cbs_h264_syntax_template.c:767
H264RawAUD
Definition: cbs_h264.h:227
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
end_of_sequence
static int FUNC() end_of_sequence(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1410
scaling_list
static int FUNC() scaling_list(CodedBitstreamContext *ctx, RWContext *rw, H264RawScalingList *current, int size_of_scaling_list)
Definition: cbs_h264_syntax_template.c:71
more_rbsp_data
#define more_rbsp_data(var)
Definition: cbs_h2645.c:408
H264RawSEIRecoveryPoint
Definition: cbs_h264.h:292
H264_SEI_TYPE_PIC_TIMING
@ H264_SEI_TYPE_PIC_TIMING
picture timing
Definition: h264_sei.h:29
ib
#define ib(width, name)
Definition: cbs_h2645.c:261
H264_NAL_SPS_EXT
@ H264_NAL_SPS_EXT
Definition: h264.h:47
H264_NAL_END_SEQUENCE
@ H264_NAL_END_SEQUENCE
Definition: h264.h:44
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:570
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
H264RawFiller
Definition: cbs_h264.h:438
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
length
const char int length
Definition: avisynth_c.h:860
H264_MAX_MB_PIC_SIZE
@ H264_MAX_MB_PIC_SIZE
Definition: h264.h:102
ues
#define ues(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:272
H264RawSPSExtension
Definition: cbs_h264.h:166
vui_parameters_default
static int FUNC() vui_parameters_default(CodedBitstreamContext *ctx, RWContext *rw, H264RawVUI *current, H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:220
H264RawSEIBufferingPeriod
Definition: cbs_h264.h:233
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:374
RWContext
#define RWContext
Definition: cbs_av1.c:666
CodedBitstreamH264Context::sps
H264RawSPS * sps[H264_MAX_SPS_COUNT]
Definition: cbs_h264.h:453
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1370
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
H264_SEI_TYPE_ALTERNATIVE_TRANSFER
@ H264_SEI_TYPE_ALTERNATIVE_TRANSFER
alternative transfer
Definition: h264_sei.h:39
cbs_h2645_read_more_rbsp_data
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
Definition: cbs_h2645.c:325
H264RawSPS
Definition: cbs_h264.h:111
sei_pic_timestamp
static int FUNC() sei_pic_timestamp(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPicTimestamp *current, const H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:559
H264RawPPS
Definition: cbs_h264.h:180
Generated on Wed Aug 24 2022 21:26:35 for FFmpeg by   doxygen 1.8.17