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