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