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