falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
100691 Commits
32 Branches
380MB
Tree: 4bf3384800
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4bf3384800'
${ noResults }
FFmpeg/libavcodec/cbs_h264_syntax_template.c

1329 lines
44KB
Raw Blame History 

  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. {

  516.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  517.     const H264RawSPS *sps;

  518.     int err, i, length;

  519. 

  520.     HEADER("Buffering Period");

  521. 

  522.     ue(seq_parameter_set_id, 0, 31);

  523. 

  524.     sps = h264->sps[current->seq_parameter_set_id];

  525.     if (!sps) {

  526.         av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",

  527.                current->seq_parameter_set_id);

  528.         return AVERROR_INVALIDDATA;

  529.     }

  530.     h264->active_sps = sps;

  531. 

  532.     if (sps->vui.nal_hrd_parameters_present_flag) {

  533.         for (i = 0; i <= sps->vui.nal_hrd_parameters.cpb_cnt_minus1; i++) {

  534.             length = sps->vui.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;

  535.             xu(length, initial_cpb_removal_delay[SchedSelIdx],

  536.                current->nal.initial_cpb_removal_delay[i],

  537.                1, MAX_UINT_BITS(length), 1, i);

  538.             xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],

  539.                current->nal.initial_cpb_removal_delay_offset[i],

  540.                0, MAX_UINT_BITS(length), 1, i);

  541.         }

  542.     }

  543. 

  544.     if (sps->vui.vcl_hrd_parameters_present_flag) {

  545.         for (i = 0; i <= sps->vui.vcl_hrd_parameters.cpb_cnt_minus1; i++) {

  546.             length = sps->vui.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;

  547.             xu(length, initial_cpb_removal_delay[SchedSelIdx],

  548.                current->vcl.initial_cpb_removal_delay[i],

  549.                1, MAX_UINT_BITS(length), 1, i);

  550.             xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],

  551.                current->vcl.initial_cpb_removal_delay_offset[i],

  552.                0, MAX_UINT_BITS(length), 1, i);

  553.         }

  554.     }

  555. 

  556.     return 0;

  557. }

  558. 

  559. static int FUNC(sei_pic_timestamp)(CodedBitstreamContext *ctx, RWContext *rw,

  560.                                    H264RawSEIPicTimestamp *current,

  561.                                    const H264RawSPS *sps)

  562. {

  563.     uint8_t time_offset_length;

  564.     int err;

  565. 

  566.     u(2, ct_type, 0, 2);

  567.     flag(nuit_field_based_flag);

  568.     u(5, counting_type, 0, 6);

  569.     flag(full_timestamp_flag);

  570.     flag(discontinuity_flag);

  571.     flag(cnt_dropped_flag);

  572.     ub(8, n_frames);

  573.     if (current->full_timestamp_flag) {

  574.             u(6, seconds_value, 0, 59);

  575.             u(6, minutes_value, 0, 59);

  576.             u(5, hours_value,   0, 23);

  577.     } else {

  578.         flag(seconds_flag);

  579.         if (current->seconds_flag) {

  580.             u(6, seconds_value, 0, 59);

  581.             flag(minutes_flag);

  582.             if (current->minutes_flag) {

  583.                 u(6, minutes_value, 0, 59);

  584.                 flag(hours_flag);

  585.                 if (current->hours_flag)

  586.                     u(5, hours_value, 0, 23);

  587.             }

  588.         }

  589.     }

  590. 

  591.     if (sps->vui.nal_hrd_parameters_present_flag)

  592.         time_offset_length = sps->vui.nal_hrd_parameters.time_offset_length;

  593.     else if (sps->vui.vcl_hrd_parameters_present_flag)

  594.         time_offset_length = sps->vui.vcl_hrd_parameters.time_offset_length;

  595.     else

  596.         time_offset_length = 24;

  597. 

  598.     if (time_offset_length > 0)

  599.         ib(time_offset_length, time_offset);

  600.     else

  601.         infer(time_offset, 0);

  602. 

  603.     return 0;

  604. }

  605. 

  606. static int FUNC(sei_pic_timing)(CodedBitstreamContext *ctx, RWContext *rw,

  607.                                 H264RawSEIPicTiming *current)

  608. {

  609.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  610.     const H264RawSPS *sps;

  611.     int err;

  612. 

  613.     HEADER("Picture Timing");

  614. 

  615.     sps = h264->active_sps;

  616.     if (!sps) {

  617.         // If there is exactly one possible SPS but it is not yet active

  618.         // then just assume that it should be the active one.

  619.         int i, k = -1;

  620.         for (i = 0; i < H264_MAX_SPS_COUNT; i++) {

  621.             if (h264->sps[i]) {

  622.                 if (k >= 0) {

  623.                     k = -1;

  624.                     break;

  625.                 }

  626.                 k = i;

  627.             }

  628.         }

  629.         if (k >= 0)

  630.             sps = h264->sps[k];

  631.     }

  632.     if (!sps) {

  633.         av_log(ctx->log_ctx, AV_LOG_ERROR,

  634.                "No active SPS for pic_timing.\n");

  635.         return AVERROR_INVALIDDATA;

  636.     }

  637. 

  638.     if (sps->vui.nal_hrd_parameters_present_flag ||

  639.         sps->vui.vcl_hrd_parameters_present_flag) {

  640.         const H264RawHRD *hrd;

  641. 

  642.         if (sps->vui.nal_hrd_parameters_present_flag)

  643.             hrd = &sps->vui.nal_hrd_parameters;

  644.         else if (sps->vui.vcl_hrd_parameters_present_flag)

  645.             hrd = &sps->vui.vcl_hrd_parameters;

  646.         else {

  647.             av_log(ctx->log_ctx, AV_LOG_ERROR,

  648.                    "No HRD parameters for pic_timing.\n");

  649.             return AVERROR_INVALIDDATA;

  650.         }

  651. 

  652.         ub(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay);

  653.         ub(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay);

  654.     }

  655. 

  656.     if (sps->vui.pic_struct_present_flag) {

  657.         static const uint8_t num_clock_ts[9] = {

  658.             1, 1, 1, 2, 2, 3, 3, 2, 3

  659.         };

  660.         int i;

  661. 

  662.         u(4, pic_struct, 0, 8);

  663.         if (current->pic_struct > 8)

  664.             return AVERROR_INVALIDDATA;

  665. 

  666.         for (i = 0; i < num_clock_ts[current->pic_struct]; i++) {

  667.             flags(clock_timestamp_flag[i], 1, i);

  668.             if (current->clock_timestamp_flag[i])

  669.                 CHECK(FUNC(sei_pic_timestamp)(ctx, rw,

  670.                                               &current->timestamp[i], sps));

  671.         }

  672.     }

  673. 

  674.     return 0;

  675. }

  676. 

  677. static int FUNC(sei_pan_scan_rect)(CodedBitstreamContext *ctx, RWContext *rw,

  678.                                    H264RawSEIPanScanRect *current)

  679. {

  680.     int err, i;

  681. 

  682.     HEADER("Pan-Scan Rectangle");

  683. 

  684.     ue(pan_scan_rect_id, 0, UINT32_MAX - 1);

  685.     flag(pan_scan_rect_cancel_flag);

  686. 

  687.     if (!current->pan_scan_rect_cancel_flag) {

  688.         ue(pan_scan_cnt_minus1, 0, 2);

  689. 

  690.         for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {

  691.             ses(pan_scan_rect_left_offset[i],   INT32_MIN + 1, INT32_MAX, 1, i);

  692.             ses(pan_scan_rect_right_offset[i],  INT32_MIN + 1, INT32_MAX, 1, i);

  693.             ses(pan_scan_rect_top_offset[i],    INT32_MIN + 1, INT32_MAX, 1, i);

  694.             ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);

  695.         }

  696. 

  697.         ue(pan_scan_rect_repetition_period, 0, 16384);

  698.     }

  699. 

  700.     return 0;

  701. }

  702. 

  703. static int FUNC(sei_recovery_point)(CodedBitstreamContext *ctx, RWContext *rw,

  704.                                     H264RawSEIRecoveryPoint *current)

  705. {

  706.     int err;

  707. 

  708.     HEADER("Recovery Point");

  709. 

  710.     ue(recovery_frame_cnt, 0, 65535);

  711.     flag(exact_match_flag);

  712.     flag(broken_link_flag);

  713.     u(2, changing_slice_group_idc, 0, 2);

  714. 

  715.     return 0;

  716. }

  717. 

  718. static int FUNC(sei_display_orientation)(CodedBitstreamContext *ctx, RWContext *rw,

  719.                                          H264RawSEIDisplayOrientation *current)

  720. {

  721.     int err;

  722. 

  723.     HEADER("Display Orientation");

  724. 

  725.     flag(display_orientation_cancel_flag);

  726.     if (!current->display_orientation_cancel_flag) {

  727.         flag(hor_flip);

  728.         flag(ver_flip);

  729.         ub(16, anticlockwise_rotation);

  730.         ue(display_orientation_repetition_period, 0, 16384);

  731.         flag(display_orientation_extension_flag);

  732.     }

  733. 

  734.     return 0;

  735. }

  736. 

  737. static int FUNC(sei_payload)(CodedBitstreamContext *ctx, RWContext *rw,

  738.                              H264RawSEIPayload *current)

  739. {

  740.     int err, i;

  741.     int start_position, end_position;

  742. 

  743. #ifdef READ

  744.     start_position = get_bits_count(rw);

  745. #else

  746.     start_position = put_bits_count(rw);

  747. #endif

  748. 

  749.     switch (current->payload_type) {

  750.     case H264_SEI_TYPE_BUFFERING_PERIOD:

  751.         CHECK(FUNC(sei_buffering_period)

  752.               (ctx, rw, &current->payload.buffering_period));

  753.         break;

  754.     case H264_SEI_TYPE_PIC_TIMING:

  755.         CHECK(FUNC(sei_pic_timing)

  756.               (ctx, rw, &current->payload.pic_timing));

  757.         break;

  758.     case H264_SEI_TYPE_PAN_SCAN_RECT:

  759.         CHECK(FUNC(sei_pan_scan_rect)

  760.               (ctx, rw, &current->payload.pan_scan_rect));

  761.         break;

  762.     case H264_SEI_TYPE_FILLER_PAYLOAD:

  763.         {

  764.             for (i = 0; i  < current->payload_size; i++)

  765.                 fixed(8, ff_byte, 0xff);

  766.         }

  767.         break;

  768.     case H264_SEI_TYPE_USER_DATA_REGISTERED:

  769.         CHECK(FUNC_SEI(sei_user_data_registered)

  770.               (ctx, rw, &current->payload.user_data_registered, &current->payload_size));

  771.         break;

  772.     case H264_SEI_TYPE_USER_DATA_UNREGISTERED:

  773.         CHECK(FUNC_SEI(sei_user_data_unregistered)

  774.               (ctx, rw, &current->payload.user_data_unregistered, &current->payload_size));

  775.         break;

  776.     case H264_SEI_TYPE_RECOVERY_POINT:

  777.         CHECK(FUNC(sei_recovery_point)

  778.               (ctx, rw, &current->payload.recovery_point));

  779.         break;

  780.     case H264_SEI_TYPE_DISPLAY_ORIENTATION:

  781.         CHECK(FUNC(sei_display_orientation)

  782.               (ctx, rw, &current->payload.display_orientation));

  783.         break;

  784.     case H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME:

  785.         CHECK(FUNC_SEI(sei_mastering_display_colour_volume)

  786.               (ctx, rw, &current->payload.mastering_display_colour_volume));

  787.         break;

  788.     case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:

  789.         CHECK(FUNC_SEI(sei_alternative_transfer_characteristics)

  790.               (ctx, rw, &current->payload.alternative_transfer_characteristics));

  791.         break;

  792.     default:

  793.         {

  794. #ifdef READ

  795.             current->payload.other.data_length = current->payload_size;

  796. #endif

  797.             allocate(current->payload.other.data, current->payload.other.data_length);

  798.             for (i = 0; i < current->payload.other.data_length; i++)

  799.                 xu(8, payload_byte[i], current->payload.other.data[i], 0, 255, 1, i);

  800.         }

  801.     }

  802. 

  803.     if (byte_alignment(rw)) {

  804.         fixed(1, bit_equal_to_one, 1);

  805.         while (byte_alignment(rw))

  806.             fixed(1, bit_equal_to_zero, 0);

  807.     }

  808. 

  809. #ifdef READ

  810.     end_position = get_bits_count(rw);

  811.     if (end_position < start_position + 8 * current->payload_size) {

  812.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Incorrect SEI payload length: "

  813.                "header %"PRIu32" bits, actually %d bits.\n",

  814.                8 * current->payload_size,

  815.                end_position - start_position);

  816.         return AVERROR_INVALIDDATA;

  817.     }

  818. #else

  819.     end_position = put_bits_count(rw);

  820.     current->payload_size = (end_position - start_position) / 8;

  821. #endif

  822. 

  823.     return 0;

  824. }

  825. 

  826. static int FUNC(sei)(CodedBitstreamContext *ctx, RWContext *rw,

  827.                      H264RawSEI *current)

  828. {

  829.     int err, k;

  830. 

  831.     HEADER("Supplemental Enhancement Information");

  832. 

  833.     CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,

  834.                                 1 << H264_NAL_SEI));

  835. 

  836. #ifdef READ

  837.     for (k = 0; k < H264_MAX_SEI_PAYLOADS; k++) {

  838.         uint32_t payload_type = 0;

  839.         uint32_t payload_size = 0;

  840.         uint32_t tmp;

  841. 

  842.         while (show_bits(rw, 8) == 0xff) {

  843.             fixed(8, ff_byte, 0xff);

  844.             payload_type += 255;

  845.         }

  846.         xu(8, last_payload_type_byte, tmp, 0, 254, 0);

  847.         payload_type += tmp;

  848. 

  849.         while (show_bits(rw, 8) == 0xff) {

  850.             fixed(8, ff_byte, 0xff);

  851.             payload_size += 255;

  852.         }

  853.         xu(8, last_payload_size_byte, tmp, 0, 254, 0);

  854.         payload_size += tmp;

  855. 

  856.         current->payload[k].payload_type = payload_type;

  857.         current->payload[k].payload_size = payload_size;

  858. 

  859.         current->payload_count++;

  860.         CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k]));

  861. 

  862.         if (!cbs_h2645_read_more_rbsp_data(rw))

  863.             break;

  864.     }

  865.     if (k >= H264_MAX_SEI_PAYLOADS) {

  866.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many payloads in "

  867.                "SEI message: found %d.\n", k);

  868.         return AVERROR_INVALIDDATA;

  869.     }

  870. #else

  871.     for (k = 0; k < current->payload_count; k++) {

  872.         PutBitContext start_state;

  873.         uint32_t tmp;

  874.         int need_size, i;

  875. 

  876.         // Somewhat clumsy: we write the payload twice when

  877.         // we don't know the size in advance.  This will mess

  878.         // with trace output, but is otherwise harmless.

  879.         start_state = *rw;

  880.         need_size = !current->payload[k].payload_size;

  881.         for (i = 0; i < 1 + need_size; i++) {

  882.             *rw = start_state;

  883. 

  884.             tmp = current->payload[k].payload_type;

  885.             while (tmp >= 255) {

  886.                 fixed(8, ff_byte, 0xff);

  887.                 tmp -= 255;

  888.             }

  889.             xu(8, last_payload_type_byte, tmp, 0, 254, 0);

  890. 

  891.             tmp = current->payload[k].payload_size;

  892.             while (tmp >= 255) {

  893.                 fixed(8, ff_byte, 0xff);

  894.                 tmp -= 255;

  895.             }

  896.             xu(8, last_payload_size_byte, tmp, 0, 254, 0);

  897. 

  898.             CHECK(FUNC(sei_payload)(ctx, rw, &current->payload[k]));

  899.         }

  900.     }

  901. #endif

  902. 

  903.     CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));

  904. 

  905.     return 0;

  906. }

  907. 

  908. static int FUNC(aud)(CodedBitstreamContext *ctx, RWContext *rw,

  909.                      H264RawAUD *current)

  910. {

  911.     int err;

  912. 

  913.     HEADER("Access Unit Delimiter");

  914. 

  915.     CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,

  916.                                 1 << H264_NAL_AUD));

  917. 

  918.     ub(3, primary_pic_type);

  919. 

  920.     CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));

  921. 

  922.     return 0;

  923. }

  924. 

  925. static int FUNC(ref_pic_list_modification)(CodedBitstreamContext *ctx, RWContext *rw,

  926.                                            H264RawSliceHeader *current)

  927. {

  928.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  929.     const H264RawSPS *sps = h264->active_sps;

  930.     int err, i, mopn;

  931. 

  932.     if (current->slice_type % 5 != 2 &&

  933.         current->slice_type % 5 != 4) {

  934.         flag(ref_pic_list_modification_flag_l0);

  935.         if (current->ref_pic_list_modification_flag_l0) {

  936.             for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {

  937.                 xue(modification_of_pic_nums_idc,

  938.                     current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3, 0);

  939. 

  940.                 mopn = current->rplm_l0[i].modification_of_pic_nums_idc;

  941.                 if (mopn == 3)

  942.                     break;

  943. 

  944.                 if (mopn == 0 || mopn == 1)

  945.                     xue(abs_diff_pic_num_minus1,

  946.                         current->rplm_l0[i].abs_diff_pic_num_minus1,

  947.                         0, (1 + current->field_pic_flag) *

  948.                         (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);

  949.                 else if (mopn == 2)

  950.                     xue(long_term_pic_num,

  951.                         current->rplm_l0[i].long_term_pic_num,

  952.                         0, sps->max_num_ref_frames - 1, 0);

  953.             }

  954.         }

  955.     }

  956. 

  957.     if (current->slice_type % 5 == 1) {

  958.         flag(ref_pic_list_modification_flag_l1);

  959.         if (current->ref_pic_list_modification_flag_l1) {

  960.             for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {

  961.                 xue(modification_of_pic_nums_idc,

  962.                     current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3, 0);

  963. 

  964.                 mopn = current->rplm_l1[i].modification_of_pic_nums_idc;

  965.                 if (mopn == 3)

  966.                     break;

  967. 

  968.                 if (mopn == 0 || mopn == 1)

  969.                     xue(abs_diff_pic_num_minus1,

  970.                         current->rplm_l1[i].abs_diff_pic_num_minus1,

  971.                         0, (1 + current->field_pic_flag) *

  972.                         (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);

  973.                 else if (mopn == 2)

  974.                     xue(long_term_pic_num,

  975.                         current->rplm_l1[i].long_term_pic_num,

  976.                         0, sps->max_num_ref_frames - 1, 0);

  977.             }

  978.         }

  979.     }

  980. 

  981.     return 0;

  982. }

  983. 

  984. static int FUNC(pred_weight_table)(CodedBitstreamContext *ctx, RWContext *rw,

  985.                                    H264RawSliceHeader *current)

  986. {

  987.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  988.     const H264RawSPS *sps = h264->active_sps;

  989.     int chroma;

  990.     int err, i, j;

  991. 

  992.     ue(luma_log2_weight_denom, 0, 7);

  993. 

  994.     chroma = !sps->separate_colour_plane_flag && sps->chroma_format_idc != 0;

  995.     if (chroma)

  996.         ue(chroma_log2_weight_denom, 0, 7);

  997. 

  998.     for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {

  999.         flags(luma_weight_l0_flag[i], 1, i);

  1000.         if (current->luma_weight_l0_flag[i]) {

  1001.             ses(luma_weight_l0[i], -128, +127, 1, i);

  1002.             ses(luma_offset_l0[i], -128, +127, 1, i);

  1003.         }

  1004.         if (chroma) {

  1005.             flags(chroma_weight_l0_flag[i], 1, i);

  1006.             if (current->chroma_weight_l0_flag[i]) {

  1007.                 for (j = 0; j < 2; j++) {

  1008.                     ses(chroma_weight_l0[i][j], -128, +127, 2, i, j);

  1009.                     ses(chroma_offset_l0[i][j], -128, +127, 2, i, j);

  1010.                 }

  1011.             }

  1012.         }

  1013.     }

  1014. 

  1015.     if (current->slice_type % 5 == 1) {

  1016.         for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {

  1017.             flags(luma_weight_l1_flag[i], 1, i);

  1018.             if (current->luma_weight_l1_flag[i]) {

  1019.                 ses(luma_weight_l1[i], -128, +127, 1, i);

  1020.                 ses(luma_offset_l1[i], -128, +127, 1, i);

  1021.             }

  1022.             if (chroma) {

  1023.                 flags(chroma_weight_l1_flag[i], 1, i);

  1024.                 if (current->chroma_weight_l1_flag[i]) {

  1025.                     for (j = 0; j < 2; j++) {

  1026.                         ses(chroma_weight_l1[i][j], -128, +127, 2, i, j);

  1027.                         ses(chroma_offset_l1[i][j], -128, +127, 2, i, j);

  1028.                     }

  1029.                 }

  1030.             }

  1031.         }

  1032.     }

  1033. 

  1034.     return 0;

  1035. }

  1036. 

  1037. static int FUNC(dec_ref_pic_marking)(CodedBitstreamContext *ctx, RWContext *rw,

  1038.                                      H264RawSliceHeader *current, int idr_pic_flag)

  1039. {

  1040.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  1041.     const H264RawSPS *sps = h264->active_sps;

  1042.     int err, i;

  1043.     uint32_t mmco;

  1044. 

  1045.     if (idr_pic_flag) {

  1046.         flag(no_output_of_prior_pics_flag);

  1047.         flag(long_term_reference_flag);

  1048.     } else {

  1049.         flag(adaptive_ref_pic_marking_mode_flag);

  1050.         if (current->adaptive_ref_pic_marking_mode_flag) {

  1051.             for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {

  1052.                 xue(memory_management_control_operation,

  1053.                     current->mmco[i].memory_management_control_operation,

  1054.                     0, 6, 0);

  1055. 

  1056.                 mmco = current->mmco[i].memory_management_control_operation;

  1057.                 if (mmco == 0)

  1058.                     break;

  1059. 

  1060.                 if (mmco == 1 || mmco == 3)

  1061.                     xue(difference_of_pic_nums_minus1,

  1062.                         current->mmco[i].difference_of_pic_nums_minus1,

  1063.                         0, INT32_MAX, 0);

  1064.                 if (mmco == 2)

  1065.                     xue(long_term_pic_num,

  1066.                         current->mmco[i].long_term_pic_num,

  1067.                         0, sps->max_num_ref_frames - 1, 0);

  1068.                 if (mmco == 3 || mmco == 6)

  1069.                     xue(long_term_frame_idx,

  1070.                         current->mmco[i].long_term_frame_idx,

  1071.                         0, sps->max_num_ref_frames - 1, 0);

  1072.                 if (mmco == 4)

  1073.                     xue(max_long_term_frame_idx_plus1,

  1074.                         current->mmco[i].max_long_term_frame_idx_plus1,

  1075.                         0, sps->max_num_ref_frames, 0);

  1076.             }

  1077.             if (i == H264_MAX_MMCO_COUNT) {

  1078.                 av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many "

  1079.                        "memory management control operations.\n");

  1080.                 return AVERROR_INVALIDDATA;

  1081.             }

  1082.         }

  1083.     }

  1084. 

  1085.     return 0;

  1086. }

  1087. 

  1088. static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,

  1089.                               H264RawSliceHeader *current)

  1090. {

  1091.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  1092.     const H264RawSPS *sps;

  1093.     const H264RawPPS *pps;

  1094.     int err;

  1095.     int idr_pic_flag;

  1096.     int slice_type_i, slice_type_p, slice_type_b;

  1097.     int slice_type_si, slice_type_sp;

  1098. 

  1099.     HEADER("Slice Header");

  1100. 

  1101.     CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,

  1102.                                 1 << H264_NAL_SLICE     |

  1103.                                 1 << H264_NAL_IDR_SLICE |

  1104.                                 1 << H264_NAL_AUXILIARY_SLICE));

  1105. 

  1106.     if (current->nal_unit_header.nal_unit_type == H264_NAL_AUXILIARY_SLICE) {

  1107.         if (!h264->last_slice_nal_unit_type) {

  1108.             av_log(ctx->log_ctx, AV_LOG_ERROR, "Auxiliary slice "

  1109.                    "is not decodable without the main picture "

  1110.                    "in the same access unit.\n");

  1111.             return AVERROR_INVALIDDATA;

  1112.         }

  1113.         idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;

  1114.     } else {

  1115.         idr_pic_flag = current->nal_unit_header.nal_unit_type == H264_NAL_IDR_SLICE;

  1116.     }

  1117. 

  1118.     ue(first_mb_in_slice, 0, H264_MAX_MB_PIC_SIZE - 1);

  1119.     ue(slice_type, 0, 9);

  1120. 

  1121.     slice_type_i  = current->slice_type % 5 == 2;

  1122.     slice_type_p  = current->slice_type % 5 == 0;

  1123.     slice_type_b  = current->slice_type % 5 == 1;

  1124.     slice_type_si = current->slice_type % 5 == 4;

  1125.     slice_type_sp = current->slice_type % 5 == 3;

  1126. 

  1127.     if (idr_pic_flag && !(slice_type_i || slice_type_si)) {

  1128.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid slice type %d "

  1129.                "for IDR picture.\n", current->slice_type);

  1130.         return AVERROR_INVALIDDATA;

  1131.     }

  1132. 

  1133.     ue(pic_parameter_set_id, 0, 255);

  1134. 

  1135.     pps = h264->pps[current->pic_parameter_set_id];

  1136.     if (!pps) {

  1137.         av_log(ctx->log_ctx, AV_LOG_ERROR, "PPS id %d not available.\n",

  1138.                current->pic_parameter_set_id);

  1139.         return AVERROR_INVALIDDATA;

  1140.     }

  1141.     h264->active_pps = pps;

  1142. 

  1143.     sps = h264->sps[pps->seq_parameter_set_id];

  1144.     if (!sps) {

  1145.         av_log(ctx->log_ctx, AV_LOG_ERROR, "SPS id %d not available.\n",

  1146.                pps->seq_parameter_set_id);

  1147.         return AVERROR_INVALIDDATA;

  1148.     }

  1149.     h264->active_sps = sps;

  1150. 

  1151.     if (sps->separate_colour_plane_flag)

  1152.         u(2, colour_plane_id, 0, 2);

  1153. 

  1154.     ub(sps->log2_max_frame_num_minus4 + 4, frame_num);

  1155. 

  1156.     if (!sps->frame_mbs_only_flag) {

  1157.         flag(field_pic_flag);

  1158.         if (current->field_pic_flag)

  1159.             flag(bottom_field_flag);

  1160.         else

  1161.             infer(bottom_field_flag, 0);

  1162.     } else {

  1163.         infer(field_pic_flag,    0);

  1164.         infer(bottom_field_flag, 0);

  1165.     }

  1166. 

  1167.     if (idr_pic_flag)

  1168.         ue(idr_pic_id, 0, 65535);

  1169. 

  1170.     if (sps->pic_order_cnt_type == 0) {

  1171.         ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb);

  1172.         if (pps->bottom_field_pic_order_in_frame_present_flag &&

  1173.             !current->field_pic_flag)

  1174.             se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);

  1175. 

  1176.     } else if (sps->pic_order_cnt_type == 1) {

  1177.         if (!sps->delta_pic_order_always_zero_flag) {

  1178.             se(delta_pic_order_cnt[0], INT32_MIN + 1, INT32_MAX);

  1179.             if (pps->bottom_field_pic_order_in_frame_present_flag &&

  1180.                 !current->field_pic_flag)

  1181.                 se(delta_pic_order_cnt[1], INT32_MIN + 1, INT32_MAX);

  1182.             else

  1183.                 infer(delta_pic_order_cnt[1], 0);

  1184.         } else {

  1185.             infer(delta_pic_order_cnt[0], 0);

  1186.             infer(delta_pic_order_cnt[1], 0);

  1187.         }

  1188.     }

  1189. 

  1190.     if (pps->redundant_pic_cnt_present_flag)

  1191.         ue(redundant_pic_cnt, 0, 127);

  1192.     else

  1193.         infer(redundant_pic_cnt, 0);

  1194. 

  1195.     if (current->nal_unit_header.nal_unit_type != H264_NAL_AUXILIARY_SLICE

  1196.         && !current->redundant_pic_cnt)

  1197.         h264->last_slice_nal_unit_type =

  1198.             current->nal_unit_header.nal_unit_type;

  1199. 

  1200.     if (slice_type_b)

  1201.         flag(direct_spatial_mv_pred_flag);

  1202. 

  1203.     if (slice_type_p || slice_type_sp || slice_type_b) {

  1204.         flag(num_ref_idx_active_override_flag);

  1205.         if (current->num_ref_idx_active_override_flag) {

  1206.             ue(num_ref_idx_l0_active_minus1, 0, 31);

  1207.             if (slice_type_b)

  1208.                 ue(num_ref_idx_l1_active_minus1, 0, 31);

  1209.         } else {

  1210.             infer(num_ref_idx_l0_active_minus1,

  1211.                   pps->num_ref_idx_l0_default_active_minus1);

  1212.             infer(num_ref_idx_l1_active_minus1,

  1213.                   pps->num_ref_idx_l1_default_active_minus1);

  1214.         }

  1215.     }

  1216. 

  1217.     if (current->nal_unit_header.nal_unit_type == 20 ||

  1218.         current->nal_unit_header.nal_unit_type == 21) {

  1219.         av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC / 3DAVC not supported.\n");

  1220.         return AVERROR_PATCHWELCOME;

  1221.     } else {

  1222.         CHECK(FUNC(ref_pic_list_modification)(ctx, rw, current));

  1223.     }

  1224. 

  1225.     if ((pps->weighted_pred_flag && (slice_type_p || slice_type_sp)) ||

  1226.         (pps->weighted_bipred_idc == 1 && slice_type_b)) {

  1227.         CHECK(FUNC(pred_weight_table)(ctx, rw, current));

  1228.     }

  1229. 

  1230.     if (current->nal_unit_header.nal_ref_idc != 0) {

  1231.         CHECK(FUNC(dec_ref_pic_marking)(ctx, rw, current, idr_pic_flag));

  1232.     }

  1233. 

  1234.     if (pps->entropy_coding_mode_flag &&

  1235.         !slice_type_i && !slice_type_si) {

  1236.         ue(cabac_init_idc, 0, 2);

  1237.     }

  1238. 

  1239.     se(slice_qp_delta, - 51 - 6 * sps->bit_depth_luma_minus8,

  1240.                        + 51 + 6 * sps->bit_depth_luma_minus8);

  1241.     if (slice_type_sp || slice_type_si) {

  1242.         if (slice_type_sp)

  1243.             flag(sp_for_switch_flag);

  1244.         se(slice_qs_delta, -51, +51);

  1245.     }

  1246. 

  1247.     if (pps->deblocking_filter_control_present_flag) {

  1248.         ue(disable_deblocking_filter_idc, 0, 2);

  1249.         if (current->disable_deblocking_filter_idc != 1) {

  1250.             se(slice_alpha_c0_offset_div2, -6, +6);

  1251.             se(slice_beta_offset_div2,     -6, +6);

  1252.         } else {

  1253.             infer(slice_alpha_c0_offset_div2, 0);

  1254.             infer(slice_beta_offset_div2,     0);

  1255.         }

  1256.     } else {

  1257.         infer(disable_deblocking_filter_idc, 0);

  1258.         infer(slice_alpha_c0_offset_div2,    0);

  1259.         infer(slice_beta_offset_div2,        0);

  1260.     }

  1261. 

  1262.     if (pps->num_slice_groups_minus1 > 0 &&

  1263.         pps->slice_group_map_type >= 3 &&

  1264.         pps->slice_group_map_type <= 5) {

  1265.         unsigned int pic_size, max, bits;

  1266. 

  1267.         pic_size = (sps->pic_width_in_mbs_minus1 + 1) *

  1268.                    (sps->pic_height_in_map_units_minus1 + 1);

  1269.         max = (pic_size + pps->slice_group_change_rate_minus1) /

  1270.               (pps->slice_group_change_rate_minus1 + 1);

  1271.         bits = av_ceil_log2(max + 1);

  1272. 

  1273.         u(bits, slice_group_change_cycle, 0, max);

  1274.     }

  1275. 

  1276.     if (pps->entropy_coding_mode_flag) {

  1277.         while (byte_alignment(rw))

  1278.             fixed(1, cabac_alignment_one_bit, 1);

  1279.     }

  1280. 

  1281.     return 0;

  1282. }

  1283. 

  1284. static int FUNC(filler)(CodedBitstreamContext *ctx, RWContext *rw,

  1285.                         H264RawFiller *current)

  1286. {

  1287.     int err;

  1288. 

  1289.     HEADER("Filler Data");

  1290. 

  1291.     CHECK(FUNC(nal_unit_header)(ctx, rw, &current->nal_unit_header,

  1292.                                 1 << H264_NAL_FILLER_DATA));

  1293. 

  1294. #ifdef READ

  1295.     while (show_bits(rw, 8) == 0xff) {

  1296.         fixed(8, ff_byte, 0xff);

  1297.         ++current->filler_size;

  1298.     }

  1299. #else

  1300.     {

  1301.         uint32_t i;

  1302.         for (i = 0; i < current->filler_size; i++)

  1303.             fixed(8, ff_byte, 0xff);

  1304.     }

  1305. #endif

  1306. 

  1307.     CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));

  1308. 

  1309.     return 0;

  1310. }

  1311. 

  1312. static int FUNC(end_of_sequence)(CodedBitstreamContext *ctx, RWContext *rw,

  1313.                                  H264RawNALUnitHeader *current)

  1314. {

  1315.     HEADER("End of Sequence");

  1316. 

  1317.     return FUNC(nal_unit_header)(ctx, rw, current,

  1318.                                  1 << H264_NAL_END_SEQUENCE);

  1319. }

  1320. 

  1321. static int FUNC(end_of_stream)(CodedBitstreamContext *ctx, RWContext *rw,

  1322.                                H264RawNALUnitHeader *current)

  1323. {

  1324.     HEADER("End of Stream");

  1325. 

  1326.     return FUNC(nal_unit_header)(ctx, rw, current,

  1327.                                  1 << H264_NAL_END_STREAM);

  1328. }