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.
44836 Commits
32 Branches
844MB
Tree: acf06f4544
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'acf06f4544'
${ noResults }
FFmpeg/libavcodec/cbs_h264_syntax_template.c

1231 lines
41KB
Raw Blame History 

  1. /*

  2.  * This file is part of Libav.

  3.  *

  4.  * Libav 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.  * Libav 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 Libav; 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.     av_unused int one = 1, zero = 0;

  23.     xu(1, rbsp_stop_one_bit, one, 1, 1);

  24.     while (byte_alignment(rw) != 0)

  25.         xu(1, rbsp_alignment_zero_bit, zero, 0, 0);

  26. 

  27.     return 0;

  28. }

  29. 

  30. static int FUNC(nal_unit_header)(CodedBitstreamContext *ctx, RWContext *rw,

  31.                                  H264RawNALUnitHeader *current,

  32.                                  uint32_t valid_type_mask)

  33. {

  34.     int err;

  35. 

  36.     u(1, forbidden_zero_bit, 0, 0);

  37.     u(2, nal_ref_idc,        0, 3);

  38.     u(5, nal_unit_type,      0, 31);

  39. 

  40.     if (!(1 << current->nal_unit_type & valid_type_mask)) {

  41.         av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid NAL unit type %d.\n",

  42.                current->nal_unit_type);

  43.         return AVERROR_INVALIDDATA;

  44.     }

  45. 

  46.     if (current->nal_unit_type == 14 ||

  47.         current->nal_unit_type == 20 ||

  48.         current->nal_unit_type == 21) {

  49.         if (current->nal_unit_type != 21)

  50.             flag(svc_extension_flag);

  51.         else

  52.             flag(avc_3d_extension_flag);

  53. 

  54.         if (current->svc_extension_flag) {

  55.             av_log(ctx->log_ctx, AV_LOG_ERROR, "SVC not supported.\n");

  56.             return AVERROR_PATCHWELCOME;

  57. 

  58.         } else if (current->avc_3d_extension_flag) {

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

  60.             return AVERROR_PATCHWELCOME;

  61. 

  62.         } else {

  63.             av_log(ctx->log_ctx, AV_LOG_ERROR, "MVC not supported.\n");

  64.             return AVERROR_PATCHWELCOME;

  65.         }

  66.     }

  67. 

  68.     return 0;

  69. }

  70. 

  71. static int FUNC(scaling_list)(CodedBitstreamContext *ctx, RWContext *rw,

  72.                               H264RawScalingList *current,

  73.                               int size_of_scaling_list)

  74. {

  75.     int err, i, scale;

  76. 

  77.     scale = 8;

  78.     for (i = 0; i < size_of_scaling_list; i++) {

  79.         xse(delta_scale, current->delta_scale[i], -128, +127);

  80.         scale = (scale + current->delta_scale[i] + 256) % 256;

  81.         if (scale == 0)

  82.             break;

  83.     }

  84. 

  85.     return 0;

  86. }

  87. 

  88. static int FUNC(hrd_parameters)(CodedBitstreamContext *ctx, RWContext *rw,

  89.                                 H264RawHRD *current)

  90. {

  91.     int err, i;

  92. 

  93.     ue(cpb_cnt_minus1, 0, 31);

  94.     u(4, bit_rate_scale, 0, 15);

  95.     u(4, cpb_size_scale, 0, 15);

  96. 

  97.     for (i = 0; i <= current->cpb_cnt_minus1; i++) {

  98.         ue(bit_rate_value_minus1[i], 0, UINT32_MAX - 1);

  99.         ue(cpb_size_value_minus1[i], 0, UINT32_MAX - 1);

  100.         flag(cbr_flag[i]);

  101.     }

  102. 

  103.     u(5, initial_cpb_removal_delay_length_minus1, 0, 31);

  104.     u(5, cpb_removal_delay_length_minus1,         0, 31);

  105.     u(5, dpb_output_delay_length_minus1,          0, 31);

  106.     u(5, time_offset_length,                      0, 31);

  107. 

  108.     return 0;

  109. }

  110. 

  111. static int FUNC(vui_parameters)(CodedBitstreamContext *ctx, RWContext *rw,

  112.                                 H264RawVUI *current, H264RawSPS *sps)

  113. {

  114.     int err;

  115. 

  116.     flag(aspect_ratio_info_present_flag);

  117.     if (current->aspect_ratio_info_present_flag) {

  118.         u(8, aspect_ratio_idc, 0, 255);

  119.         if (current->aspect_ratio_idc == 255) {

  120.             u(16, sar_width,  0, 65535);

  121.             u(16, sar_height, 0, 65535);

  122.         }

  123.     } else {

  124.         infer(aspect_ratio_idc, 0);

  125.     }

  126. 

  127.     flag(overscan_info_present_flag);

  128.     if (current->overscan_info_present_flag)

  129.         flag(overscan_appropriate_flag);

  130. 

  131.     flag(video_signal_type_present_flag);

  132.     if (current->video_signal_type_present_flag) {

  133.         u(3, video_format, 0, 7);

  134.         flag(video_full_range_flag);

  135.         flag(colour_description_present_flag);

  136.         if (current->colour_description_present_flag) {

  137.             u(8, colour_primaries,         0, 255);

  138.             u(8, transfer_characteristics, 0, 255);

  139.             u(8, matrix_coefficients,      0, 255);

  140.         }

  141.     } else {

  142.         infer(video_format,             5);

  143.         infer(video_full_range_flag,    0);

  144.         infer(colour_primaries,         2);

  145.         infer(transfer_characteristics, 2);

  146.         infer(matrix_coefficients,      2);

  147.     }

  148. 

  149.     flag(chroma_loc_info_present_flag);

  150.     if (current->chroma_loc_info_present_flag) {

  151.         ue(chroma_sample_loc_type_top_field,    0, 5);

  152.         ue(chroma_sample_loc_type_bottom_field, 0, 5);

  153.     } else {

  154.         infer(chroma_sample_loc_type_top_field,    0);

  155.         infer(chroma_sample_loc_type_bottom_field, 0);

  156.     }

  157. 

  158.     flag(timing_info_present_flag);

  159.     if (current->timing_info_present_flag) {

  160.         u(32, num_units_in_tick, 1, UINT32_MAX);

  161.         u(32, time_scale,        1, UINT32_MAX);

  162.         flag(fixed_frame_rate_flag);

  163.     } else {

  164.         infer(fixed_frame_rate_flag, 0);

  165.     }

  166. 

  167.     flag(nal_hrd_parameters_present_flag);

  168.     if (current->nal_hrd_parameters_present_flag)

  169.         CHECK(FUNC(hrd_parameters)(ctx, rw, &current->nal_hrd_parameters));

  170. 

  171.     flag(vcl_hrd_parameters_present_flag);

  172.     if (current->vcl_hrd_parameters_present_flag)

  173.         CHECK(FUNC(hrd_parameters)(ctx, rw, &current->vcl_hrd_parameters));

  174. 

  175.     if (current->nal_hrd_parameters_present_flag ||

  176.         current->vcl_hrd_parameters_present_flag)

  177.         flag(low_delay_hrd_flag);

  178.     else

  179.         infer(low_delay_hrd_flag, 1 - current->fixed_frame_rate_flag);

  180. 

  181.     flag(pic_struct_present_flag);

  182. 

  183.     flag(bitstream_restriction_flag);

  184.     if (current->bitstream_restriction_flag) {

  185.         flag(motion_vectors_over_pic_boundaries_flag);

  186.         ue(max_bytes_per_pic_denom, 0, 16);

  187.         ue(max_bits_per_mb_denom,   0, 16);

  188.         ue(log2_max_mv_length_horizontal, 0, 16);

  189.         ue(log2_max_mv_length_vertical,   0, 16);

  190.         ue(max_num_reorder_frames,  0, H264_MAX_DPB_FRAMES);

  191.         ue(max_dec_frame_buffering, 0, H264_MAX_DPB_FRAMES);

  192.     } else {

  193.         infer(motion_vectors_over_pic_boundaries_flag, 1);

  194.         infer(max_bytes_per_pic_denom, 2);

  195.         infer(max_bits_per_mb_denom,   1);

  196.         infer(log2_max_mv_length_horizontal, 16);

  197.         infer(log2_max_mv_length_vertical,   16);

  198. 

  199.         if ((sps->profile_idc ==  44 || sps->profile_idc ==  86 ||

  200.              sps->profile_idc == 110 || sps->profile_idc == 110 ||

  201.              sps->profile_idc == 122 || sps->profile_idc == 244) &&

  202.             sps->constraint_set3_flag) {

  203.             infer(max_num_reorder_frames,  0);

  204.             infer(max_dec_frame_buffering, 0);

  205.         } else {

  206.             infer(max_num_reorder_frames,  H264_MAX_DPB_FRAMES);

  207.             infer(max_dec_frame_buffering, H264_MAX_DPB_FRAMES);

  208.         }

  209.     }

  210. 

  211.     return 0;

  212. }

  213. 

  214. static int FUNC(sps)(CodedBitstreamContext *ctx, RWContext *rw,

  215.                      H264RawSPS *current)

  216. {

  217.     int err, i;

  218. 

  219.     HEADER("Sequence Parameter Set");

  220. 

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

  222.                                 1 << H264_NAL_SPS));

  223. 

  224.     u(8, profile_idc, 0, 255);

  225. 

  226.     flag(constraint_set0_flag);

  227.     flag(constraint_set1_flag);

  228.     flag(constraint_set2_flag);

  229.     flag(constraint_set3_flag);

  230.     flag(constraint_set4_flag);

  231.     flag(constraint_set5_flag);

  232. 

  233.     u(2, reserved_zero_2bits,  0, 0);

  234. 

  235.     u(8, level_idc, 0, 255);

  236. 

  237.     ue(seq_parameter_set_id, 0, 31);

  238. 

  239.     if (current->profile_idc == 100 || current->profile_idc == 110 ||

  240.         current->profile_idc == 122 || current->profile_idc == 244 ||

  241.         current->profile_idc ==  44 || current->profile_idc ==  83 ||

  242.         current->profile_idc ==  86 || current->profile_idc == 118 ||

  243.         current->profile_idc == 128 || current->profile_idc == 138) {

  244.         ue(chroma_format_idc, 0, 3);

  245. 

  246.         if (current->chroma_format_idc == 3)

  247.             flag(separate_colour_plane_flag);

  248.         else

  249.             infer(separate_colour_plane_flag, 0);

  250. 

  251.         ue(bit_depth_luma_minus8,   0, 6);

  252.         ue(bit_depth_chroma_minus8, 0, 6);

  253. 

  254.         flag(qpprime_y_zero_transform_bypass_flag);

  255. 

  256.         flag(seq_scaling_matrix_present_flag);

  257.         if (current->seq_scaling_matrix_present_flag) {

  258.             for (i = 0; i < ((current->chroma_format_idc != 3) ? 8 : 12); i++) {

  259.                 flag(seq_scaling_list_present_flag[i]);

  260.                 if (current->seq_scaling_list_present_flag[i]) {

  261.                     if (i < 6)

  262.                         CHECK(FUNC(scaling_list)(ctx, rw,

  263.                                                  &current->scaling_list_4x4[i],

  264.                                                  16));

  265.                     else

  266.                         CHECK(FUNC(scaling_list)(ctx, rw,

  267.                                                  &current->scaling_list_8x8[i - 6],

  268.                                                  64));

  269.                 }

  270.             }

  271.         }

  272.     } else {

  273.         infer(chroma_format_idc, current->profile_idc == 183 ? 0 : 1);

  274. 

  275.         infer(separate_colour_plane_flag, 0);

  276.         infer(bit_depth_luma_minus8,      0);

  277.         infer(bit_depth_chroma_minus8,    0);

  278.     }

  279. 

  280.     ue(log2_max_frame_num_minus4, 0, 12);

  281.     ue(pic_order_cnt_type, 0, 2);

  282. 

  283.     if (current->pic_order_cnt_type == 0) {

  284.         ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);

  285.     } else if (current->pic_order_cnt_type == 1) {

  286.         flag(delta_pic_order_always_zero_flag);

  287.         se(offset_for_non_ref_pic,         INT32_MIN + 1, INT32_MAX);

  288.         se(offset_for_top_to_bottom_field, INT32_MIN + 1, INT32_MAX);

  289.         ue(num_ref_frames_in_pic_order_cnt_cycle, 0, 255);

  290. 

  291.         for (i = 0; i < current->num_ref_frames_in_pic_order_cnt_cycle; i++)

  292.             se(offset_for_ref_frame[i], INT32_MIN + 1, INT32_MAX);

  293.     }

  294. 

  295.     ue(max_num_ref_frames, 0, H264_MAX_DPB_FRAMES);

  296.     flag(gaps_in_frame_num_allowed_flag);

  297. 

  298.     ue(pic_width_in_mbs_minus1,        0, H264_MAX_MB_WIDTH);

  299.     ue(pic_height_in_map_units_minus1, 0, H264_MAX_MB_HEIGHT);

  300. 

  301.     flag(frame_mbs_only_flag);

  302.     if (!current->frame_mbs_only_flag)

  303.         flag(mb_adaptive_frame_field_flag);

  304. 

  305.     flag(direct_8x8_inference_flag);

  306. 

  307.     flag(frame_cropping_flag);

  308.     if (current->frame_cropping_flag) {

  309.         ue(frame_crop_left_offset,   0, H264_MAX_WIDTH);

  310.         ue(frame_crop_right_offset,  0, H264_MAX_WIDTH);

  311.         ue(frame_crop_top_offset,    0, H264_MAX_HEIGHT);

  312.         ue(frame_crop_bottom_offset, 0, H264_MAX_HEIGHT);

  313.     }

  314. 

  315.     flag(vui_parameters_present_flag);

  316.     if (current->vui_parameters_present_flag)

  317.         CHECK(FUNC(vui_parameters)(ctx, rw, &current->vui, current));

  318. 

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

  320. 

  321.     return 0;

  322. }

  323. 

  324. static int FUNC(sps_extension)(CodedBitstreamContext *ctx, RWContext *rw,

  325.                                H264RawSPSExtension *current)

  326. {

  327.     int err;

  328. 

  329.     HEADER("Sequence Parameter Set Extension");

  330. 

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

  332.                                 1 << H264_NAL_SPS_EXT));

  333. 

  334.     ue(seq_parameter_set_id, 0, 31);

  335. 

  336.     ue(aux_format_idc, 0, 3);

  337. 

  338.     if (current->aux_format_idc != 0) {

  339.         int bits;

  340. 

  341.         ue(bit_depth_aux_minus8, 0, 4);

  342.         flag(alpha_incr_flag);

  343. 

  344.         bits = current->bit_depth_aux_minus8 + 9;

  345.         u(bits, alpha_opaque_value,      0, (1 << bits) - 1);

  346.         u(bits, alpha_transparent_value, 0, (1 << bits) - 1);

  347.     }

  348. 

  349.     flag(additional_extension_flag);

  350. 

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

  352. 

  353.     return 0;

  354. }

  355. 

  356. static int FUNC(pps)(CodedBitstreamContext *ctx, RWContext *rw,

  357.                      H264RawPPS *current)

  358. {

  359.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  360.     const H264RawSPS *sps;

  361.     int err, i;

  362. 

  363.     HEADER("Picture Parameter Set");

  364. 

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

  366.                                 1 << H264_NAL_PPS));

  367. 

  368.     ue(pic_parameter_set_id, 0, 255);

  369.     ue(seq_parameter_set_id, 0, 31);

  370. 

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

  372.     if (!sps) {

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

  374.                current->seq_parameter_set_id);

  375.         return AVERROR_INVALIDDATA;

  376.     }

  377. 

  378.     flag(entropy_coding_mode_flag);

  379.     flag(bottom_field_pic_order_in_frame_present_flag);

  380. 

  381.     ue(num_slice_groups_minus1, 0, 7);

  382.     if (current->num_slice_groups_minus1 > 0) {

  383.         unsigned int pic_size;

  384.         int iGroup;

  385. 

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

  387.                    (sps->pic_height_in_map_units_minus1 + 1);

  388. 

  389.         ue(slice_group_map_type, 0, 6);

  390. 

  391.         if (current->slice_group_map_type == 0) {

  392.             for (iGroup = 0; iGroup <= current->num_slice_groups_minus1; iGroup++)

  393.                 ue(run_length_minus1[iGroup], 0, pic_size - 1);

  394. 

  395.         } else if (current->slice_group_map_type == 2) {

  396.             for (iGroup = 0; iGroup < current->num_slice_groups_minus1; iGroup++) {

  397.                 ue(top_left[iGroup],     0,                         pic_size - 1);

  398.                 ue(bottom_right[iGroup], current->top_left[iGroup], pic_size - 1);

  399.             }

  400.         } else if (current->slice_group_map_type == 3 ||

  401.                    current->slice_group_map_type == 4 ||

  402.                    current->slice_group_map_type == 5) {

  403.             flag(slice_group_change_direction_flag);

  404.             ue(slice_group_change_rate_minus1, 0, pic_size - 1);

  405.         } else if (current->slice_group_map_type == 6) {

  406.             ue(pic_size_in_map_units_minus1, pic_size - 1, pic_size - 1);

  407.             for (i = 0; i <= current->pic_size_in_map_units_minus1; i++)

  408.                 u(av_log2(2 * current->num_slice_groups_minus1 + 1),

  409.                   slice_group_id[i], 0, current->num_slice_groups_minus1);

  410.         }

  411.     }

  412. 

  413.     ue(num_ref_idx_l0_default_active_minus1, 0, 31);

  414.     ue(num_ref_idx_l1_default_active_minus1, 0, 31);

  415. 

  416.     flag(weighted_pred_flag);

  417.     u(2, weighted_bipred_idc, 0, 2);

  418. 

  419.     se(pic_init_qp_minus26, -26 - 6 * sps->bit_depth_luma_minus8, +25);

  420.     se(pic_init_qs_minus26, -26, +25);

  421.     se(chroma_qp_index_offset, -12, +12);

  422. 

  423.     flag(deblocking_filter_control_present_flag);

  424.     flag(constrained_intra_pred_flag);

  425.     flag(redundant_pic_cnt_present_flag);

  426. 

  427.     if (more_rbsp_data(current->more_rbsp_data))

  428.     {

  429.         flag(transform_8x8_mode_flag);

  430. 

  431.         flag(pic_scaling_matrix_present_flag);

  432.         if (current->pic_scaling_matrix_present_flag) {

  433.             for (i = 0; i < 6 + (((sps->chroma_format_idc != 3) ? 2 : 6) *

  434.                                  current->transform_8x8_mode_flag); i++) {

  435.                 flag(pic_scaling_list_present_flag[i]);

  436.                 if (current->pic_scaling_list_present_flag[i]) {

  437.                     if (i < 6)

  438.                         CHECK(FUNC(scaling_list)(ctx, rw,

  439.                                                  &current->scaling_list_4x4[i],

  440.                                                  16));

  441.                     else

  442.                         CHECK(FUNC(scaling_list)(ctx, rw,

  443.                                                  &current->scaling_list_8x8[i - 6],

  444.                                                  64));

  445.                 }

  446.             }

  447.         }

  448. 

  449.         se(second_chroma_qp_index_offset, -12, +12);

  450.     } else {

  451.         infer(transform_8x8_mode_flag, 0);

  452.         infer(pic_scaling_matrix_present_flag, 0);

  453.         infer(second_chroma_qp_index_offset, current->chroma_qp_index_offset);

  454.     }

  455. 

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

  457. 

  458.     return 0;

  459. }

  460. 

  461. static int FUNC(sei_buffering_period)(CodedBitstreamContext *ctx, RWContext *rw,

  462.                                       H264RawSEIBufferingPeriod *current)

  463. {

  464.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  465.     const H264RawSPS *sps;

  466.     int err, i, length;

  467. 

  468.     ue(seq_parameter_set_id, 0, 31);

  469. 

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

  471.     if (!sps) {

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

  473.                current->seq_parameter_set_id);

  474.         return AVERROR_INVALIDDATA;

  475.     }

  476.     h264->active_sps = sps;

  477. 

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

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

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

  481.             xu(length, initial_cpb_removal_delay[SchedSelIdx],

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

  483.                0, (1 << (uint64_t)length) - 1);

  484.             xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],

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

  486.                0, (1 << (uint64_t)length) - 1);

  487.         }

  488.     }

  489. 

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

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

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

  493.             xu(length, initial_cpb_removal_delay[SchedSelIdx],

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

  495.                0, (1 << (uint64_t)length) - 1);

  496.             xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],

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

  498.                0, (1 << (uint64_t)length) - 1);

  499.         }

  500.     }

  501. 

  502.     return 0;

  503. }

  504. 

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

  506.                                    H264RawSEIPicTimestamp *current)

  507. {

  508.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  509.     const H264RawSPS *sps;

  510.     uint8_t time_offset_length;

  511.     int err;

  512. 

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

  514.     flag(nuit_field_based_flag);

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

  516.     flag(full_timestamp_flag);

  517.     flag(discontinuity_flag);

  518.     flag(cnt_dropped_flag);

  519.     u(8, n_frames, 0, 255);

  520.     if (current->full_timestamp_flag) {

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

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

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

  524.     } else {

  525.         flag(seconds_flag);

  526.         if (current->seconds_flag) {

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

  528.             flag(minutes_flag);

  529.             if (current->minutes_flag) {

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

  531.                 flag(hours_flag);

  532.                 if (current->hours_flag)

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

  534.             }

  535.         }

  536.     }

  537. 

  538.     sps = h264->active_sps;

  539.     if (sps->vui.nal_hrd_parameters_present_flag)

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

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

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

  543.     else

  544.         time_offset_length = 24;

  545. 

  546.     if (time_offset_length > 0)

  547.         u(time_offset_length, time_offset,

  548.           0, (1 << (uint64_t)time_offset_length) - 1);

  549.     else

  550.         infer(time_offset, 0);

  551. 

  552.     return 0;

  553. }

  554. 

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

  556.                                 H264RawSEIPicTiming *current)

  557. {

  558.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  559.     const H264RawSPS *sps;

  560.     int err;

  561. 

  562.     sps = h264->active_sps;

  563.     if (!sps) {

  564.         av_log(ctx->log_ctx, AV_LOG_ERROR,

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

  566.         return AVERROR_INVALIDDATA;

  567.     }

  568. 

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

  570.         sps->vui.vcl_hrd_parameters_present_flag) {

  571.         const H264RawHRD *hrd;

  572. 

  573.         if (sps->vui.nal_hrd_parameters_present_flag)

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

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

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

  577.         else {

  578.             av_log(ctx->log_ctx, AV_LOG_ERROR,

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

  580.             return AVERROR_INVALIDDATA;

  581.         }

  582. 

  583.         u(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay,

  584.           0, (1 << (uint64_t)hrd->cpb_removal_delay_length_minus1) + 1);

  585.         u(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay,

  586.           0, (1 << (uint64_t)hrd->dpb_output_delay_length_minus1) + 1);

  587.     }

  588. 

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

  590.         static const int num_clock_ts[9] = {

  591.             1, 1, 1, 2, 2, 3, 3, 2, 3

  592.         };

  593.         int i;

  594. 

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

  596.         if (current->pic_struct > 8)

  597.             return AVERROR_INVALIDDATA;

  598. 

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

  600.             flag(clock_timestamp_flag[i]);

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

  602.                 CHECK(FUNC(sei_pic_timestamp)(ctx, rw, &current->timestamp[i]));

  603.         }

  604.     }

  605. 

  606.     return 0;

  607. }

  608. 

  609. static int FUNC(sei_user_data_registered)(CodedBitstreamContext *ctx, RWContext *rw,

  610.                                           H264RawSEIUserDataRegistered *current,

  611.                                           uint32_t *payload_size)

  612. {

  613.     int err, i, j;

  614. 

  615.     u(8, itu_t_t35_country_code, 0x00, 0xff);

  616.     if (current->itu_t_t35_country_code != 0xff)

  617.         i = 1;

  618.     else {

  619.         u(8, itu_t_t35_country_code_extension_byte, 0x00, 0xff);

  620.         i = 2;

  621.     }

  622. 

  623. #ifdef READ

  624.     if (*payload_size < i) {

  625.         av_log(ctx->log_ctx, AV_LOG_ERROR,

  626.                "Invalid SEI user data registered payload.\n");

  627.         return AVERROR_INVALIDDATA;

  628.     }

  629.     current->data_length = *payload_size - i;

  630. #else

  631.     *payload_size = i + current->data_length;

  632. #endif

  633. 

  634.     allocate(current->data, current->data_length);

  635.     for (j = 0; j < current->data_length; j++)

  636.         xu(8, itu_t_t35_payload_byte, current->data[j], 0x00, 0xff);

  637. 

  638.     return 0;

  639. }

  640. 

  641. static int FUNC(sei_user_data_unregistered)(CodedBitstreamContext *ctx, RWContext *rw,

  642.                                             H264RawSEIUserDataUnregistered *current,

  643.                                             uint32_t *payload_size)

  644. {

  645.     int err, i;

  646. 

  647. #ifdef READ

  648.     if (*payload_size < 16) {

  649.         av_log(ctx->log_ctx, AV_LOG_ERROR,

  650.                "Invalid SEI user data unregistered payload.\n");

  651.         return AVERROR_INVALIDDATA;

  652.     }

  653.     current->data_length = *payload_size - 16;

  654. #else

  655.     *payload_size = 16 + current->data_length;

  656. #endif

  657. 

  658.     for (i = 0; i < 16; i++) {

  659.         xu(8, uuid_iso_iec_11578,

  660.            current->uuid_iso_iec_11578[i], 0x00, 0xff);

  661.     }

  662. 

  663.     allocate(current->data, current->data_length);

  664. 

  665.     for (i = 0; i < current->data_length; i++)

  666.         xu(8, user_data_payload_byte, current->data[i], 0x00, 0xff);

  667. 

  668.     return 0;

  669. }

  670. 

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

  672.                                     H264RawSEIRecoveryPoint *current)

  673. {

  674.     int err;

  675. 

  676.     ue(recovery_frame_cnt, 0, 65535);

  677.     flag(exact_match_flag);

  678.     flag(broken_link_flag);

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

  680. 

  681.     return 0;

  682. }

  683. 

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

  685.                                          H264RawSEIDisplayOrientation *current)

  686. {

  687.     int err;

  688. 

  689.     flag(display_orientation_cancel_flag);

  690.     if (!current->display_orientation_cancel_flag) {

  691.         flag(hor_flip);

  692.         flag(ver_flip);

  693.         u(16, anticlockwise_rotation, 0, 65535);

  694.         ue(display_orientation_repetition_period, 0, 16384);

  695.         flag(display_orientation_extension_flag);

  696.     }

  697. 

  698.     return 0;

  699. }

  700. 

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

  702.                              H264RawSEIPayload *current)

  703. {

  704.     int err, i;

  705.     int start_position, end_position;

  706. 

  707. #ifdef READ

  708.     start_position = bitstream_tell(rw);

  709. #else

  710.     start_position = put_bits_count(rw);

  711. #endif

  712. 

  713.     switch (current->payload_type) {

  714.     case H264_SEI_TYPE_BUFFERING_PERIOD:

  715.         CHECK(FUNC(sei_buffering_period)

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

  717.         break;

  718.     case H264_SEI_TYPE_PIC_TIMING:

  719.         CHECK(FUNC(sei_pic_timing)

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

  721.         break;

  722.     case H264_SEI_TYPE_FILLER_PAYLOAD:

  723.         {

  724.             av_unused int ff_byte = 0xff;

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

  726.                 xu(8, ff_byte, ff_byte, 0xff, 0xff);

  727.         }

  728.         break;

  729.     case H264_SEI_TYPE_USER_DATA_REGISTERED:

  730.         CHECK(FUNC(sei_user_data_registered)

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

  732.         break;

  733.     case H264_SEI_TYPE_USER_DATA_UNREGISTERED:

  734.         CHECK(FUNC(sei_user_data_unregistered)

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

  736.         break;

  737.     case H264_SEI_TYPE_RECOVERY_POINT:

  738.         CHECK(FUNC(sei_recovery_point)

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

  740.         break;

  741.     case H264_SEI_TYPE_DISPLAY_ORIENTATION:

  742.         CHECK(FUNC(sei_display_orientation)

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

  744.         break;

  745.     default:

  746.         {

  747.             allocate(current->payload.other.data, current->payload_size);

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

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

  750.         }

  751.     }

  752. 

  753.     if (byte_alignment(rw)) {

  754.         av_unused int one = 1, zero = 0;

  755.         xu(1, bit_equal_to_one, one, 1, 1);

  756.         while (byte_alignment(rw))

  757.             xu(1, bit_equal_to_zero, zero, 0, 0);

  758.     }

  759. 

  760. #ifdef READ

  761.     end_position = bitstream_tell(rw);

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

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

  764.                "header %d bits, actually %d bits.\n",

  765.                8 * current->payload_size,

  766.                end_position - start_position);

  767.         return AVERROR_INVALIDDATA;

  768.     }

  769. #else

  770.     end_position = put_bits_count(rw);

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

  772. #endif

  773. 

  774.     return 0;

  775. }

  776. 

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

  778.                      H264RawSEI *current)

  779. {

  780.     int err, k;

  781. 

  782.     HEADER("Supplemental Enhancement Information");

  783. 

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

  785.                                 1 << H264_NAL_SEI));

  786. 

  787. #ifdef READ

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

  789.         uint32_t payload_type = 0;

  790.         uint32_t payload_size = 0;

  791.         uint32_t tmp;

  792. 

  793.         while (bitstream_peek(rw, 8) == 0xff) {

  794.             xu(8, ff_byte, tmp, 0xff, 0xff);

  795.             payload_type += 255;

  796.         }

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

  798.         payload_type += tmp;

  799. 

  800.         while (bitstream_peek(rw, 8) == 0xff) {

  801.             xu(8, ff_byte, tmp, 0xff, 0xff);

  802.             payload_size += 255;

  803.         }

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

  805.         payload_size += tmp;

  806. 

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

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

  809. 

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

  811. 

  812.         if (!cbs_h2645_read_more_rbsp_data(rw))

  813.             break;

  814.     }

  815.     if (k >= H264_MAX_SEI_PAYLOADS) {

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

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

  818.         return AVERROR_INVALIDDATA;

  819.     }

  820.     current->payload_count = k + 1;

  821. #else

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

  823.         PutBitContext start_state;

  824.         uint32_t tmp;

  825.         int need_size, i;

  826. 

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

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

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

  830.         start_state = *rw;

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

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

  833.             *rw = start_state;

  834. 

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

  836.             while (tmp >= 255) {

  837.                 xu(8, ff_byte, 0xff, 0xff, 0xff);

  838.                 tmp -= 255;

  839.             }

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

  841. 

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

  843.             while (tmp >= 255) {

  844.                 xu(8, ff_byte, 0xff, 0xff, 0xff);

  845.                 tmp -= 255;

  846.             }

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

  848. 

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

  850.         }

  851.     }

  852. #endif

  853. 

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

  855. 

  856.     return 0;

  857. }

  858. 

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

  860.                      H264RawAUD *current)

  861. {

  862.     int err;

  863. 

  864.     HEADER("Access Unit Delimiter");

  865. 

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

  867.                                 1 << H264_NAL_AUD));

  868. 

  869.     u(3, primary_pic_type, 0, 7);

  870. 

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

  872. 

  873.     return 0;

  874. }

  875. 

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

  877.                                            H264RawSliceHeader *current)

  878. {

  879.     CodedBitstreamH264Context *h264 = ctx->priv_data;

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

  881.     int err, i, mopn;

  882. 

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

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

  885.         flag(ref_pic_list_modification_flag_l0);

  886.         if (current->ref_pic_list_modification_flag_l0) {

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

  888.                 xue(modification_of_pic_nums_idc,

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

  890. 

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

  892.                 if (mopn == 3)

  893.                     break;

  894. 

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

  896.                     xue(abs_diff_pic_num_minus1,

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

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

  899.                         (1 << (sps->log2_max_frame_num_minus4 + 4)));

  900.                 else if (mopn == 2)

  901.                     xue(long_term_pic_num,

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

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

  904.             }

  905.         }

  906.     }

  907. 

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

  909.         flag(ref_pic_list_modification_flag_l1);

  910.         if (current->ref_pic_list_modification_flag_l1) {

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

  912.                 xue(modification_of_pic_nums_idc,

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

  914. 

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

  916.                 if (mopn == 3)

  917.                     break;

  918. 

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

  920.                     xue(abs_diff_pic_num_minus1,

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

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

  923.                         (1 << (sps->log2_max_frame_num_minus4 + 4)));

  924.                 else if (mopn == 2)

  925.                     xue(long_term_pic_num,

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

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

  928.             }

  929.         }

  930.     }

  931. 

  932.     return 0;

  933. }

  934. 

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

  936.                                    H264RawSliceHeader *current)

  937. {

  938.     CodedBitstreamH264Context *h264 = ctx->priv_data;

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

  940.     int chroma;

  941.     int err, i, j;

  942. 

  943.     ue(luma_log2_weight_denom, 0, 7);

  944. 

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

  946.     if (chroma)

  947.         ue(chroma_log2_weight_denom, 0, 7);

  948. 

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

  950.         flag(luma_weight_l0_flag[i]);

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

  952.             se(luma_weight_l0[i], -128, +127);

  953.             se(luma_offset_l0[i], -128, +127);

  954.         }

  955.         if (chroma) {

  956.             flag(chroma_weight_l0_flag[i]);

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

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

  959.                     se(chroma_weight_l0[i][j], -128, +127);

  960.                     se(chroma_offset_l0[i][j], -128, +127);

  961.                 }

  962.             }

  963.         }

  964.     }

  965. 

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

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

  968.             flag(luma_weight_l1_flag[i]);

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

  970.                 se(luma_weight_l1[i], -128, +127);

  971.                 se(luma_offset_l1[i], -128, +127);

  972.             }

  973.             if (chroma) {

  974.                 flag(chroma_weight_l1_flag[i]);

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

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

  977.                         se(chroma_weight_l1[i][j], -128, +127);

  978.                         se(chroma_offset_l1[i][j], -128, +127);

  979.                     }

  980.                 }

  981.             }

  982.         }

  983.     }

  984. 

  985.     return 0;

  986. }

  987. 

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

  989.                                      H264RawSliceHeader *current, int idr_pic_flag)

  990. {

  991.     CodedBitstreamH264Context *h264 = ctx->priv_data;

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

  993.     int err, i;

  994.     uint32_t mmco;

  995. 

  996.     if (idr_pic_flag) {

  997.         flag(no_output_of_prior_pics_flag);

  998.         flag(long_term_reference_flag);

  999.     } else {

  1000.         flag(adaptive_ref_pic_marking_mode_flag);

  1001.         if (current->adaptive_ref_pic_marking_mode_flag) {

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

  1003.                 xue(memory_management_control_operation,

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

  1005.                     0, 6);

  1006. 

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

  1008.                 if (mmco == 0)

  1009.                     break;

  1010. 

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

  1012.                     xue(difference_of_pic_nums_minus1,

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

  1014.                         0, INT32_MAX);

  1015.                 if (mmco == 2)

  1016.                     xue(long_term_pic_num,

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

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

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

  1020.                     xue(long_term_frame_idx,

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

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

  1023.                 if (mmco == 4)

  1024.                     xue(max_long_term_frame_idx_plus1,

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

  1026.                         0, sps->max_num_ref_frames);

  1027.             }

  1028.             if (i == H264_MAX_MMCO_COUNT) {

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

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

  1031.                 return AVERROR_INVALIDDATA;

  1032.             }

  1033.         }

  1034.     }

  1035. 

  1036.     return 0;

  1037. }

  1038. 

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

  1040.                               H264RawSliceHeader *current)

  1041. {

  1042.     CodedBitstreamH264Context *h264 = ctx->priv_data;

  1043.     const H264RawSPS *sps;

  1044.     const H264RawPPS *pps;

  1045.     int err;

  1046.     int idr_pic_flag;

  1047.     int slice_type_i, slice_type_p, slice_type_b;

  1048.     int slice_type_si, slice_type_sp;

  1049. 

  1050.     HEADER("Slice Header");

  1051. 

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

  1053.                                 1 << H264_NAL_SLICE     |

  1054.                                 1 << H264_NAL_IDR_SLICE |

  1055.                                 1 << H264_NAL_AUXILIARY_SLICE));

  1056. 

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

  1058.         if (!h264->last_slice_nal_unit_type) {

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

  1060.                    "is not decodable without the main picture "

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

  1062.             return AVERROR_INVALIDDATA;

  1063.         }

  1064.     } else {

  1065.         h264->last_slice_nal_unit_type =

  1066.             current->nal_unit_header.nal_unit_type;

  1067.     }

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

  1069. 

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

  1071.     ue(slice_type, 0, 9);

  1072. 

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

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

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

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

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

  1078. 

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

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

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

  1082.         return AVERROR_INVALIDDATA;

  1083.     }

  1084. 

  1085.     ue(pic_parameter_set_id, 0, 255);

  1086. 

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

  1088.     if (!pps) {

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

  1090.                current->pic_parameter_set_id);

  1091.         return AVERROR_INVALIDDATA;

  1092.     }

  1093.     h264->active_pps = pps;

  1094. 

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

  1096.     if (!sps) {

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

  1098.                pps->seq_parameter_set_id);

  1099.         return AVERROR_INVALIDDATA;

  1100.     }

  1101.     h264->active_sps = sps;

  1102. 

  1103.     if (sps->separate_colour_plane_flag)

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

  1105. 

  1106.     u(sps->log2_max_frame_num_minus4 + 4, frame_num,

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

  1108. 

  1109.     if (!sps->frame_mbs_only_flag) {

  1110.         flag(field_pic_flag);

  1111.         if (current->field_pic_flag)

  1112.             flag(bottom_field_flag);

  1113.         else

  1114.             infer(bottom_field_flag, 0);

  1115.     } else {

  1116.         infer(field_pic_flag,    0);

  1117.         infer(bottom_field_flag, 0);

  1118.     }

  1119. 

  1120.     if (idr_pic_flag)

  1121.         ue(idr_pic_id, 0, 65535);

  1122. 

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

  1124.         u(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb,

  1125.           0, (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1);

  1126.         if (pps->bottom_field_pic_order_in_frame_present_flag &&

  1127.             !current->field_pic_flag)

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

  1129. 

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

  1131.         if (!sps->delta_pic_order_always_zero_flag) {

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

  1133.             if (pps->bottom_field_pic_order_in_frame_present_flag &&

  1134.                 !current->field_pic_flag)

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

  1136.             else

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

  1138.         } else {

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

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

  1141.         }

  1142.     }

  1143. 

  1144.     if (pps->redundant_pic_cnt_present_flag)

  1145.         ue(redundant_pic_cnt, 0, 127);

  1146. 

  1147.     if (slice_type_b)

  1148.         flag(direct_spatial_mv_pred_flag);

  1149. 

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

  1151.         flag(num_ref_idx_active_override_flag);

  1152.         if (current->num_ref_idx_active_override_flag) {

  1153.             ue(num_ref_idx_l0_active_minus1, 0, 31);

  1154.             if (slice_type_b)

  1155.                 ue(num_ref_idx_l1_active_minus1, 0, 31);

  1156.         } else {

  1157.             infer(num_ref_idx_l0_active_minus1,

  1158.                   pps->num_ref_idx_l0_default_active_minus1);

  1159.             infer(num_ref_idx_l1_active_minus1,

  1160.                   pps->num_ref_idx_l1_default_active_minus1);

  1161.         }

  1162.     }

  1163. 

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

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

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

  1167.         return AVERROR_PATCHWELCOME;

  1168.     } else {

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

  1170.     }

  1171. 

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

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

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

  1175.     }

  1176. 

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

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

  1179.     }

  1180. 

  1181.     if (pps->entropy_coding_mode_flag &&

  1182.         !slice_type_i && !slice_type_si) {

  1183.         ue(cabac_init_idc, 0, 2);

  1184.     }

  1185. 

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

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

  1188.     if (slice_type_sp || slice_type_si) {

  1189.         if (slice_type_sp)

  1190.             flag(sp_for_switch_flag);

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

  1192.     }

  1193. 

  1194.     if (pps->deblocking_filter_control_present_flag) {

  1195.         ue(disable_deblocking_filter_idc, 0, 2);

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

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

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

  1199.         } else {

  1200.             infer(slice_alpha_c0_offset_div2, 0);

  1201.             infer(slice_beta_offset_div2,     0);

  1202.         }

  1203.     } else {

  1204.         infer(disable_deblocking_filter_idc, 0);

  1205.         infer(slice_alpha_c0_offset_div2,    0);

  1206.         infer(slice_beta_offset_div2,        0);

  1207.     }

  1208. 

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

  1210.         pps->slice_group_map_type >= 3 &&

  1211.         pps->slice_group_map_type <= 5) {

  1212.         unsigned int pic_size, max, bits;

  1213. 

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

  1215.                    (sps->pic_height_in_map_units_minus1 + 1);

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

  1217.               (pps->slice_group_change_rate_minus1 + 1);

  1218.         bits = av_log2(2 * max - 1);

  1219. 

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

  1221.     }

  1222. 

  1223.     if (pps->entropy_coding_mode_flag) {

  1224.         av_unused int one = 1;

  1225.         while (byte_alignment(rw))

  1226.             xu(1, cabac_alignment_one_bit, one, 1, 1);

  1227.     }

  1228. 

  1229.     return 0;

  1230. }