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