git.sesse.net Git - ffmpeg/blob - libavcodec/cbs_h264_syntax_template.c

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