LCOV - code coverage report
Current view: top level - libavcodec - cbs_h264_syntax_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 421 697 60.4 %
Date: 2018-02-23 01:21:18 Functions: 30 46 65.2 %

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

Generated by: LCOV version 1.13