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 
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 
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 
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 
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 
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);
139  ub(8, matrix_coefficients);
140  } else {
141  infer(colour_primaries, 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);
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 
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);
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 
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 
368 
369  return 0;
370 }
371 
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 
400 
401  return 0;
402 }
403 
405  H264RawPPS *current)
406 {
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 
509 
510  return 0;
511 }
512 
514  H264RawSEIBufferingPeriod *current,
516 {
518  const H264RawSPS *sps;
519  int err, i, length;
520 
521  HEADER("Buffering Period");
522 
523  ue(seq_parameter_set_id, 0, 31);
524 
525  sps = h264->sps[current->seq_parameter_set_id];
526  if (!sps) {
527  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
528  current->seq_parameter_set_id);
529  return AVERROR_INVALIDDATA;
530  }
531  h264->active_sps = sps;
532 
533  if (sps->vui.nal_hrd_parameters_present_flag) {
534  for (i = 0; i <= sps->vui.nal_hrd_parameters.cpb_cnt_minus1; i++) {
535  length = sps->vui.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
536  xu(length, initial_cpb_removal_delay[SchedSelIdx],
537  current->nal.initial_cpb_removal_delay[i],
538  1, MAX_UINT_BITS(length), 1, i);
539  xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
540  current->nal.initial_cpb_removal_delay_offset[i],
541  0, MAX_UINT_BITS(length), 1, i);
542  }
543  }
544 
545  if (sps->vui.vcl_hrd_parameters_present_flag) {
546  for (i = 0; i <= sps->vui.vcl_hrd_parameters.cpb_cnt_minus1; i++) {
547  length = sps->vui.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
548  xu(length, initial_cpb_removal_delay[SchedSelIdx],
549  current->vcl.initial_cpb_removal_delay[i],
550  1, MAX_UINT_BITS(length), 1, i);
551  xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
552  current->vcl.initial_cpb_removal_delay_offset[i],
553  0, MAX_UINT_BITS(length), 1, i);
554  }
555  }
556 
557  return 0;
558 }
559 
561  H264RawSEIPicTimestamp *current,
562  const H264RawSPS *sps)
563 {
564  uint8_t time_offset_length;
565  int err;
566 
567  u(2, ct_type, 0, 2);
568  flag(nuit_field_based_flag);
569  u(5, counting_type, 0, 6);
570  flag(full_timestamp_flag);
571  flag(discontinuity_flag);
572  flag(cnt_dropped_flag);
573  ub(8, n_frames);
574  if (current->full_timestamp_flag) {
575  u(6, seconds_value, 0, 59);
576  u(6, minutes_value, 0, 59);
577  u(5, hours_value, 0, 23);
578  } else {
579  flag(seconds_flag);
580  if (current->seconds_flag) {
581  u(6, seconds_value, 0, 59);
582  flag(minutes_flag);
583  if (current->minutes_flag) {
584  u(6, minutes_value, 0, 59);
585  flag(hours_flag);
586  if (current->hours_flag)
587  u(5, hours_value, 0, 23);
588  }
589  }
590  }
591 
592  if (sps->vui.nal_hrd_parameters_present_flag)
593  time_offset_length = sps->vui.nal_hrd_parameters.time_offset_length;
594  else if (sps->vui.vcl_hrd_parameters_present_flag)
595  time_offset_length = sps->vui.vcl_hrd_parameters.time_offset_length;
596  else
597  time_offset_length = 24;
598 
599  if (time_offset_length > 0)
600  ib(time_offset_length, time_offset);
601  else
602  infer(time_offset, 0);
603 
604  return 0;
605 }
606 
608  H264RawSEIPicTiming *current,
610 {
612  const H264RawSPS *sps;
613  int err;
614 
615  HEADER("Picture Timing");
616 
617  sps = h264->active_sps;
618  if (!sps) {
619  // If there is exactly one possible SPS but it is not yet active
620  // then just assume that it should be the active one.
621  int i, k = -1;
622  for (i = 0; i < H264_MAX_SPS_COUNT; i++) {
623  if (h264->sps[i]) {
624  if (k >= 0) {
625  k = -1;
626  break;
627  }
628  k = i;
629  }
630  }
631  if (k >= 0)
632  sps = h264->sps[k];
633  }
634  if (!sps) {
635  av_log(ctx->log_ctx, AV_LOG_ERROR,
636  "No active SPS for pic_timing.\n");
637  return AVERROR_INVALIDDATA;
638  }
639 
640  if (sps->vui.nal_hrd_parameters_present_flag ||
641  sps->vui.vcl_hrd_parameters_present_flag) {
642  const H264RawHRD *hrd;
643 
644  if (sps->vui.nal_hrd_parameters_present_flag)
645  hrd = &sps->vui.nal_hrd_parameters;
646  else if (sps->vui.vcl_hrd_parameters_present_flag)
647  hrd = &sps->vui.vcl_hrd_parameters;
648  else {
649  av_log(ctx->log_ctx, AV_LOG_ERROR,
650  "No HRD parameters for pic_timing.\n");
651  return AVERROR_INVALIDDATA;
652  }
653 
654  ub(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay);
655  ub(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay);
656  }
657 
658  if (sps->vui.pic_struct_present_flag) {
659  static const uint8_t num_clock_ts[9] = {
660  1, 1, 1, 2, 2, 3, 3, 2, 3
661  };
662  int i;
663 
664  u(4, pic_struct, 0, 8);
665  if (current->pic_struct > 8)
666  return AVERROR_INVALIDDATA;
667 
668  for (i = 0; i < num_clock_ts[current->pic_struct]; i++) {
669  flags(clock_timestamp_flag[i], 1, i);
670  if (current->clock_timestamp_flag[i])
672  &current->timestamp[i], sps));
673  }
674  }
675 
676  return 0;
677 }
678 
680  H264RawSEIPanScanRect *current,
682 {
683  int err, i;
684 
685  HEADER("Pan-Scan Rectangle");
686 
687  ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
688  flag(pan_scan_rect_cancel_flag);
689 
690  if (!current->pan_scan_rect_cancel_flag) {
691  ue(pan_scan_cnt_minus1, 0, 2);
692 
693  for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
694  ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
695  ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
696  ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
697  ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
698  }
699 
700  ue(pan_scan_rect_repetition_period, 0, 16384);
701  }
702 
703  return 0;
704 }
705 
707  H264RawSEIRecoveryPoint *current,
709 {
710  int err;
711 
712  HEADER("Recovery Point");
713 
714  ue(recovery_frame_cnt, 0, 65535);
715  flag(exact_match_flag);
716  flag(broken_link_flag);
717  u(2, changing_slice_group_idc, 0, 2);
718 
719  return 0;
720 }
721 
725 {
727  const H264RawSPS *sps;
728  int err, c, i, j;
729 
730  HEADER("Film Grain Characteristics");
731 
732  sps = h264->active_sps;
733  if (!sps) {
734  // If there is exactly one possible SPS but it is not yet active
735  // then just assume that it should be the active one.
736  int i, k = -1;
737  for (i = 0; i < H264_MAX_SPS_COUNT; i++) {
738  if (h264->sps[i]) {
739  if (k >= 0) {
740  k = -1;
741  break;
742  }
743  k = i;
744  }
745  }
746  if (k >= 0)
747  sps = h264->sps[k];
748  }
749 
750  flag(film_grain_characteristics_cancel_flag);
751  if (!current->film_grain_characteristics_cancel_flag) {
752  int filmGrainBitDepth[3];
753 
754  u(2, film_grain_model_id, 0, 1);
755  flag(separate_colour_description_present_flag);
756  if (current->separate_colour_description_present_flag) {
757  ub(3, film_grain_bit_depth_luma_minus8);
758  ub(3, film_grain_bit_depth_chroma_minus8);
759  flag(film_grain_full_range_flag);
760  ub(8, film_grain_colour_primaries);
761  ub(8, film_grain_transfer_characteristics);
762  ub(8, film_grain_matrix_coefficients);
763  } else {
764  if (!sps) {
765  av_log(ctx->log_ctx, AV_LOG_ERROR,
766  "No active SPS for film_grain_characteristics.\n");
767  return AVERROR_INVALIDDATA;
768  }
769  infer(film_grain_bit_depth_luma_minus8, sps->bit_depth_luma_minus8);
770  infer(film_grain_bit_depth_chroma_minus8, sps->bit_depth_chroma_minus8);
771  infer(film_grain_full_range_flag, sps->vui.video_full_range_flag);
772  infer(film_grain_colour_primaries, sps->vui.colour_primaries);
773  infer(film_grain_transfer_characteristics, sps->vui.transfer_characteristics);
774  infer(film_grain_matrix_coefficients, sps->vui.matrix_coefficients);
775  }
776 
777  filmGrainBitDepth[0] = current->film_grain_bit_depth_luma_minus8 + 8;
778  filmGrainBitDepth[1] =
779  filmGrainBitDepth[2] = current->film_grain_bit_depth_chroma_minus8 + 8;
780 
781  u(2, blending_mode_id, 0, 1);
782  ub(4, log2_scale_factor);
783  for (c = 0; c < 3; c++)
784  flags(comp_model_present_flag[c], 1, c);
785  for (c = 0; c < 3; c++) {
786  if (current->comp_model_present_flag[c]) {
787  ubs(8, num_intensity_intervals_minus1[c], 1, c);
788  us(3, num_model_values_minus1[c], 0, 5, 1, c);
789  for (i = 0; i <= current->num_intensity_intervals_minus1[c]; i++) {
790  ubs(8, intensity_interval_lower_bound[c][i], 2, c, i);
791  ubs(8, intensity_interval_upper_bound[c][i], 2, c, i);
792  for (j = 0; j <= current->num_model_values_minus1[c]; j++)
793  ses(comp_model_value[c][i][j], 0 - current->film_grain_model_id * (1 << (filmGrainBitDepth[c] - 1)),
794  ((1 << filmGrainBitDepth[c]) - 1) - current->film_grain_model_id * (1 << (filmGrainBitDepth[c] - 1)),
795  3, c, i, j);
796  }
797  }
798  }
799  ue(film_grain_characteristics_repetition_period, 0, 16384);
800  }
801 
802  return 0;
803 }
804 
808 {
809  int err;
810 
811  HEADER("Display Orientation");
812 
813  flag(display_orientation_cancel_flag);
814  if (!current->display_orientation_cancel_flag) {
815  flag(hor_flip);
816  flag(ver_flip);
817  ub(16, anticlockwise_rotation);
818  ue(display_orientation_repetition_period, 0, 16384);
819  flag(display_orientation_extension_flag);
820  }
821 
822  return 0;
823 }
824 
826  H264RawSEI *current)
827 {
828  int err;
829 
830  HEADER("Supplemental Enhancement Information");
831 
832  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
833  1 << H264_NAL_SEI));
834 
835  CHECK(FUNC_SEI(message_list)(ctx, rw, &current->message_list, 1));
836 
838 
839  return 0;
840 }
841 
843  H264RawAUD *current)
844 {
845  int err;
846 
847  HEADER("Access Unit Delimiter");
848 
849  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
850  1 << H264_NAL_AUD));
851 
852  ub(3, primary_pic_type);
853 
855 
856  return 0;
857 }
858 
860  H264RawSliceHeader *current)
861 {
863  const H264RawSPS *sps = h264->active_sps;
864  int err, i, mopn;
865 
866  if (current->slice_type % 5 != 2 &&
867  current->slice_type % 5 != 4) {
868  flag(ref_pic_list_modification_flag_l0);
869  if (current->ref_pic_list_modification_flag_l0) {
870  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
871  xue(modification_of_pic_nums_idc,
872  current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3, 0);
873 
874  mopn = current->rplm_l0[i].modification_of_pic_nums_idc;
875  if (mopn == 3)
876  break;
877 
878  if (mopn == 0 || mopn == 1)
879  xue(abs_diff_pic_num_minus1,
880  current->rplm_l0[i].abs_diff_pic_num_minus1,
881  0, (1 + current->field_pic_flag) *
882  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
883  else if (mopn == 2)
884  xue(long_term_pic_num,
885  current->rplm_l0[i].long_term_pic_num,
886  0, sps->max_num_ref_frames - 1, 0);
887  }
888  }
889  }
890 
891  if (current->slice_type % 5 == 1) {
892  flag(ref_pic_list_modification_flag_l1);
893  if (current->ref_pic_list_modification_flag_l1) {
894  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
895  xue(modification_of_pic_nums_idc,
896  current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3, 0);
897 
898  mopn = current->rplm_l1[i].modification_of_pic_nums_idc;
899  if (mopn == 3)
900  break;
901 
902  if (mopn == 0 || mopn == 1)
903  xue(abs_diff_pic_num_minus1,
904  current->rplm_l1[i].abs_diff_pic_num_minus1,
905  0, (1 + current->field_pic_flag) *
906  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
907  else if (mopn == 2)
908  xue(long_term_pic_num,
909  current->rplm_l1[i].long_term_pic_num,
910  0, sps->max_num_ref_frames - 1, 0);
911  }
912  }
913  }
914 
915  return 0;
916 }
917 
919  H264RawSliceHeader *current)
920 {
922  const H264RawSPS *sps = h264->active_sps;
923  int chroma;
924  int err, i, j;
925 
926  ue(luma_log2_weight_denom, 0, 7);
927 
928  chroma = !sps->separate_colour_plane_flag && sps->chroma_format_idc != 0;
929  if (chroma)
930  ue(chroma_log2_weight_denom, 0, 7);
931 
932  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
933  flags(luma_weight_l0_flag[i], 1, i);
934  if (current->luma_weight_l0_flag[i]) {
935  ses(luma_weight_l0[i], -128, +127, 1, i);
936  ses(luma_offset_l0[i], -128, +127, 1, i);
937  }
938  if (chroma) {
939  flags(chroma_weight_l0_flag[i], 1, i);
940  if (current->chroma_weight_l0_flag[i]) {
941  for (j = 0; j < 2; j++) {
942  ses(chroma_weight_l0[i][j], -128, +127, 2, i, j);
943  ses(chroma_offset_l0[i][j], -128, +127, 2, i, j);
944  }
945  }
946  }
947  }
948 
949  if (current->slice_type % 5 == 1) {
950  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
951  flags(luma_weight_l1_flag[i], 1, i);
952  if (current->luma_weight_l1_flag[i]) {
953  ses(luma_weight_l1[i], -128, +127, 1, i);
954  ses(luma_offset_l1[i], -128, +127, 1, i);
955  }
956  if (chroma) {
957  flags(chroma_weight_l1_flag[i], 1, i);
958  if (current->chroma_weight_l1_flag[i]) {
959  for (j = 0; j < 2; j++) {
960  ses(chroma_weight_l1[i][j], -128, +127, 2, i, j);
961  ses(chroma_offset_l1[i][j], -128, +127, 2, i, j);
962  }
963  }
964  }
965  }
966  }
967 
968  return 0;
969 }
970 
972  H264RawSliceHeader *current, int idr_pic_flag)
973 {
975  const H264RawSPS *sps = h264->active_sps;
976  int err, i;
977  uint32_t mmco;
978 
979  if (idr_pic_flag) {
980  flag(no_output_of_prior_pics_flag);
981  flag(long_term_reference_flag);
982  } else {
983  flag(adaptive_ref_pic_marking_mode_flag);
984  if (current->adaptive_ref_pic_marking_mode_flag) {
985  for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {
986  xue(memory_management_control_operation,
987  current->mmco[i].memory_management_control_operation,
988  0, 6, 0);
989 
990  mmco = current->mmco[i].memory_management_control_operation;
991  if (mmco == 0)
992  break;
993 
994  if (mmco == 1 || mmco == 3)
995  xue(difference_of_pic_nums_minus1,
996  current->mmco[i].difference_of_pic_nums_minus1,
997  0, INT32_MAX, 0);
998  if (mmco == 2)
999  xue(long_term_pic_num,
1000  current->mmco[i].long_term_pic_num,
1001  0, sps->max_num_ref_frames - 1, 0);
1002  if (mmco == 3 || mmco == 6)
1003  xue(long_term_frame_idx,
1004  current->mmco[i].long_term_frame_idx,
1005  0, sps->max_num_ref_frames - 1, 0);
1006  if (mmco == 4)
1007  xue(max_long_term_frame_idx_plus1,
1008  current->mmco[i].max_long_term_frame_idx_plus1,
1009  0, sps->max_num_ref_frames, 0);
1010  }
1011  if (i == H264_MAX_MMCO_COUNT) {
1012  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many "
1013  "memory management control operations.\n");
1014  return AVERROR_INVALIDDATA;
1015  }
1016  }
1017  }
1018 
1019  return 0;
1020 }
1021 
1023  H264RawSliceHeader *current)
1024 {
1026  const H264RawSPS *sps;
1027  const H264RawPPS *pps;
1028  int err;
1029  int idr_pic_flag;
1030  int slice_type_i, slice_type_p, slice_type_b;
1031  int slice_type_si, slice_type_sp;
1032 
1033  HEADER("Slice Header");
1034 
1035  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1036  1 << H264_NAL_SLICE |
1037  1 << H264_NAL_IDR_SLICE |
1038  1 << H264_NAL_AUXILIARY_SLICE));
1039 
1040  if (current->nal_unit_header.nal_unit_type == H264_NAL_AUXILIARY_SLICE) {
1041  if (!h264->last_slice_nal_unit_type) {
1042  av_log(ctx->log_ctx, AV_LOG_ERROR, "Auxiliary slice "
1043  "is not decodable without the main picture "
1044  "in the same access unit.\n");
1045  return AVERROR_INVALIDDATA;
1046  }
1047  idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;
1048  } else {
1049  idr_pic_flag = current->nal_unit_header.nal_unit_type == H264_NAL_IDR_SLICE;
1050  }
1051 
1052  ue(first_mb_in_slice, 0, H264_MAX_MB_PIC_SIZE - 1);
1053  ue(slice_type, 0, 9);
1054 
1055  slice_type_i = current->slice_type % 5 == 2;
1056  slice_type_p = current->slice_type % 5 == 0;
1057  slice_type_b = current->slice_type % 5 == 1;
1058  slice_type_si = current->slice_type % 5 == 4;
1059  slice_type_sp = current->slice_type % 5 == 3;
1060 
1061  if (idr_pic_flag && !(slice_type_i || slice_type_si)) {
1062  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid slice type %d "
1063  "for IDR picture.\n", current->slice_type);
1064  return AVERROR_INVALIDDATA;
1065  }
1066 
1067  ue(pic_parameter_set_id, 0, 255);
1068 
1069  pps = h264->pps[current->pic_parameter_set_id];
1070  if (!pps) {
1071  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
1072  current->pic_parameter_set_id);
1073  return AVERROR_INVALIDDATA;
1074  }
1075  h264->active_pps = pps;
1076 
1077  sps = h264->sps[pps->seq_parameter_set_id];
1078  if (!sps) {
1079  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1080  pps->seq_parameter_set_id);
1081  return AVERROR_INVALIDDATA;
1082  }
1083  h264->active_sps = sps;
1084 
1085  if (sps->separate_colour_plane_flag)
1086  u(2, colour_plane_id, 0, 2);
1087 
1088  ub(sps->log2_max_frame_num_minus4 + 4, frame_num);
1089 
1090  if (!sps->frame_mbs_only_flag) {
1091  flag(field_pic_flag);
1092  if (current->field_pic_flag)
1093  flag(bottom_field_flag);
1094  else
1095  infer(bottom_field_flag, 0);
1096  } else {
1097  infer(field_pic_flag, 0);
1098  infer(bottom_field_flag, 0);
1099  }
1100 
1101  if (idr_pic_flag)
1102  ue(idr_pic_id, 0, 65535);
1103 
1104  if (sps->pic_order_cnt_type == 0) {
1105  ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb);
1106  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1107  !current->field_pic_flag)
1108  se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);
1109 
1110  } else if (sps->pic_order_cnt_type == 1) {
1111  if (!sps->delta_pic_order_always_zero_flag) {
1112  se(delta_pic_order_cnt[0], INT32_MIN + 1, INT32_MAX);
1113  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1114  !current->field_pic_flag)
1115  se(delta_pic_order_cnt[1], INT32_MIN + 1, INT32_MAX);
1116  else
1117  infer(delta_pic_order_cnt[1], 0);
1118  } else {
1119  infer(delta_pic_order_cnt[0], 0);
1120  infer(delta_pic_order_cnt[1], 0);
1121  }
1122  }
1123 
1124  if (pps->redundant_pic_cnt_present_flag)
1125  ue(redundant_pic_cnt, 0, 127);
1126  else
1127  infer(redundant_pic_cnt, 0);
1128 
1129  if (current->nal_unit_header.nal_unit_type != H264_NAL_AUXILIARY_SLICE
1130  && !current->redundant_pic_cnt)
1131  h264->last_slice_nal_unit_type =
1132  current->nal_unit_header.nal_unit_type;
1133 
1134  if (slice_type_b)
1135  flag(direct_spatial_mv_pred_flag);
1136 
1137  if (slice_type_p || slice_type_sp || slice_type_b) {
1138  flag(num_ref_idx_active_override_flag);
1139  if (current->num_ref_idx_active_override_flag) {
1140  ue(num_ref_idx_l0_active_minus1, 0, 31);
1141  if (slice_type_b)
1142  ue(num_ref_idx_l1_active_minus1, 0, 31);
1143  } else {
1144  infer(num_ref_idx_l0_active_minus1,
1145  pps->num_ref_idx_l0_default_active_minus1);
1146  infer(num_ref_idx_l1_active_minus1,
1147  pps->num_ref_idx_l1_default_active_minus1);
1148  }
1149  }
1150 
1151  if (current->nal_unit_header.nal_unit_type == 20 ||
1152  current->nal_unit_header.nal_unit_type == 21) {
1153  av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC / 3DAVC not supported.\n");
1154  return AVERROR_PATCHWELCOME;
1155  } else {
1156  CHECK(FUNC(ref_pic_list_modification)(ctx, rw, current));
1157  }
1158 
1159  if ((pps->weighted_pred_flag && (slice_type_p || slice_type_sp)) ||
1160  (pps->weighted_bipred_idc == 1 && slice_type_b)) {
1161  CHECK(FUNC(pred_weight_table)(ctx, rw, current));
1162  }
1163 
1164  if (current->nal_unit_header.nal_ref_idc != 0) {
1165  CHECK(FUNC(dec_ref_pic_marking)(ctx, rw, current, idr_pic_flag));
1166  }
1167 
1168  if (pps->entropy_coding_mode_flag &&
1169  !slice_type_i && !slice_type_si) {
1170  ue(cabac_init_idc, 0, 2);
1171  }
1172 
1173  se(slice_qp_delta, - 51 - 6 * sps->bit_depth_luma_minus8,
1174  + 51 + 6 * sps->bit_depth_luma_minus8);
1175  if (slice_type_sp || slice_type_si) {
1176  if (slice_type_sp)
1177  flag(sp_for_switch_flag);
1178  se(slice_qs_delta, -51, +51);
1179  }
1180 
1181  if (pps->deblocking_filter_control_present_flag) {
1182  ue(disable_deblocking_filter_idc, 0, 2);
1183  if (current->disable_deblocking_filter_idc != 1) {
1184  se(slice_alpha_c0_offset_div2, -6, +6);
1185  se(slice_beta_offset_div2, -6, +6);
1186  } else {
1187  infer(slice_alpha_c0_offset_div2, 0);
1188  infer(slice_beta_offset_div2, 0);
1189  }
1190  } else {
1191  infer(disable_deblocking_filter_idc, 0);
1192  infer(slice_alpha_c0_offset_div2, 0);
1193  infer(slice_beta_offset_div2, 0);
1194  }
1195 
1196  if (pps->num_slice_groups_minus1 > 0 &&
1197  pps->slice_group_map_type >= 3 &&
1198  pps->slice_group_map_type <= 5) {
1199  unsigned int pic_size, max, bits;
1200 
1201  pic_size = (sps->pic_width_in_mbs_minus1 + 1) *
1202  (sps->pic_height_in_map_units_minus1 + 1);
1203  max = (pic_size + pps->slice_group_change_rate_minus1) /
1204  (pps->slice_group_change_rate_minus1 + 1);
1205  bits = av_ceil_log2(max + 1);
1206 
1207  u(bits, slice_group_change_cycle, 0, max);
1208  }
1209 
1210  if (pps->entropy_coding_mode_flag) {
1211  while (byte_alignment(rw))
1212  fixed(1, cabac_alignment_one_bit, 1);
1213  }
1214 
1215  return 0;
1216 }
1217 
1219  H264RawFiller *current)
1220 {
1221  int err;
1222 
1223  HEADER("Filler Data");
1224 
1225  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1226  1 << H264_NAL_FILLER_DATA));
1227 
1228 #ifdef READ
1229  while (show_bits(rw, 8) == 0xff) {
1230  fixed(8, ff_byte, 0xff);
1231  ++current->filler_size;
1232  }
1233 #else
1234  {
1235  uint32_t i;
1236  for (i = 0; i < current->filler_size; i++)
1237  fixed(8, ff_byte, 0xff);
1238  }
1239 #endif
1240 
1242 
1243  return 0;
1244 }
1245 
1247  H264RawNALUnitHeader *current)
1248 {
1249  HEADER("End of Sequence");
1250 
1251  return FUNC(nal_unit_header)(ctx, rw, current,
1252  1 << H264_NAL_END_SEQUENCE);
1253 }
1254 
1256  H264RawNALUnitHeader *current)
1257 {
1258  HEADER("End of Stream");
1259 
1260  return FUNC(nal_unit_header)(ctx, rw, current,
1261  1 << H264_NAL_END_STREAM);
1262 }
xue
#define xue(name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:398
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
byte_alignment
#define byte_alignment(rw)
Definition: cbs_av1.c:719
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
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:275
HEADER
#define HEADER(name)
Definition: cbs_av1.c:533
CodedBitstreamH264Context::pps
H264RawPPS * pps[H264_MAX_PPS_COUNT]
Definition: cbs_h264.h:413
infer
#define infer(name, value)
Definition: cbs_av1.c:709
H264_NAL_END_SEQUENCE
@ H264_NAL_END_SEQUENCE
Definition: h264.h:44
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:173
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:54
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:1634
H264RawHRD
Definition: cbs_h264.h:43
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:432
max
#define max(a, b)
Definition: cuda_runtime.h:33
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
ses
#define ses(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:290
H264RawSEIPicTiming
Definition: cbs_h264.h:249
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
av_ceil_log2
#define av_ceil_log2
Definition: common.h:93
CodedBitstreamH264Context::active_sps
const H264RawSPS * active_sps
Definition: cbs_h264.h:418
filler
static int FUNC() filler(CodedBitstreamContext *ctx, RWContext *rw, H264RawFiller *current)
Definition: cbs_h264_syntax_template.c:1218
ub
#define ub(width, name)
Definition: cbs_h2645.c:266
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:269
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1376
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:278
H264RawSEIPicTimestamp
Definition: cbs_h264.h:232
message_list
static int FUNC() message_list(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessageList *current, int prefix)
Definition: cbs_sei_syntax_template.c:230
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:180
H264_MAX_MMCO_COUNT
@ H264_MAX_MMCO_COUNT
Definition: h264.h:92
H264_MAX_MB_HEIGHT
@ H264_MAX_MB_HEIGHT
Definition: h264.h:107
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:141
ctx
AVFormatContext * ctx
Definition: movenc.c:48
FUNC_SEI
#define FUNC_SEI(name)
Definition: cbs_h2645.c:260
H264_NAL_SPS_EXT
@ H264_NAL_SPS_EXT
Definition: h264.h:47
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:174
sei_display_orientation
static int FUNC() sei_display_orientation(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIDisplayOrientation *current, SEIMessageState *sei)
Definition: cbs_h264_syntax_template.c:805
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:918
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
film_grain_characteristics
static int FUNC() film_grain_characteristics(CodedBitstreamContext *ctx, RWContext *rw, H264RawFilmGrainCharacteristics *current, SEIMessageState *state)
Definition: cbs_h264_syntax_template.c:722
slice_header
static int FUNC() slice_header(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:1022
profile_idc
int profile_idc
Definition: h264_levels.c:53
end_of_stream
static int FUNC() end_of_stream(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1255
state
static struct @317 state
H264RawNALUnitHeader
Definition: cbs_h264.h:31
H264RawSEIPanScanRect
Definition: cbs_h264.h:257
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:825
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
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
CodedBitstreamH264Context
Definition: cbs_h264.h:404
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:842
H264_NAL_END_STREAM
@ H264_NAL_END_STREAM
Definition: h264.h:45
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
H264RawFilmGrainCharacteristics
Definition: cbs_h264.h:275
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
H264_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:177
H264RawSEIDisplayOrientation
Definition: cbs_h264.h:296
CodedBitstreamH264Context::active_pps
const H264RawPPS * active_pps
Definition: cbs_h264.h:419
H264RawSliceHeader
Definition: cbs_h264.h:310
ref_pic_list_modification
static int FUNC() ref_pic_list_modification(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:859
flag
#define flag(name)
Definition: cbs_av1.c:553
vui_parameters
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H264RawVUI *current, H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:111
i
int i
Definition: input.c:406
ubs
#define ubs(width, name, subs,...)
Definition: cbs_h2645.c:280
H264_MAX_MB_PIC_SIZE
@ H264_MAX_MB_PIC_SIZE
Definition: h264.h:102
CodedBitstreamH264Context::last_slice_nal_unit_type
uint8_t last_slice_nal_unit_type
Definition: cbs_h264.h:424
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
H264RawScalingList
Definition: cbs_h264.h:39
H264RawVUI
Definition: cbs_h264.h:58
H264RawSEI
Definition: cbs_h264.h:305
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:53
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:971
SEIMessageState
Definition: cbs_sei.h:85
H264RawAUD
Definition: cbs_h264.h:218
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
sei_pan_scan_rect
static int FUNC() sei_pan_scan_rect(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPanScanRect *current, SEIMessageState *sei)
Definition: cbs_h264_syntax_template.c:679
end_of_sequence
static int FUNC() end_of_sequence(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1246
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
sei_buffering_period
static int FUNC() sei_buffering_period(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIBufferingPeriod *current, SEIMessageState *sei)
Definition: cbs_h264_syntax_template.c:513
more_rbsp_data
#define more_rbsp_data(var)
Definition: cbs_h2645.c:427
H264RawSEIRecoveryPoint
Definition: cbs_h264.h:268
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
ib
#define ib(width, name)
Definition: cbs_h2645.c:273
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
H264_NAL_AUXILIARY_SLICE
@ H264_NAL_AUXILIARY_SLICE
Definition: h264.h:53
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:566
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
H264RawFiller
Definition: cbs_h264.h:397
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
sei_recovery_point
static int FUNC() sei_recovery_point(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIRecoveryPoint *current, SEIMessageState *sei)
Definition: cbs_h264_syntax_template.c:706
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ues
#define ues(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:284
H264RawSPSExtension
Definition: cbs_h264.h:157
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:224
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:392
RWContext
#define RWContext
Definition: cbs_av1.c:662
sei_pic_timing
static int FUNC() sei_pic_timing(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPicTiming *current, SEIMessageState *sei)
Definition: cbs_h264_syntax_template.c:607
H264_MAX_MB_WIDTH
@ H264_MAX_MB_WIDTH
Definition: h264.h:106
H264_MAX_RPLM_COUNT
@ H264_MAX_RPLM_COUNT
Definition: h264.h:84
CodedBitstreamH264Context::sps
H264RawSPS * sps[H264_MAX_SPS_COUNT]
Definition: cbs_h264.h:412
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1125
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
H264RawSPS
Definition: cbs_h264.h:102
sei_pic_timestamp
static int FUNC() sei_pic_timestamp(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPicTimestamp *current, const H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:560
H264RawPPS
Definition: cbs_h264.h:171