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_display_orientation, (CodedBitstreamContext *ctx, RWContext *rw,
805  H264RawSEIDisplayOrientation *current,
806  SEIMessageState *sei))
807 {
808  int err;
809 
810  HEADER("Display Orientation");
811 
812  flag(display_orientation_cancel_flag);
813  if (!current->display_orientation_cancel_flag) {
814  flag(hor_flip);
815  flag(ver_flip);
816  ub(16, anticlockwise_rotation);
817  ue(display_orientation_repetition_period, 0, 16384);
818  flag(display_orientation_extension_flag);
819  }
820 
821  return 0;
822 }
823 
824 static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,
825  H264RawSEI *current)
826 {
827  int err;
828 
829  HEADER("Supplemental Enhancement Information");
830 
831  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
832  1 << H264_NAL_SEI));
833 
834  CHECK(FUNC_SEI(message_list)(ctx, rw, &current->message_list, 1));
835 
836  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
837 
838  return 0;
839 }
840 
841 static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw,
842  H264RawAUD *current)
843 {
844  int err;
845 
846  HEADER("Access Unit Delimiter");
847 
848  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
849  1 << H264_NAL_AUD));
850 
851  ub(3, primary_pic_type);
852 
853  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
854 
855  return 0;
856 }
857 
858 static int FUNC(ref_pic_list_modification)(CodedBitstreamContext *ctx, RWContext *rw,
859  H264RawSliceHeader *current)
860 {
861  CodedBitstreamH264Context *h264 = ctx->priv_data;
862  const H264RawSPS *sps = h264->active_sps;
863  int err, i, mopn;
864 
865  if (current->slice_type % 5 != 2 &&
866  current->slice_type % 5 != 4) {
867  flag(ref_pic_list_modification_flag_l0);
868  if (current->ref_pic_list_modification_flag_l0) {
869  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
870  xue(modification_of_pic_nums_idc,
871  current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3, 0);
872 
873  mopn = current->rplm_l0[i].modification_of_pic_nums_idc;
874  if (mopn == 3)
875  break;
876 
877  if (mopn == 0 || mopn == 1)
878  xue(abs_diff_pic_num_minus1,
879  current->rplm_l0[i].abs_diff_pic_num_minus1,
880  0, (1 + current->field_pic_flag) *
881  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
882  else if (mopn == 2)
883  xue(long_term_pic_num,
884  current->rplm_l0[i].long_term_pic_num,
885  0, sps->max_num_ref_frames - 1, 0);
886  }
887  }
888  }
889 
890  if (current->slice_type % 5 == 1) {
891  flag(ref_pic_list_modification_flag_l1);
892  if (current->ref_pic_list_modification_flag_l1) {
893  for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
894  xue(modification_of_pic_nums_idc,
895  current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3, 0);
896 
897  mopn = current->rplm_l1[i].modification_of_pic_nums_idc;
898  if (mopn == 3)
899  break;
900 
901  if (mopn == 0 || mopn == 1)
902  xue(abs_diff_pic_num_minus1,
903  current->rplm_l1[i].abs_diff_pic_num_minus1,
904  0, (1 + current->field_pic_flag) *
905  (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
906  else if (mopn == 2)
907  xue(long_term_pic_num,
908  current->rplm_l1[i].long_term_pic_num,
909  0, sps->max_num_ref_frames - 1, 0);
910  }
911  }
912  }
913 
914  return 0;
915 }
916 
917 static int FUNC(pred_weight_table)(CodedBitstreamContext *ctx, RWContext *rw,
918  H264RawSliceHeader *current)
919 {
920  CodedBitstreamH264Context *h264 = ctx->priv_data;
921  const H264RawSPS *sps = h264->active_sps;
922  int chroma;
923  int err, i, j;
924 
925  ue(luma_log2_weight_denom, 0, 7);
926 
927  chroma = !sps->separate_colour_plane_flag && sps->chroma_format_idc != 0;
928  if (chroma)
929  ue(chroma_log2_weight_denom, 0, 7);
930 
931  for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
932  flags(luma_weight_l0_flag[i], 1, i);
933  if (current->luma_weight_l0_flag[i]) {
934  ses(luma_weight_l0[i], -128, +127, 1, i);
935  ses(luma_offset_l0[i], -128, +127, 1, i);
936  }
937  if (chroma) {
938  flags(chroma_weight_l0_flag[i], 1, i);
939  if (current->chroma_weight_l0_flag[i]) {
940  for (j = 0; j < 2; j++) {
941  ses(chroma_weight_l0[i][j], -128, +127, 2, i, j);
942  ses(chroma_offset_l0[i][j], -128, +127, 2, i, j);
943  }
944  }
945  }
946  }
947 
948  if (current->slice_type % 5 == 1) {
949  for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
950  flags(luma_weight_l1_flag[i], 1, i);
951  if (current->luma_weight_l1_flag[i]) {
952  ses(luma_weight_l1[i], -128, +127, 1, i);
953  ses(luma_offset_l1[i], -128, +127, 1, i);
954  }
955  if (chroma) {
956  flags(chroma_weight_l1_flag[i], 1, i);
957  if (current->chroma_weight_l1_flag[i]) {
958  for (j = 0; j < 2; j++) {
959  ses(chroma_weight_l1[i][j], -128, +127, 2, i, j);
960  ses(chroma_offset_l1[i][j], -128, +127, 2, i, j);
961  }
962  }
963  }
964  }
965  }
966 
967  return 0;
968 }
969 
970 static int FUNC(dec_ref_pic_marking)(CodedBitstreamContext *ctx, RWContext *rw,
971  H264RawSliceHeader *current, int idr_pic_flag)
972 {
973  CodedBitstreamH264Context *h264 = ctx->priv_data;
974  const H264RawSPS *sps = h264->active_sps;
975  int err, i;
976  uint32_t mmco;
977 
978  if (idr_pic_flag) {
979  flag(no_output_of_prior_pics_flag);
980  flag(long_term_reference_flag);
981  } else {
982  flag(adaptive_ref_pic_marking_mode_flag);
983  if (current->adaptive_ref_pic_marking_mode_flag) {
984  for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {
985  xue(memory_management_control_operation,
986  current->mmco[i].memory_management_control_operation,
987  0, 6, 0);
988 
989  mmco = current->mmco[i].memory_management_control_operation;
990  if (mmco == 0)
991  break;
992 
993  if (mmco == 1 || mmco == 3)
994  xue(difference_of_pic_nums_minus1,
995  current->mmco[i].difference_of_pic_nums_minus1,
996  0, INT32_MAX, 0);
997  if (mmco == 2)
998  xue(long_term_pic_num,
999  current->mmco[i].long_term_pic_num,
1000  0, sps->max_num_ref_frames - 1, 0);
1001  if (mmco == 3 || mmco == 6)
1002  xue(long_term_frame_idx,
1003  current->mmco[i].long_term_frame_idx,
1004  0, sps->max_num_ref_frames - 1, 0);
1005  if (mmco == 4)
1006  xue(max_long_term_frame_idx_plus1,
1007  current->mmco[i].max_long_term_frame_idx_plus1,
1008  0, sps->max_num_ref_frames, 0);
1009  }
1010  if (i == H264_MAX_MMCO_COUNT) {
1011  av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many "
1012  "memory management control operations.\n");
1013  return AVERROR_INVALIDDATA;
1014  }
1015  }
1016  }
1017 
1018  return 0;
1019 }
1020 
1021 static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
1022  H264RawSliceHeader *current)
1023 {
1024  CodedBitstreamH264Context *h264 = ctx->priv_data;
1025  const H264RawSPS *sps;
1026  const H264RawPPS *pps;
1027  int err;
1028  int idr_pic_flag;
1029  int slice_type_i, slice_type_p, slice_type_b;
1030  int slice_type_si, slice_type_sp;
1031 
1032  HEADER("Slice Header");
1033 
1034  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1035  1 << H264_NAL_SLICE |
1036  1 << H264_NAL_IDR_SLICE |
1037  1 << H264_NAL_AUXILIARY_SLICE));
1038 
1039  if (current->nal_unit_header.nal_unit_type == H264_NAL_AUXILIARY_SLICE) {
1040  if (!h264->last_slice_nal_unit_type) {
1041  av_log(ctx->log_ctx, AV_LOG_ERROR, "Auxiliary slice "
1042  "is not decodable without the main picture "
1043  "in the same access unit.\n");
1044  return AVERROR_INVALIDDATA;
1045  }
1046  idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;
1047  } else {
1048  idr_pic_flag = current->nal_unit_header.nal_unit_type == H264_NAL_IDR_SLICE;
1049  }
1050 
1051  ue(first_mb_in_slice, 0, H264_MAX_MB_PIC_SIZE - 1);
1052  ue(slice_type, 0, 9);
1053 
1054  slice_type_i = current->slice_type % 5 == 2;
1055  slice_type_p = current->slice_type % 5 == 0;
1056  slice_type_b = current->slice_type % 5 == 1;
1057  slice_type_si = current->slice_type % 5 == 4;
1058  slice_type_sp = current->slice_type % 5 == 3;
1059 
1060  if (idr_pic_flag && !(slice_type_i || slice_type_si)) {
1061  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid slice type %d "
1062  "for IDR picture.\n", current->slice_type);
1063  return AVERROR_INVALIDDATA;
1064  }
1065 
1066  ue(pic_parameter_set_id, 0, 255);
1067 
1068  pps = h264->pps[current->pic_parameter_set_id];
1069  if (!pps) {
1070  av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
1071  current->pic_parameter_set_id);
1072  return AVERROR_INVALIDDATA;
1073  }
1074  h264->active_pps = pps;
1075 
1076  sps = h264->sps[pps->seq_parameter_set_id];
1077  if (!sps) {
1078  av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
1079  pps->seq_parameter_set_id);
1080  return AVERROR_INVALIDDATA;
1081  }
1082  h264->active_sps = sps;
1083 
1084  if (sps->separate_colour_plane_flag)
1085  u(2, colour_plane_id, 0, 2);
1086 
1087  ub(sps->log2_max_frame_num_minus4 + 4, frame_num);
1088 
1089  if (!sps->frame_mbs_only_flag) {
1090  flag(field_pic_flag);
1091  if (current->field_pic_flag)
1092  flag(bottom_field_flag);
1093  else
1094  infer(bottom_field_flag, 0);
1095  } else {
1096  infer(field_pic_flag, 0);
1097  infer(bottom_field_flag, 0);
1098  }
1099 
1100  if (idr_pic_flag)
1101  ue(idr_pic_id, 0, 65535);
1102 
1103  if (sps->pic_order_cnt_type == 0) {
1104  ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb);
1105  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1106  !current->field_pic_flag)
1107  se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);
1108 
1109  } else if (sps->pic_order_cnt_type == 1) {
1110  if (!sps->delta_pic_order_always_zero_flag) {
1111  se(delta_pic_order_cnt[0], INT32_MIN + 1, INT32_MAX);
1112  if (pps->bottom_field_pic_order_in_frame_present_flag &&
1113  !current->field_pic_flag)
1114  se(delta_pic_order_cnt[1], INT32_MIN + 1, INT32_MAX);
1115  else
1116  infer(delta_pic_order_cnt[1], 0);
1117  } else {
1118  infer(delta_pic_order_cnt[0], 0);
1119  infer(delta_pic_order_cnt[1], 0);
1120  }
1121  }
1122 
1123  if (pps->redundant_pic_cnt_present_flag)
1124  ue(redundant_pic_cnt, 0, 127);
1125  else
1126  infer(redundant_pic_cnt, 0);
1127 
1128  if (current->nal_unit_header.nal_unit_type != H264_NAL_AUXILIARY_SLICE
1129  && !current->redundant_pic_cnt)
1130  h264->last_slice_nal_unit_type =
1131  current->nal_unit_header.nal_unit_type;
1132 
1133  if (slice_type_b)
1134  flag(direct_spatial_mv_pred_flag);
1135 
1136  if (slice_type_p || slice_type_sp || slice_type_b) {
1137  flag(num_ref_idx_active_override_flag);
1138  if (current->num_ref_idx_active_override_flag) {
1139  ue(num_ref_idx_l0_active_minus1, 0, 31);
1140  if (slice_type_b)
1141  ue(num_ref_idx_l1_active_minus1, 0, 31);
1142  } else {
1143  infer(num_ref_idx_l0_active_minus1,
1144  pps->num_ref_idx_l0_default_active_minus1);
1145  infer(num_ref_idx_l1_active_minus1,
1146  pps->num_ref_idx_l1_default_active_minus1);
1147  }
1148  }
1149 
1150  if (current->nal_unit_header.nal_unit_type == 20 ||
1151  current->nal_unit_header.nal_unit_type == 21) {
1152  av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC / 3DAVC not supported.\n");
1153  return AVERROR_PATCHWELCOME;
1154  } else {
1155  CHECK(FUNC(ref_pic_list_modification)(ctx, rw, current));
1156  }
1157 
1158  if ((pps->weighted_pred_flag && (slice_type_p || slice_type_sp)) ||
1159  (pps->weighted_bipred_idc == 1 && slice_type_b)) {
1160  CHECK(FUNC(pred_weight_table)(ctx, rw, current));
1161  }
1162 
1163  if (current->nal_unit_header.nal_ref_idc != 0) {
1164  CHECK(FUNC(dec_ref_pic_marking)(ctx, rw, current, idr_pic_flag));
1165  }
1166 
1167  if (pps->entropy_coding_mode_flag &&
1168  !slice_type_i && !slice_type_si) {
1169  ue(cabac_init_idc, 0, 2);
1170  }
1171 
1172  se(slice_qp_delta, - 51 - 6 * sps->bit_depth_luma_minus8,
1173  + 51 + 6 * sps->bit_depth_luma_minus8);
1174  if (slice_type_sp || slice_type_si) {
1175  if (slice_type_sp)
1176  flag(sp_for_switch_flag);
1177  se(slice_qs_delta, -51, +51);
1178  }
1179 
1180  if (pps->deblocking_filter_control_present_flag) {
1181  ue(disable_deblocking_filter_idc, 0, 2);
1182  if (current->disable_deblocking_filter_idc != 1) {
1183  se(slice_alpha_c0_offset_div2, -6, +6);
1184  se(slice_beta_offset_div2, -6, +6);
1185  } else {
1186  infer(slice_alpha_c0_offset_div2, 0);
1187  infer(slice_beta_offset_div2, 0);
1188  }
1189  } else {
1190  infer(disable_deblocking_filter_idc, 0);
1191  infer(slice_alpha_c0_offset_div2, 0);
1192  infer(slice_beta_offset_div2, 0);
1193  }
1194 
1195  if (pps->num_slice_groups_minus1 > 0 &&
1196  pps->slice_group_map_type >= 3 &&
1197  pps->slice_group_map_type <= 5) {
1198  unsigned int pic_size, max, bits;
1199 
1200  pic_size = (sps->pic_width_in_mbs_minus1 + 1) *
1201  (sps->pic_height_in_map_units_minus1 + 1);
1202  max = (pic_size + pps->slice_group_change_rate_minus1) /
1203  (pps->slice_group_change_rate_minus1 + 1);
1204  bits = av_ceil_log2(max + 1);
1205 
1206  u(bits, slice_group_change_cycle, 0, max);
1207  }
1208 
1209  if (pps->entropy_coding_mode_flag) {
1210  while (byte_alignment(rw))
1211  fixed(1, cabac_alignment_one_bit, 1);
1212  }
1213 
1214  return 0;
1215 }
1216 
1217 static int FUNC(filler)(CodedBitstreamContext *ctx, RWContext *rw,
1218  H264RawFiller *current)
1219 {
1220  int err;
1221 
1222  HEADER("Filler Data");
1223 
1224  CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,
1225  1 << H264_NAL_FILLER_DATA));
1226 
1227 #ifdef READ
1228  while (show_bits(rw, 8) == 0xff) {
1229  fixed(8, ff_byte, 0xff);
1230  ++current->filler_size;
1231  }
1232 #else
1233  {
1234  uint32_t i;
1235  for (i = 0; i < current->filler_size; i++)
1236  fixed(8, ff_byte, 0xff);
1237  }
1238 #endif
1239 
1240  CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
1241 
1242  return 0;
1243 }
1244 
1245 static int FUNC(end_of_sequence)(CodedBitstreamContext *ctx, RWContext *rw,
1246  H264RawNALUnitHeader *current)
1247 {
1248  HEADER("End of Sequence");
1249 
1250  return FUNC(nal_unit_header)(ctx, rw, current,
1251  1 << H264_NAL_END_SEQUENCE);
1252 }
1253 
1254 static int FUNC(end_of_stream)(CodedBitstreamContext *ctx, RWContext *rw,
1255  H264RawNALUnitHeader *current)
1256 {
1257  HEADER("End of Stream");
1258 
1259  return FUNC(nal_unit_header)(ctx, rw, current,
1260  1 << H264_NAL_END_STREAM);
1261 }
H264_NAL_PPS
@ H264_NAL_PPS
Definition: h264.h:42
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
xue
#define xue(name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:411
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
byte_alignment
#define byte_alignment(rw)
Definition: cbs_av1.c:653
H264RawSEIPicTiming::pic_struct
uint8_t pic_struct
Definition: cbs_h264.h:252
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:250
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:259
HEADER
#define HEADER(name)
Definition: cbs_av1.c:456
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
CodedBitstreamH264Context::pps
H264RawPPS * pps[H264_MAX_PPS_COUNT]
RefStruct references.
Definition: cbs_h264.h:411
infer
#define infer(name, value)
Definition: cbs_av1.c:643
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:219
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
allocate
#define allocate(name, size)
Definition: cbs_h2645.c:445
max
#define max(a, b)
Definition: cuda_runtime.h:33
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:274
H264RawSEIPicTiming
Definition: cbs_h264.h:249
H264_MAX_RPLM_COUNT
@ H264_MAX_RPLM_COUNT
Definition: h264.h:84
CHECK
CHECK(-1) CHECK(-2) }} }} CHECK(1) CHECK(2) }} }} } if(diff0+diff1 > 0) temp -
av_ceil_log2
#define av_ceil_log2
Definition: common.h:95
CodedBitstreamH264Context::active_sps
const H264RawSPS * active_sps
Definition: cbs_h264.h:416
filler
static int FUNC() filler(CodedBitstreamContext *ctx, RWContext *rw, H264RawFiller *current)
Definition: cbs_h264_syntax_template.c:1217
ub
#define ub(width, name)
Definition: cbs_h2645.c:400
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
ue
#define ue(name, range_min, range_max)
Definition: cbs_h2645.c:253
H264_NAL_AUXILIARY_SLICE
@ H264_NAL_AUXILIARY_SLICE
Definition: h264.h:53
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:262
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:253
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
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_MMCO_COUNT
@ H264_MAX_MMCO_COUNT
Definition: h264.h:92
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:48
FUNC_SEI
#define FUNC_SEI(name)
Definition: cbs_h2645.c:236
MAX_UINT_BITS
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:196
H264_MAX_SPS_COUNT
@ H264_MAX_SPS_COUNT
Definition: h264.h:71
pred_weight_table
static int FUNC() pred_weight_table(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:917
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
H264_NAL_END_SEQUENCE
@ H264_NAL_END_SEQUENCE
Definition: h264.h:44
slice_header
static int FUNC() slice_header(CodedBitstreamContext *ctx, RWContext *rw, H264RawSliceHeader *current)
Definition: cbs_h264_syntax_template.c:1021
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:1254
H264_NAL_END_STREAM
@ H264_NAL_END_STREAM
Definition: h264.h:45
H264RawNALUnitHeader
Definition: cbs_h264.h:31
H264RawSEIPanScanRect
Definition: cbs_h264.h:257
H264_MAX_MB_PIC_SIZE
@ H264_MAX_MB_PIC_SIZE
Definition: h264.h:102
state
static struct @385 state
H264RawSEIBufferingPeriod::nal
struct H264RawSEIBufferingPeriod::@42 nal
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:824
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_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
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:841
H264RawFilmGrainCharacteristics::film_grain_bit_depth_luma_minus8
uint8_t film_grain_bit_depth_luma_minus8
Definition: cbs_h264.h:279
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
H264RawFilmGrainCharacteristics
Definition: cbs_h264.h:275
H264RawSEIBufferingPeriod::vcl
struct H264RawSEIBufferingPeriod::@42 vcl
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:165
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:296
H264RawSEIPanScanRect::pan_scan_cnt_minus1
uint8_t pan_scan_cnt_minus1
Definition: cbs_h264.h:260
H264_MAX_MB_HEIGHT
@ H264_MAX_MB_HEIGHT
Definition: h264.h:107
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
H264RawFilmGrainCharacteristics::num_intensity_intervals_minus1
uint8_t num_intensity_intervals_minus1[3]
Definition: cbs_h264.h:288
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
CodedBitstreamH264Context::active_pps
const H264RawPPS * active_pps
Definition: cbs_h264.h:417
H264RawSliceHeader
Definition: cbs_h264.h:310
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:858
flag
#define flag(name)
Definition: cbs_av1.c:474
vui_parameters
static int FUNC() vui_parameters(CodedBitstreamContext *ctx, RWContext *rw, H264RawVUI *current, H264RawSPS *sps)
Definition: cbs_h264_syntax_template.c:111
ubs
#define ubs(width, name, subs,...)
Definition: cbs_h2645.c:264
CodedBitstreamH264Context::last_slice_nal_unit_type
uint8_t last_slice_nal_unit_type
Definition: cbs_h264.h:422
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
H264_MAX_MB_WIDTH
@ H264_MAX_MB_WIDTH
Definition: h264.h:106
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
H264RawSEI
Definition: cbs_h264.h:305
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
H264RawSEIBufferingPeriod::seq_parameter_set_id
uint8_t seq_parameter_set_id
Definition: cbs_h264.h:225
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:970
SEIMessageState
Definition: cbs_sei.h:86
H264RawAUD
Definition: cbs_h264.h:218
FUNC
#define FUNC(a)
Definition: bit_depth_template.c:104
end_of_sequence
static int FUNC() end_of_sequence(CodedBitstreamContext *ctx, RWContext *rw, H264RawNALUnitHeader *current)
Definition: cbs_h264_syntax_template.c:1245
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:440
H264RawSEIRecoveryPoint
Definition: cbs_h264.h:268
ib
#define ib(width, name)
Definition: cbs_h2645.c:257
H264RawSEIDisplayOrientation::display_orientation_cancel_flag
uint8_t display_orientation_cancel_flag
Definition: cbs_h264.h:297
fixed
#define fixed(width, name, value)
Definition: cbs_av1.c:487
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
H264RawFiller
Definition: cbs_h264.h:397
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:268
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
H264_NAL_SPS_EXT
@ H264_NAL_SPS_EXT
Definition: h264.h:47
SEI_FUNC
SEI_FUNC(sei_buffering_period,(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIBufferingPeriod *current, SEIMessageState *sei))
Definition: cbs_h264_syntax_template.c:513
xu
#define xu(width, name, var, range_min, range_max, subs,...)
Definition: cbs_h2645.c:405
RWContext
#define RWContext
Definition: cbs_av1.c:591
CodedBitstreamH264Context::sps
H264RawSPS * sps[H264_MAX_SPS_COUNT]
RefStruct references.
Definition: cbs_h264.h:410
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1283
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
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 Thu Sep 26 2024 23:14:51 for FFmpeg by   doxygen 1.8.17