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