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

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