FFmpeg: libavcodec/cbs_h264_syntax_template.c Source File

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  SEI_FUNC(sei_buffering_period, (CodedBitstreamContext *ctx, RWContext *rw,
514  H264RawSEIBufferingPeriod *current,
515  SEIMessageState *sei))
516 {
517  CodedBitstreamH264Context *h264 = ctx->priv_data;
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 
560  static int FUNC(sei_pic_timestamp)(CodedBitstreamContext *ctx, RWContext *rw,
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 
607  SEI_FUNC(sei_pic_timing, (CodedBitstreamContext *ctx, RWContext *rw,
608  H264RawSEIPicTiming *current, SEIMessageState *sei))
609 {
610  CodedBitstreamH264Context *h264 = ctx->priv_data;
611  const H264RawSPS *sps;
612  int err;
613 
614  HEADER("Picture Timing");
615 
616  sps = h264->active_sps;
617  if (!sps) {
618  // If there is exactly one possible SPS but it is not yet active
619  // then just assume that it should be the active one.
620  int i, k = -1;
621  for (i = 0; i < H264_MAX_SPS_COUNT; i++) {
622  if (h264->sps[i]) {
623  if (k >= 0) {
624  k = -1;
625  break;
626  }
627  k = i;
628  }
629  }
630  if (k >= 0)
631  sps = h264->sps[k];
632  }
633  if (!sps) {
634  av_log(ctx->log_ctx, AV_LOG_ERROR,
635  "No active SPS for pic_timing.\n");
636  return AVERROR_INVALIDDATA;
637  }
638 
639  if (sps->vui.nal_hrd_parameters_present_flag ||
640  sps->vui.vcl_hrd_parameters_present_flag) {
641  const H264RawHRD *hrd;
642 
643  if (sps->vui.nal_hrd_parameters_present_flag)
644  hrd = &sps->vui.nal_hrd_parameters;
645  else if (sps->vui.vcl_hrd_parameters_present_flag)
646  hrd = &sps->vui.vcl_hrd_parameters;
647  else {
648  av_log(ctx->log_ctx, AV_LOG_ERROR,
649  "No HRD parameters for pic_timing.\n");
650  return AVERROR_INVALIDDATA;
651  }
652 
653  ub(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay);
654  ub(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay);
655  }
656 
657  if (sps->vui.pic_struct_present_flag) {
658  static const uint8_t num_clock_ts[9] = {
659  1, 1, 1, 2, 2, 3, 3, 2, 3
660  };
661  int i;
662 
663  u(4, pic_struct, 0, 8);
664  if (current->pic_struct > 8)
665  return AVERROR_INVALIDDATA;
666 
667  for (i = 0; i < num_clock_ts[current->pic_struct]; i++) {
668  flags(clock_timestamp_flag[i], 1, i);
669  if (current->clock_timestamp_flag[i])
670  CHECK(FUNC(sei_pic_timestamp)(ctx, rw,
671  &current->timestamp[i], sps));
672  }
673  }
674 
675  return 0;
676 }
677 
678  SEI_FUNC(sei_pan_scan_rect, (CodedBitstreamContext *ctx, RWContext *rw,
679  H264RawSEIPanScanRect *current,
680  SEIMessageState *sei))
681 {
682  int err, i;
683 
684  HEADER("Pan-Scan Rectangle");
685 
686  ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
687  flag(pan_scan_rect_cancel_flag);
688 
689  if (!current->pan_scan_rect_cancel_flag) {
690  ue(pan_scan_cnt_minus1, 0, 2);
691 
692  for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
693  ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
694  ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
695  ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
696  ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
697  }
698 
699  ue(pan_scan_rect_repetition_period, 0, 16384);
700  }
701 
702  return 0;
703 }
704 
705  SEI_FUNC(sei_recovery_point, (CodedBitstreamContext *ctx, RWContext *rw,
706  H264RawSEIRecoveryPoint *current,
707  SEIMessageState *sei))
708 {
709  int err;
710 
711  HEADER("Recovery Point");
712 
713  ue(recovery_frame_cnt, 0, 65535);
714  flag(exact_match_flag);
715  flag(broken_link_flag);
716  u(2, changing_slice_group_idc, 0, 2);
717 
718  return 0;
719 }
720 
721  SEI_FUNC(film_grain_characteristics, (CodedBitstreamContext *ctx, RWContext *rw,
722  H264RawFilmGrainCharacteristics *current,
723  SEIMessageState *state))
724 {
725  CodedBitstreamH264Context *h264 = ctx->priv_data;
726  const H264RawSPS *sps;
727  int err, c, i, j;
728 
729  HEADER("Film Grain Characteristics");
730 
731  sps = h264->active_sps;
732  if (!sps) {
733  // If there is exactly one possible SPS but it is not yet active
734  // then just assume that it should be the active one.
735  int i, k = -1;
736  for (i = 0; i < H264_MAX_SPS_COUNT; i++) {
737  if (h264->sps[i]) {
738  if (k >= 0) {
739  k = -1;
740  break;
741  }
742  k = i;
743  }
744  }
745  if (k >= 0)
746  sps = h264->sps[k];
747  }
748 
749  flag(film_grain_characteristics_cancel_flag);
750  if (!current->film_grain_characteristics_cancel_flag) {
751  int filmGrainBitDepth[3];
752 
753  u(2, film_grain_model_id, 0, 1);
754  flag(separate_colour_description_present_flag);
755  if (current->separate_colour_description_present_flag) {
756  ub(3, film_grain_bit_depth_luma_minus8);
757  ub(3, film_grain_bit_depth_chroma_minus8);
758  flag(film_grain_full_range_flag);
759  ub(8, film_grain_colour_primaries);
760  ub(8, film_grain_transfer_characteristics);
761  ub(8, film_grain_matrix_coefficients);
762  } else {
763  if (!sps) {
764  av_log(ctx->log_ctx, AV_LOG_ERROR,
765  "No active SPS for film_grain_characteristics.\n");
766  return AVERROR_INVALIDDATA;
767  }
768  infer(film_grain_bit_depth_luma_minus8, sps->bit_depth_luma_minus8);
769  infer(film_grain_bit_depth_chroma_minus8, sps->bit_depth_chroma_minus8);
770  infer(film_grain_full_range_flag, sps->vui.video_full_range_flag);
771  infer(film_grain_colour_primaries, sps->vui.colour_primaries);
772  infer(film_grain_transfer_characteristics, sps->vui.transfer_characteristics);
773  infer(film_grain_matrix_coefficients, sps->vui.matrix_coefficients);
774  }
775 
776  filmGrainBitDepth[0] = current->film_grain_bit_depth_luma_minus8 + 8;
777  filmGrainBitDepth[1] =
778  filmGrainBitDepth[2] = current->film_grain_bit_depth_chroma_minus8 + 8;
779 
780  u(2, blending_mode_id, 0, 1);
781  ub(4, log2_scale_factor);
782  for (c = 0; c < 3; c++)
783  flags(comp_model_present_flag[c], 1, c);
784  for (c = 0; c < 3; c++) {
785  if (current->comp_model_present_flag[c]) {
786  ubs(8, num_intensity_intervals_minus1[c], 1, c);
787  us(3, num_model_values_minus1[c], 0, 5, 1, c);
788  for (i = 0; i <= current->num_intensity_intervals_minus1[c]; i++) {
789  ubs(8, intensity_interval_lower_bound[c][i], 2, c, i);
790  ubs(8, intensity_interval_upper_bound[c][i], 2, c, i);
791  for (j = 0; j <= current->num_model_values_minus1[c]; j++)
792  ses(comp_model_value[c][i][j], 0 - current->film_grain_model_id * (1 << (filmGrainBitDepth[c] - 1)),
793  ((1 << filmGrainBitDepth[c]) - 1) - current->film_grain_model_id * (1 << (filmGrainBitDepth[c] - 1)),
794  3, c, i, j);
795  }
796  }
797  }
798  ue(film_grain_characteristics_repetition_period, 0, 16384);
799  }
800 
801  return 0;
802 }
803 
804  SEI_FUNC(sei_frame_packing_arrangement, (CodedBitstreamContext *ctx, RWContext *rw,
805  H264RawSEIFramePackingArrangement *current,
806  SEIMessageState *sei))
807 {
808  int err;
809 
810  HEADER("Frame Packing Arrangement");
811 
812  ue(frame_packing_arrangement_id, 0, MAX_UINT_BITS(31));
813  flag(frame_packing_arrangement_cancel_flag);
814  if (!current->frame_packing_arrangement_cancel_flag) {
815  u(7, frame_packing_arrangement_type, 0, 7);
816  flag(quincunx_sampling_flag);
817  u(6, content_interpretation_type, 0, 2);
818  flag(spatial_flipping_flag);
819  flag(frame0_flipped_flag);
820  flag(field_views_flag);
821  flag(current_frame_is_frame0_flag);
822  flag(frame0_self_contained_flag);
823  flag(frame1_self_contained_flag);
824  if (!current->quincunx_sampling_flag && current->frame_packing_arrangement_type != 5) {
825  ub(4, frame0_grid_position_x);
826  ub(4, frame0_grid_position_y);
827  ub(4, frame1_grid_position_x);
828  ub(4, frame1_grid_position_y);
829  }
830  fixed(8, frame_packing_arrangement_reserved_byte, 0);
831  ue(frame_packing_arrangement_repetition_period, 0, 16384);
832  }
833  flag(frame_packing_arrangement_extension_flag);
834 
835  return 0;
836 }
837 
838  SEI_FUNC(sei_display_orientation, (CodedBitstreamContext *ctx, RWContext *rw,
839  H264RawSEIDisplayOrientation *current,
840  SEIMessageState *sei))
841 {
842  int err;
843 
844  HEADER("Display Orientation");
845 
846  flag(display_orientation_cancel_flag);
847  if (!current->display_orientation_cancel_flag) {
848  flag(hor_flip);
849  flag(ver_flip);
850  ub(16, anticlockwise_rotation);
851  ue(display_orientation_repetition_period, 0, 16384);
852  flag(display_orientation_extension_flag);
853  }
854 
855  return 0;
856 }
857 
858  static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,
859  H264RawSEI *current)
860 {
861  int err;
862 
863  HEADER("Supplemental Enhancement Information");
864 
865  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
866  1 << H264_NAL_SEI));
867 
868  CHECK(FUNC_SEI(message_list)(ctx, rw, &current->message_list, 1));
869 
870  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
871 
872  return 0;
873 }
874 
875  static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw,
876  H264RawAUD *current)
877 {
878  int err;
879 
880  HEADER("Access Unit Delimiter");
881 
882  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
883  1 << H264_NAL_AUD));
884 
885  ub(3, primary_pic_type);
886 
887  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
888 
889  return 0;
890 }
891 
892  static int FUNC(ref_pic_list_modification)(CodedBitstreamContext *ctx, RWContext *rw,
893  H264RawSliceHeader *current)
894 {
895  CodedBitstreamH264Context *h264 = ctx->priv_data;
896  const H264RawSPS *sps = h264->active_sps;
897  int err, i, mopn;
898 
899  if (current->slice_type % 5 != 2 &&
900  current->slice_type % 5 != 4) {
901  flag(ref_pic_list_modification_flag_l0);
902  if (current->ref_pic_list_modification_flag_l0) {
903  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
904  xue(modification_of_pic_nums_idc,
905  current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3, 0);
906 
907  mopn = current->rplm_l0[i].modification_of_pic_nums_idc;
908  if (mopn == 3)
909  break;
910 
911  if (mopn == 0 || mopn == 1)
912  xue(abs_diff_pic_num_minus1,
913  current->rplm_l0[i].abs_diff_pic_num_minus1,
914  0, (1 + current->field_pic_flag) *
915  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
916  else if (mopn == 2)
917  xue(long_term_pic_num,
918  current->rplm_l0[i].long_term_pic_num,
919  0, sps->max_num_ref_frames - 1, 0);
920  }
921  }
922  }
923 
924  if (current->slice_type % 5 == 1) {
925  flag(ref_pic_list_modification_flag_l1);
926  if (current->ref_pic_list_modification_flag_l1) {
927  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
928  xue(modification_of_pic_nums_idc,
929  current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3, 0);
930 
931  mopn = current->rplm_l1[i].modification_of_pic_nums_idc;
932  if (mopn == 3)
933  break;
934 
935  if (mopn == 0 || mopn == 1)
936  xue(abs_diff_pic_num_minus1,
937  current->rplm_l1[i].abs_diff_pic_num_minus1,
938  0, (1 + current->field_pic_flag) *
939  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
940  else if (mopn == 2)
941  xue(long_term_pic_num,
942  current->rplm_l1[i].long_term_pic_num,
943  0, sps->max_num_ref_frames - 1, 0);
944  }
945  }
946  }
947 
948  return 0;
949 }
950 
951  static int FUNC(pred_weight_table)(CodedBitstreamContext *ctx, RWContext *rw,
952  H264RawSliceHeader *current)
953 {
954  CodedBitstreamH264Context *h264 = ctx->priv_data;
955  const H264RawSPS *sps = h264->active_sps;
956  int chroma;
957  int err, i, j;
958 
959  ue(luma_log2_weight_denom, 0, 7);
960 
961  chroma = !sps->separate_colour_plane_flag && sps->chroma_format_idc != 0;
962  if (chroma)
963  ue(chroma_log2_weight_denom, 0, 7);
964 
965  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
966  flags(luma_weight_l0_flag[i], 1, i);
967  if (current->luma_weight_l0_flag[i]) {
968  ses(luma_weight_l0[i], -128, +127, 1, i);
969  ses(luma_offset_l0[i], -128, +127, 1, i);
970  }
971  if (chroma) {
972  flags(chroma_weight_l0_flag[i], 1, i);
973  if (current->chroma_weight_l0_flag[i]) {
974  for (j = 0; j < 2; j++) {
975  ses(chroma_weight_l0[i][j], -128, +127, 2, i, j);
976  ses(chroma_offset_l0[i][j], -128, +127, 2, i, j);
977  }
978  }
979  }
980  }
981 
982  if (current->slice_type % 5 == 1) {
983  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
984  flags(luma_weight_l1_flag[i], 1, i);
985  if (current->luma_weight_l1_flag[i]) {
986  ses(luma_weight_l1[i], -128, +127, 1, i);
987  ses(luma_offset_l1[i], -128, +127, 1, i);
988  }
989  if (chroma) {
990  flags(chroma_weight_l1_flag[i], 1, i);
991  if (current->chroma_weight_l1_flag[i]) {
992  for (j = 0; j < 2; j++) {
993  ses(chroma_weight_l1[i][j], -128, +127, 2, i, j);
994  ses(chroma_offset_l1[i][j], -128, +127, 2, i, j);
995  }
996  }
997  }
998  }
999  }
1000 
1001  return 0;
1002 }
1003 
1004  static int FUNC(dec_ref_pic_marking)(CodedBitstreamContext *ctx, RWContext *rw,
1005  H264RawSliceHeader *current, int idr_pic_flag)
1006 {
1007  CodedBitstreamH264Context *h264 = ctx->priv_data;
1008  const H264RawSPS *sps = h264->active_sps;
1009  int err, i;
1010  uint32_t mmco;
1011 
1012  if (idr_pic_flag) {
1013  flag(no_output_of_prior_pics_flag);
1014  flag(long_term_reference_flag);
1015  } else {
1016  flag(adaptive_ref_pic_marking_mode_flag);
1017  if (current->adaptive_ref_pic_marking_mode_flag) {
1018  for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {
1019  xue(memory_management_control_operation,
1020  current->mmco[i].memory_management_control_operation,
1021  0, 6, 0);
1022 
1023  mmco = current->mmco[i].memory_management_control_operation;
1024  if (mmco == 0)
1025  break;
1026 
1027  if (mmco == 1 || mmco == 3)
1028  xue(difference_of_pic_nums_minus1,
1029  current->mmco[i].difference_of_pic_nums_minus1,
1030  0, INT32_MAX, 0);
1031  if (mmco == 2)
1032  xue(long_term_pic_num,
1033  current->mmco[i].long_term_pic_num,
1034  0, sps->max_num_ref_frames - 1, 0);
1035  if (mmco == 3 || mmco == 6)
1036  xue(long_term_frame_idx,
1037  current->mmco[i].long_term_frame_idx,
1038  0, sps->max_num_ref_frames - 1, 0);
1039  if (mmco == 4)
1040  xue(max_long_term_frame_idx_plus1,
1041  current->mmco[i].max_long_term_frame_idx_plus1,
1042  0, sps->max_num_ref_frames, 0);
1043  }
1044  if (i == H264_MAX_MMCO_COUNT) {
1045  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many "
1046  "memory management control operations.\n");
1047  return AVERROR_INVALIDDATA;
1048  }
1049  }
1050  }
1051 
1052  return 0;
1053 }
1054 
1055  static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
1056  H264RawSliceHeader *current)
1057 {
1058  CodedBitstreamH264Context *h264 = ctx->priv_data;
1059  const H264RawSPS *sps;
1060  const H264RawPPS *pps;
1061  int err;
1062  int idr_pic_flag;
1063  int slice_type_i, slice_type_p, slice_type_b;
1064  int slice_type_si, slice_type_sp;
1065 
1066  HEADER("Slice Header");
1067 
1068  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1069  1 << H264_NAL_SLICE |
1070  1 << H264_NAL_IDR_SLICE |
1071  1 << H264_NAL_AUXILIARY_SLICE));
1072 
1073  if (current->nal_unit_header.nal_unit_type == H264_NAL_AUXILIARY_SLICE) {
1074  if (!h264->last_slice_nal_unit_type) {
1075  av_log(ctx->log_ctx, AV_LOG_ERROR, "Auxiliary slice "
1076  "is not decodable without the main picture "
1077  "in the same access unit.\n");
1078  return AVERROR_INVALIDDATA;
1079  }
1080  idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;
1081  } else {
1082  idr_pic_flag = current->nal_unit_header.nal_unit_type == H264_NAL_IDR_SLICE;
1083  }
1084 
1085  ue(first_mb_in_slice, 0, H264_MAX_MB_PIC_SIZE - 1);
1086  ue(slice_type, 0, 9);
1087 
1088  slice_type_i = current->slice_type % 5 == 2;
1089  slice_type_p = current->slice_type % 5 == 0;
1090  slice_type_b = current->slice_type % 5 == 1;
1091  slice_type_si = current->slice_type % 5 == 4;
1092  slice_type_sp = current->slice_type % 5 == 3;
1093 
1094  if (idr_pic_flag && !(slice_type_i || slice_type_si)) {
1095  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid slice type %d "
1096  "for IDR picture.\n", current->slice_type);
1097  return AVERROR_INVALIDDATA;
1098  }
1099 
1100  ue(pic_parameter_set_id, 0, 255);
1101 
1102  pps = h264->pps[current->pic_parameter_set_id];
1103  if (!pps) {
1104  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
1105  current->pic_parameter_set_id);
1106  return AVERROR_INVALIDDATA;
1107  }
1108  h264->active_pps = pps;
1109 
1110  sps = h264->sps[pps->seq_parameter_set_id];
1111  if (!sps) {
1112  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1113  pps->seq_parameter_set_id);
1114  return AVERROR_INVALIDDATA;
1115  }
1116  h264->active_sps = sps;
1117 
1118  if (sps->separate_colour_plane_flag)
1119  u(2, colour_plane_id, 0, 2);
1120 
1121  ub(sps->log2_max_frame_num_minus4 + 4, frame_num);
1122 
1123  if (!sps->frame_mbs_only_flag) {
1124  flag(field_pic_flag);
1125  if (current->field_pic_flag)
1126  flag(bottom_field_flag);
1127  else
1128  infer(bottom_field_flag, 0);
1129  } else {
1130  infer(field_pic_flag, 0);
1131  infer(bottom_field_flag, 0);
1132  }
1133 
1134  if (idr_pic_flag)
1135  ue(idr_pic_id, 0, 65535);
1136 
1137  if (sps->pic_order_cnt_type == 0) {
1138  ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb);
1139  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1140  !current->field_pic_flag)
1141  se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);
1142 
1143  } else if (sps->pic_order_cnt_type == 1) {
1144  if (!sps->delta_pic_order_always_zero_flag) {
1145  se(delta_pic_order_cnt[0], INT32_MIN + 1, INT32_MAX);
1146  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1147  !current->field_pic_flag)
1148  se(delta_pic_order_cnt[1], INT32_MIN + 1, INT32_MAX);
1149  else
1150  infer(delta_pic_order_cnt[1], 0);
1151  } else {
1152  infer(delta_pic_order_cnt[0], 0);
1153  infer(delta_pic_order_cnt[1], 0);
1154  }
1155  }
1156 
1157  if (pps->redundant_pic_cnt_present_flag)
1158  ue(redundant_pic_cnt, 0, 127);
1159  else
1160  infer(redundant_pic_cnt, 0);
1161 
1162  if (current->nal_unit_header.nal_unit_type != H264_NAL_AUXILIARY_SLICE
1163  && !current->redundant_pic_cnt)
1164  h264->last_slice_nal_unit_type =
1165  current->nal_unit_header.nal_unit_type;
1166 
1167  if (slice_type_b)
1168  flag(direct_spatial_mv_pred_flag);
1169 
1170  if (slice_type_p || slice_type_sp || slice_type_b) {
1171  flag(num_ref_idx_active_override_flag);
1172  if (current->num_ref_idx_active_override_flag) {
1173  ue(num_ref_idx_l0_active_minus1, 0, 31);
1174  if (slice_type_b)
1175  ue(num_ref_idx_l1_active_minus1, 0, 31);
1176  } else {
1177  infer(num_ref_idx_l0_active_minus1,
1178  pps->num_ref_idx_l0_default_active_minus1);
1179  infer(num_ref_idx_l1_active_minus1,
1180  pps->num_ref_idx_l1_default_active_minus1);
1181  }
1182  }
1183 
1184  if (current->nal_unit_header.nal_unit_type == 20 ||
1185  current->nal_unit_header.nal_unit_type == 21) {
1186  av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC / 3DAVC not supported.\n");
1187  return AVERROR_PATCHWELCOME;
1188  } else {
1189  CHECK(FUNC(ref_pic_list_modification)(ctx, rw, current));
1190  }
1191 
1192  if ((pps->weighted_pred_flag && (slice_type_p || slice_type_sp)) ||
1193  (pps->weighted_bipred_idc == 1 && slice_type_b)) {
1194  CHECK(FUNC(pred_weight_table)(ctx, rw, current));
1195  }
1196 
1197  if (current->nal_unit_header.nal_ref_idc != 0) {
1198  CHECK(FUNC(dec_ref_pic_marking)(ctx, rw, current, idr_pic_flag));
1199  }
1200 
1201  if (pps->entropy_coding_mode_flag &&
1202  !slice_type_i && !slice_type_si) {
1203  ue(cabac_init_idc, 0, 2);
1204  }
1205 
1206  se(slice_qp_delta, - 51 - 6 * sps->bit_depth_luma_minus8,
1207  + 51 + 6 * sps->bit_depth_luma_minus8);
1208  if (slice_type_sp || slice_type_si) {
1209  if (slice_type_sp)
1210  flag(sp_for_switch_flag);
1211  se(slice_qs_delta, -51, +51);
1212  }
1213 
1214  if (pps->deblocking_filter_control_present_flag) {
1215  ue(disable_deblocking_filter_idc, 0, 2);
1216  if (current->disable_deblocking_filter_idc != 1) {
1217  se(slice_alpha_c0_offset_div2, -6, +6);
1218  se(slice_beta_offset_div2, -6, +6);
1219  } else {
1220  infer(slice_alpha_c0_offset_div2, 0);
1221  infer(slice_beta_offset_div2, 0);
1222  }
1223  } else {
1224  infer(disable_deblocking_filter_idc, 0);
1225  infer(slice_alpha_c0_offset_div2, 0);
1226  infer(slice_beta_offset_div2, 0);
1227  }
1228 
1229  if (pps->num_slice_groups_minus1 > 0 &&
1230  pps->slice_group_map_type >= 3 &&
1231  pps->slice_group_map_type <= 5) {
1232  unsigned int pic_size, max, bits;
1233 
1234  pic_size = (sps->pic_width_in_mbs_minus1 + 1) *
1235  (sps->pic_height_in_map_units_minus1 + 1);
1236  max = (pic_size + pps->slice_group_change_rate_minus1) /
1237  (pps->slice_group_change_rate_minus1 + 1);
1238  bits = av_ceil_log2(max + 1);
1239 
1240  u(bits, slice_group_change_cycle, 0, max);
1241  }
1242 
1243  if (pps->entropy_coding_mode_flag) {
1244  while (byte_alignment(rw))
1245  fixed(1, cabac_alignment_one_bit, 1);
1246  }
1247 
1248  return 0;
1249 }
1250 
1251  static int FUNC(filler)(CodedBitstreamContext *ctx, RWContext *rw,
1252  H264RawFiller *current)
1253 {
1254  int err;
1255 
1256  HEADER("Filler Data");
1257 
1258  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1259  1 << H264_NAL_FILLER_DATA));
1260 
1261 #ifdef READ
1262  while (show_bits(rw, 8) == 0xff) {
1263  fixed(8, ff_byte, 0xff);
1264  ++current->filler_size;
1265  }
1266 #else
1267  {
1268  uint32_t i;
1269  for (i = 0; i < current->filler_size; i++)
1270  fixed(8, ff_byte, 0xff);
1271  }
1272 #endif
1273 
1274  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
1275 
1276  return 0;
1277 }
1278 
1279  static int FUNC(end_of_sequence)(CodedBitstreamContext *ctx, RWContext *rw,
1280  H264RawNALUnitHeader *current)
1281 {
1282  HEADER("End of Sequence");
1283 
1284  return FUNC(nal_unit_header)(ctx, rw, current,
1285  1 << H264_NAL_END_SEQUENCE);
1286 }
1287 
1288  static int FUNC(end_of_stream)(CodedBitstreamContext *ctx, RWContext *rw,
1289  H264RawNALUnitHeader *current)
1290 {
1291  HEADER("End of Stream");
1292 
1293  return FUNC(nal_unit_header)(ctx, rw, current,
1294  1 << H264_NAL_END_STREAM);
1295 }
flags
const SwsFlags flags[]
Definition: swscale.c:61
xue
#define xue(name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:412
H264_NAL_END_STREAM
@ H264_NAL_END_STREAM
Definition: h264.h:45
H264RawSEIPicTiming::pic_struct
uint8_t pic_struct
Definition: cbs_h264.h:252
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:260
CodedBitstreamH264Context::pps
H264RawPPS * pps[H264_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h264.h:431
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:226
level_idc
int level_idc
Definition: h264_levels.c:29
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:1639
H264RawHRD
Definition: cbs_h264.h:43
infer
#define infer(name, value)
Definition: cbs_apv.c:127
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:446
max
#define max(a, b)
Definition: cuda_runtime.h:33
H264RawSEIBufferingPeriod::nal
struct H264RawSEIBufferingPeriod::@79 nal
H264RawFilmGrainCharacteristics::num_model_values_minus1
uint8_t num_model_values_minus1[3]
Definition: cbs_h264.h:289
ses
#define ses(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:275
ub
#define ub(width, name)
Definition: cbs_apv.c:70
H264RawSEIPicTiming
Definition: cbs_h264.h:249
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
H264RawSEIBufferingPeriod::vcl
struct H264RawSEIBufferingPeriod::@79 vcl
av_ceil_log2
#define av_ceil_log2
Definition: common.h:97
CodedBitstreamH264Context::active_sps
const H264RawSPS * active_sps
Definition: cbs_h264.h:436
H264_MAX_MMCO_COUNT
@ H264_MAX_MMCO_COUNT
Definition: h264.h:92
H264_MAX_MB_HEIGHT
@ H264_MAX_MB_HEIGHT
Definition: h264.h:107
filler
static int FUNC() filler(CodedBitstreamContext *ctx, RWContext *rw, H264RawFiller *current)
Definition: cbs_h264_syntax_template.c:1251
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
ubs
#define ubs(width, name, subs,...)
Definition: cbs_apv.c:74
H264RawFilmGrainCharacteristics::comp_model_present_flag
uint8_t comp_model_present_flag[3]
Definition: cbs_h264.h:287
H264RawFilmGrainCharacteristics::separate_colour_description_present_flag
uint8_t separate_colour_description_present_flag
Definition: cbs_h264.h:278
H264RawSEIFramePackingArrangement::frame_packing_arrangement_cancel_flag
uint8_t frame_packing_arrangement_cancel_flag
Definition: cbs_h264.h:298
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:254
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_apv.c:120
H264_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
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:412
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[]
Definition: vf_colorspace.c:174
H264RawSEIBufferingPeriod::initial_cpb_removal_delay
uint32_t initial_cpb_removal_delay[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:227
H264RawSEIPicTiming::clock_timestamp_flag
uint8_t clock_timestamp_flag[3]
Definition: cbs_h264.h:253
H264_MAX_MB_PIC_SIZE
@ H264_MAX_MB_PIC_SIZE
Definition: h264.h:102
HEADER
#define HEADER(name)
Definition: cbs_apv.c:55
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:128
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FUNC_SEI
#define FUNC_SEI(name)
Definition: cbs_h2645.c:237
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:235
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:951
H264RawSEIFramePackingArrangement::frame_packing_arrangement_type
uint8_t frame_packing_arrangement_type
Definition: cbs_h264.h:299
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
slice_header
static int FUNC() slice_header(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:1055
profile_idc
int profile_idc
Definition: h264_levels.c:53
H264RawFilmGrainCharacteristics::film_grain_bit_depth_chroma_minus8
uint8_t film_grain_bit_depth_chroma_minus8
Definition: cbs_h264.h:280
end_of_stream
static int FUNC() end_of_stream(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1288
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
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:858
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:424
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:875
H264RawFilmGrainCharacteristics::film_grain_bit_depth_luma_minus8
uint8_t film_grain_bit_depth_luma_minus8
Definition: cbs_h264.h:279
H264_MAX_RPLM_COUNT
@ H264_MAX_RPLM_COUNT
Definition: h264.h:84
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_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
H264RawSEIPanScanRect::pan_scan_rect_cancel_flag
uint8_t pan_scan_rect_cancel_flag
Definition: cbs_h264.h:259
H264RawFilmGrainCharacteristics::film_grain_characteristics_cancel_flag
uint8_t film_grain_characteristics_cancel_flag
Definition: cbs_h264.h:276
H264RawSEIDisplayOrientation
Definition: cbs_h264.h:316
H264RawSEIPanScanRect::pan_scan_cnt_minus1
uint8_t pan_scan_cnt_minus1
Definition: cbs_h264.h:260
H264RawFilmGrainCharacteristics::num_intensity_intervals_minus1
uint8_t num_intensity_intervals_minus1[3]
Definition: cbs_h264.h:288
fixed
#define fixed(width, name, value)
Definition: cbs_apv.c:77
CodedBitstreamH264Context::active_pps
const H264RawPPS * active_pps
Definition: cbs_h264.h:437
H264RawSEIFramePackingArrangement
Definition: cbs_h264.h:296
H264RawSliceHeader
Definition: cbs_h264.h:330
H264RawSEIBufferingPeriod::initial_cpb_removal_delay_offset
uint32_t initial_cpb_removal_delay_offset[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:228
ref_pic_list_modification
static int FUNC() ref_pic_list_modification(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:892
vui_parameters
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H264RawVUI *current, H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:111
H264_MAX_MB_WIDTH
@ H264_MAX_MB_WIDTH
Definition: h264.h:106
CodedBitstreamH264Context::last_slice_nal_unit_type
uint8_t last_slice_nal_unit_type
Definition: cbs_h264.h:442
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:369
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
H264RawFilmGrainCharacteristics::film_grain_model_id
uint8_t film_grain_model_id
Definition: cbs_h264.h:277
H264RawScalingList
Definition: cbs_h264.h:39
H264RawVUI
Definition: cbs_h264.h:58
state
static struct @531 state
H264RawSEI
Definition: cbs_h264.h:325
H264_NAL_SEI
@ H264_NAL_SEI
Definition: h264.h:40
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
H264_NAL_SPS_EXT
@ H264_NAL_SPS_EXT
Definition: h264.h:47
H264RawSEIBufferingPeriod::seq_parameter_set_id
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:225
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
flag
#define flag(name)
Definition: cbs_av1.c:496
H264RawHRD::cpb_removal_delay_length_minus1
uint8_t cpb_removal_delay_length_minus1
Definition: cbs_h264.h:53
byte_alignment
#define byte_alignment(rw)
Definition: cbs_apv.c:137
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:1004
SEIMessageState
Definition: cbs_sei.h:156
RWContext
#define RWContext
Definition: cbs_apv.c:117
H264RawAUD
Definition: cbs_h264.h:218
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:101
H264_MAX_SPS_COUNT
@ H264_MAX_SPS_COUNT
Definition: h264.h:71
H264_NAL_AUXILIARY_SLICE
@ H264_NAL_AUXILIARY_SLICE
Definition: h264.h:53
end_of_sequence
static int FUNC() end_of_sequence(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1279
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
H264RawSEIPicTiming::timestamp
H264RawSEIPicTimestamp timestamp[3]
Definition: cbs_h264.h:254
more_rbsp_data
#define more_rbsp_data(var)
Definition: cbs_h2645.c:441
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_apv.c:72
H264RawSEIRecoveryPoint
Definition: cbs_h264.h:268
ib
#define ib(width, name)
Definition: cbs_h2645.c:258
H264_NAL_END_SEQUENCE
@ H264_NAL_END_SEQUENCE
Definition: h264.h:44
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
H264RawSEIDisplayOrientation::display_orientation_cancel_flag
uint8_t display_orientation_cancel_flag
Definition: cbs_h264.h:317
H264RawFiller
Definition: cbs_h264.h:417
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ues
#define ues(name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:269
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
SEI_FUNC
SEI_FUNC(sei_buffering_period,(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIBufferingPeriod *current, SEIMessageState *sei))
Definition: cbs_h264_syntax_template.c:513
CodedBitstreamH264Context::sps
H264RawSPS * sps[H264_MAX_SPS_COUNT]
RefStruct references.
Definition: cbs_h264.h:430
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1292
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
H264RawSEIFramePackingArrangement::quincunx_sampling_flag
uint8_t quincunx_sampling_flag
Definition: cbs_h264.h:300
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
Generated on Sat Oct 18 2025 19:21:56 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /