LCOV - code coverage report
Current view: top level - libavcodec - h264_ps.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 403 497 81.1 %
Date: 2017-12-13 02:34:56 Functions: 14 14 100.0 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
       3             :  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * H.264 / AVC / MPEG-4 part10 parameter set decoding.
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #include <inttypes.h>
      29             : 
      30             : #include "libavutil/imgutils.h"
      31             : #include "internal.h"
      32             : #include "mathops.h"
      33             : #include "avcodec.h"
      34             : #include "h264data.h"
      35             : #include "h264_ps.h"
      36             : #include "golomb.h"
      37             : 
      38             : #define MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
      39             : #define MIN_LOG2_MAX_FRAME_NUM    4
      40             : 
      41             : #define EXTENDED_SAR       255
      42             : 
      43             : static const uint8_t default_scaling4[2][16] = {
      44             :     {  6, 13, 20, 28, 13, 20, 28, 32,
      45             :       20, 28, 32, 37, 28, 32, 37, 42 },
      46             :     { 10, 14, 20, 24, 14, 20, 24, 27,
      47             :       20, 24, 27, 30, 24, 27, 30, 34 }
      48             : };
      49             : 
      50             : static const uint8_t default_scaling8[2][64] = {
      51             :     {  6, 10, 13, 16, 18, 23, 25, 27,
      52             :       10, 11, 16, 18, 23, 25, 27, 29,
      53             :       13, 16, 18, 23, 25, 27, 29, 31,
      54             :       16, 18, 23, 25, 27, 29, 31, 33,
      55             :       18, 23, 25, 27, 29, 31, 33, 36,
      56             :       23, 25, 27, 29, 31, 33, 36, 38,
      57             :       25, 27, 29, 31, 33, 36, 38, 40,
      58             :       27, 29, 31, 33, 36, 38, 40, 42 },
      59             :     {  9, 13, 15, 17, 19, 21, 22, 24,
      60             :       13, 13, 17, 19, 21, 22, 24, 25,
      61             :       15, 17, 19, 21, 22, 24, 25, 27,
      62             :       17, 19, 21, 22, 24, 25, 27, 28,
      63             :       19, 21, 22, 24, 25, 27, 28, 30,
      64             :       21, 22, 24, 25, 27, 28, 30, 32,
      65             :       22, 24, 25, 27, 28, 30, 32, 33,
      66             :       24, 25, 27, 28, 30, 32, 33, 35 }
      67             : };
      68             : 
      69             : /* maximum number of MBs in the DPB for a given level */
      70             : static const int level_max_dpb_mbs[][2] = {
      71             :     { 10, 396       },
      72             :     { 11, 900       },
      73             :     { 12, 2376      },
      74             :     { 13, 2376      },
      75             :     { 20, 2376      },
      76             :     { 21, 4752      },
      77             :     { 22, 8100      },
      78             :     { 30, 8100      },
      79             :     { 31, 18000     },
      80             :     { 32, 20480     },
      81             :     { 40, 32768     },
      82             :     { 41, 32768     },
      83             :     { 42, 34816     },
      84             :     { 50, 110400    },
      85             :     { 51, 184320    },
      86             :     { 52, 184320    },
      87             : };
      88             : 
      89       13767 : static void remove_pps(H264ParamSets *s, int id)
      90             : {
      91       13767 :     av_buffer_unref(&s->pps_list[id]);
      92       13767 : }
      93             : 
      94         765 : static void remove_sps(H264ParamSets *s, int id)
      95             : {
      96             : #if 0
      97             :     int i;
      98             :     if (s->sps_list[id]) {
      99             :         /* drop all PPS that depend on this SPS */
     100             :         for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
     101             :             if (s->pps_list[i] && ((PPS*)s->pps_list[i]->data)->sps_id == id)
     102             :                 remove_pps(s, i);
     103             :     }
     104             : #endif
     105         765 :     av_buffer_unref(&s->sps_list[id]);
     106         765 : }
     107             : 
     108         106 : static inline int decode_hrd_parameters(GetBitContext *gb, AVCodecContext *avctx,
     109             :                                         SPS *sps)
     110             : {
     111             :     int cpb_count, i;
     112         106 :     cpb_count = get_ue_golomb_31(gb) + 1;
     113             : 
     114         106 :     if (cpb_count > 32U) {
     115           0 :         av_log(avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
     116           0 :         return AVERROR_INVALIDDATA;
     117             :     }
     118             : 
     119         106 :     get_bits(gb, 4); /* bit_rate_scale */
     120         106 :     get_bits(gb, 4); /* cpb_size_scale */
     121         212 :     for (i = 0; i < cpb_count; i++) {
     122         106 :         get_ue_golomb_long(gb); /* bit_rate_value_minus1 */
     123         106 :         get_ue_golomb_long(gb); /* cpb_size_value_minus1 */
     124         106 :         get_bits1(gb);          /* cbr_flag */
     125             :     }
     126         106 :     sps->initial_cpb_removal_delay_length = get_bits(gb, 5) + 1;
     127         106 :     sps->cpb_removal_delay_length         = get_bits(gb, 5) + 1;
     128         106 :     sps->dpb_output_delay_length          = get_bits(gb, 5) + 1;
     129         106 :     sps->time_offset_length               = get_bits(gb, 5);
     130         106 :     sps->cpb_cnt                          = cpb_count;
     131         106 :     return 0;
     132             : }
     133             : 
     134         494 : static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx,
     135             :                                         SPS *sps)
     136             : {
     137             :     int aspect_ratio_info_present_flag;
     138             :     unsigned int aspect_ratio_idc;
     139             : 
     140         494 :     aspect_ratio_info_present_flag = get_bits1(gb);
     141             : 
     142         494 :     if (aspect_ratio_info_present_flag) {
     143         159 :         aspect_ratio_idc = get_bits(gb, 8);
     144         159 :         if (aspect_ratio_idc == EXTENDED_SAR) {
     145          22 :             sps->sar.num = get_bits(gb, 16);
     146          22 :             sps->sar.den = get_bits(gb, 16);
     147         137 :         } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
     148         137 :             sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
     149             :         } else {
     150           0 :             av_log(avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
     151           0 :             return AVERROR_INVALIDDATA;
     152             :         }
     153             :     } else {
     154         335 :         sps->sar.num =
     155         335 :         sps->sar.den = 0;
     156             :     }
     157             : 
     158         494 :     if (get_bits1(gb))      /* overscan_info_present_flag */
     159          42 :         get_bits1(gb);      /* overscan_appropriate_flag */
     160             : 
     161         494 :     sps->video_signal_type_present_flag = get_bits1(gb);
     162         494 :     if (sps->video_signal_type_present_flag) {
     163          96 :         get_bits(gb, 3);                 /* video_format */
     164          96 :         sps->full_range = get_bits1(gb); /* video_full_range_flag */
     165             : 
     166          96 :         sps->colour_description_present_flag = get_bits1(gb);
     167          96 :         if (sps->colour_description_present_flag) {
     168          76 :             sps->color_primaries = get_bits(gb, 8); /* colour_primaries */
     169          76 :             sps->color_trc       = get_bits(gb, 8); /* transfer_characteristics */
     170          76 :             sps->colorspace      = get_bits(gb, 8); /* matrix_coefficients */
     171             : 
     172             :             // Set invalid values to "unspecified"
     173          76 :             if (!av_color_primaries_name(sps->color_primaries))
     174           0 :                 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
     175          76 :             if (!av_color_transfer_name(sps->color_trc))
     176           0 :                 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
     177          76 :             if (!av_color_space_name(sps->colorspace))
     178           0 :                 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
     179             :         }
     180             :     }
     181             : 
     182             :     /* chroma_location_info_present_flag */
     183         494 :     if (get_bits1(gb)) {
     184             :         /* chroma_sample_location_type_top_field */
     185          61 :         avctx->chroma_sample_location = get_ue_golomb(gb) + 1;
     186          61 :         get_ue_golomb(gb);  /* chroma_sample_location_type_bottom_field */
     187             :     }
     188             : 
     189         494 :     if (show_bits1(gb) && get_bits_left(gb) < 10) {
     190           0 :         av_log(avctx, AV_LOG_WARNING, "Truncated VUI\n");
     191           0 :         return 0;
     192             :     }
     193             : 
     194         494 :     sps->timing_info_present_flag = get_bits1(gb);
     195         494 :     if (sps->timing_info_present_flag) {
     196         433 :         unsigned num_units_in_tick = get_bits_long(gb, 32);
     197         433 :         unsigned time_scale        = get_bits_long(gb, 32);
     198         433 :         if (!num_units_in_tick || !time_scale) {
     199           0 :             av_log(avctx, AV_LOG_ERROR,
     200             :                    "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
     201             :                    time_scale, num_units_in_tick);
     202           0 :             sps->timing_info_present_flag = 0;
     203             :         } else {
     204         433 :             sps->num_units_in_tick = num_units_in_tick;
     205         433 :             sps->time_scale = time_scale;
     206             :         }
     207         433 :         sps->fixed_frame_rate_flag = get_bits1(gb);
     208             :     }
     209             : 
     210         494 :     sps->nal_hrd_parameters_present_flag = get_bits1(gb);
     211         494 :     if (sps->nal_hrd_parameters_present_flag)
     212          75 :         if (decode_hrd_parameters(gb, avctx, sps) < 0)
     213           0 :             return AVERROR_INVALIDDATA;
     214         494 :     sps->vcl_hrd_parameters_present_flag = get_bits1(gb);
     215         494 :     if (sps->vcl_hrd_parameters_present_flag)
     216          31 :         if (decode_hrd_parameters(gb, avctx, sps) < 0)
     217           0 :             return AVERROR_INVALIDDATA;
     218         913 :     if (sps->nal_hrd_parameters_present_flag ||
     219         419 :         sps->vcl_hrd_parameters_present_flag)
     220          75 :         get_bits1(gb);     /* low_delay_hrd_flag */
     221         494 :     sps->pic_struct_present_flag = get_bits1(gb);
     222         494 :     if (!get_bits_left(gb))
     223           0 :         return 0;
     224         494 :     sps->bitstream_restriction_flag = get_bits1(gb);
     225         494 :     if (sps->bitstream_restriction_flag) {
     226         405 :         get_bits1(gb);     /* motion_vectors_over_pic_boundaries_flag */
     227         405 :         get_ue_golomb(gb); /* max_bytes_per_pic_denom */
     228         405 :         get_ue_golomb(gb); /* max_bits_per_mb_denom */
     229         405 :         get_ue_golomb(gb); /* log2_max_mv_length_horizontal */
     230         405 :         get_ue_golomb(gb); /* log2_max_mv_length_vertical */
     231         405 :         sps->num_reorder_frames = get_ue_golomb(gb);
     232         405 :         get_ue_golomb(gb); /*max_dec_frame_buffering*/
     233             : 
     234         405 :         if (get_bits_left(gb) < 0) {
     235           2 :             sps->num_reorder_frames         = 0;
     236           2 :             sps->bitstream_restriction_flag = 0;
     237             :         }
     238             : 
     239         405 :         if (sps->num_reorder_frames > 16U
     240             :             /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
     241           0 :             av_log(avctx, AV_LOG_ERROR,
     242             :                    "Clipping illegal num_reorder_frames %d\n",
     243             :                    sps->num_reorder_frames);
     244           0 :             sps->num_reorder_frames = 16;
     245           0 :             return AVERROR_INVALIDDATA;
     246             :         }
     247             :     }
     248             : 
     249         494 :     return 0;
     250             : }
     251             : 
     252        2280 : static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
     253             :                                 const uint8_t *jvt_list,
     254             :                                 const uint8_t *fallback_list)
     255             : {
     256        2280 :     int i, last = 8, next = 8;
     257        2280 :     const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
     258        2280 :     if (!get_bits1(gb)) /* matrix not written, we use the predicted one */
     259        1140 :         memcpy(factors, fallback_list, size * sizeof(uint8_t));
     260             :     else
     261       30580 :         for (i = 0; i < size; i++) {
     262       29544 :             if (next) {
     263       27536 :                 int v = get_se_golomb(gb);
     264       27536 :                 if (v < -128 || v > 127) {
     265           0 :                     av_log(NULL, AV_LOG_ERROR, "delta scale %d is invalid\n", v);
     266           0 :                     return AVERROR_INVALIDDATA;
     267             :                 }
     268       27536 :                 next = (last + v) & 0xff;
     269             :             }
     270       29544 :             if (!i && !next) { /* matrix not written, we use the preset one */
     271         104 :                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
     272         104 :                 break;
     273             :             }
     274       29440 :             last = factors[scan[i]] = next ? next : last;
     275             :         }
     276        2280 :     return 0;
     277             : }
     278             : 
     279             : /* returns non zero if the provided SPS scaling matrix has been filled */
     280        1208 : static int decode_scaling_matrices(GetBitContext *gb, const SPS *sps,
     281             :                                     const PPS *pps, int is_sps,
     282             :                                     uint8_t(*scaling_matrix4)[16],
     283             :                                     uint8_t(*scaling_matrix8)[64])
     284             : {
     285        1208 :     int fallback_sps = !is_sps && sps->scaling_matrix_present;
     286        4832 :     const uint8_t *fallback[4] = {
     287        1208 :         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
     288        1208 :         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
     289        1208 :         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
     290        1208 :         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
     291             :     };
     292        1208 :     int ret = 0;
     293        1208 :     if (get_bits1(gb)) {
     294         285 :         ret |= decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
     295         285 :         ret |= decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
     296         285 :         ret |= decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
     297         285 :         ret |= decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
     298         285 :         ret |= decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
     299         285 :         ret |= decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
     300         285 :         if (is_sps || pps->transform_8x8_mode) {
     301         285 :             ret |= decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
     302         285 :             ret |= decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
     303         285 :             if (sps->chroma_format_idc == 3) {
     304           0 :                 ret |= decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
     305           0 :                 ret |= decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
     306           0 :                 ret |= decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
     307           0 :                 ret |= decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
     308             :             }
     309             :         }
     310         285 :         if (!ret)
     311         285 :             ret = is_sps;
     312             :     }
     313             : 
     314        1208 :     return ret;
     315             : }
     316             : 
     317         802 : void ff_h264_ps_uninit(H264ParamSets *ps)
     318             : {
     319             :     int i;
     320             : 
     321       26466 :     for (i = 0; i < MAX_SPS_COUNT; i++)
     322       25664 :         av_buffer_unref(&ps->sps_list[i]);
     323             : 
     324      206114 :     for (i = 0; i < MAX_PPS_COUNT; i++)
     325      205312 :         av_buffer_unref(&ps->pps_list[i]);
     326             : 
     327         802 :     av_buffer_unref(&ps->sps_ref);
     328         802 :     av_buffer_unref(&ps->pps_ref);
     329             : 
     330         802 :     ps->pps = NULL;
     331         802 :     ps->sps = NULL;
     332         802 : }
     333             : 
     334        2052 : int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
     335             :                                      H264ParamSets *ps, int ignore_truncation)
     336             : {
     337             :     AVBufferRef *sps_buf;
     338        2052 :     int profile_idc, level_idc, constraint_set_flags = 0;
     339             :     unsigned int sps_id;
     340             :     int i, log2_max_frame_num_minus4;
     341             :     SPS *sps;
     342             :     int ret;
     343             : 
     344        2052 :     sps_buf = av_buffer_allocz(sizeof(*sps));
     345        2052 :     if (!sps_buf)
     346           0 :         return AVERROR(ENOMEM);
     347        2052 :     sps = (SPS*)sps_buf->data;
     348             : 
     349        2052 :     sps->data_size = gb->buffer_end - gb->buffer;
     350        2052 :     if (sps->data_size > sizeof(sps->data)) {
     351           0 :         av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized SPS\n");
     352           0 :         sps->data_size = sizeof(sps->data);
     353             :     }
     354        2052 :     memcpy(sps->data, gb->buffer, sps->data_size);
     355             : 
     356        2052 :     profile_idc           = get_bits(gb, 8);
     357        2052 :     constraint_set_flags |= get_bits1(gb) << 0;   // constraint_set0_flag
     358        2052 :     constraint_set_flags |= get_bits1(gb) << 1;   // constraint_set1_flag
     359        2052 :     constraint_set_flags |= get_bits1(gb) << 2;   // constraint_set2_flag
     360        2052 :     constraint_set_flags |= get_bits1(gb) << 3;   // constraint_set3_flag
     361        2052 :     constraint_set_flags |= get_bits1(gb) << 4;   // constraint_set4_flag
     362        2052 :     constraint_set_flags |= get_bits1(gb) << 5;   // constraint_set5_flag
     363        2052 :     skip_bits(gb, 2);                             // reserved_zero_2bits
     364        2052 :     level_idc = get_bits(gb, 8);
     365        2052 :     sps_id    = get_ue_golomb_31(gb);
     366             : 
     367        2052 :     if (sps_id >= MAX_SPS_COUNT) {
     368           0 :         av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
     369           0 :         goto fail;
     370             :     }
     371             : 
     372        2052 :     sps->sps_id               = sps_id;
     373        2052 :     sps->time_offset_length   = 24;
     374        2052 :     sps->profile_idc          = profile_idc;
     375        2052 :     sps->constraint_set_flags = constraint_set_flags;
     376        2052 :     sps->level_idc            = level_idc;
     377        2052 :     sps->full_range           = -1;
     378             : 
     379        2052 :     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
     380        2052 :     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
     381        2052 :     sps->scaling_matrix_present = 0;
     382        2052 :     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
     383             : 
     384        3614 :     if (sps->profile_idc == 100 ||  // High profile
     385        3080 :         sps->profile_idc == 110 ||  // High10 profile
     386        2978 :         sps->profile_idc == 122 ||  // High422 profile
     387        2890 :         sps->profile_idc == 244 ||  // High444 Predictive profile
     388        2860 :         sps->profile_idc ==  44 ||  // Cavlc444 profile
     389        2860 :         sps->profile_idc ==  83 ||  // Scalable Constrained High profile (SVC)
     390        2860 :         sps->profile_idc ==  86 ||  // Scalable High Intra profile (SVC)
     391        2860 :         sps->profile_idc == 118 ||  // Stereo High profile (MVC)
     392        2860 :         sps->profile_idc == 128 ||  // Multiview High profile (MVC)
     393        2860 :         sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)
     394        1430 :         sps->profile_idc == 144) {  // old High444 profile
     395         622 :         sps->chroma_format_idc = get_ue_golomb_31(gb);
     396         622 :         if (sps->chroma_format_idc > 3U) {
     397           0 :             avpriv_request_sample(avctx, "chroma_format_idc %u",
     398             :                                   sps->chroma_format_idc);
     399           0 :             goto fail;
     400         622 :         } else if (sps->chroma_format_idc == 3) {
     401          26 :             sps->residual_color_transform_flag = get_bits1(gb);
     402          26 :             if (sps->residual_color_transform_flag) {
     403           0 :                 av_log(avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
     404           0 :                 goto fail;
     405             :             }
     406             :         }
     407         622 :         sps->bit_depth_luma   = get_ue_golomb(gb) + 8;
     408         622 :         sps->bit_depth_chroma = get_ue_golomb(gb) + 8;
     409         622 :         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
     410           0 :             avpriv_request_sample(avctx,
     411             :                                   "Different chroma and luma bit depth");
     412           0 :             goto fail;
     413             :         }
     414        1244 :         if (sps->bit_depth_luma   < 8 || sps->bit_depth_luma   > 14 ||
     415        1244 :             sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
     416           0 :             av_log(avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
     417             :                    sps->bit_depth_luma, sps->bit_depth_chroma);
     418           0 :             goto fail;
     419             :         }
     420         622 :         sps->transform_bypass = get_bits1(gb);
     421         622 :         ret = decode_scaling_matrices(gb, sps, NULL, 1,
     422         622 :                                       sps->scaling_matrix4, sps->scaling_matrix8);
     423         622 :         if (ret < 0)
     424           0 :             goto fail;
     425         622 :         sps->scaling_matrix_present |= ret;
     426             :     } else {
     427        1430 :         sps->chroma_format_idc = 1;
     428        1430 :         sps->bit_depth_luma    = 8;
     429        1430 :         sps->bit_depth_chroma  = 8;
     430             :     }
     431             : 
     432        2052 :     log2_max_frame_num_minus4 = get_ue_golomb(gb);
     433        2052 :     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
     434             :         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
     435           0 :         av_log(avctx, AV_LOG_ERROR,
     436             :                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
     437             :                log2_max_frame_num_minus4);
     438           0 :         goto fail;
     439             :     }
     440        2052 :     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
     441             : 
     442        2052 :     sps->poc_type = get_ue_golomb_31(gb);
     443             : 
     444        2052 :     if (sps->poc_type == 0) { // FIXME #define
     445         970 :         unsigned t = get_ue_golomb(gb);
     446         970 :         if (t>12) {
     447           0 :             av_log(avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
     448           0 :             goto fail;
     449             :         }
     450         970 :         sps->log2_max_poc_lsb = t + 4;
     451        1082 :     } else if (sps->poc_type == 1) { // FIXME #define
     452          76 :         sps->delta_pic_order_always_zero_flag = get_bits1(gb);
     453          76 :         sps->offset_for_non_ref_pic           = get_se_golomb(gb);
     454          76 :         sps->offset_for_top_to_bottom_field   = get_se_golomb(gb);
     455          76 :         sps->poc_cycle_length                 = get_ue_golomb(gb);
     456             : 
     457          76 :         if ((unsigned)sps->poc_cycle_length >=
     458             :             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
     459           0 :             av_log(avctx, AV_LOG_ERROR,
     460             :                    "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
     461           0 :             goto fail;
     462             :         }
     463             : 
     464         176 :         for (i = 0; i < sps->poc_cycle_length; i++)
     465         100 :             sps->offset_for_ref_frame[i] = get_se_golomb(gb);
     466        1006 :     } else if (sps->poc_type != 2) {
     467           0 :         av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
     468           0 :         goto fail;
     469             :     }
     470             : 
     471        2052 :     sps->ref_frame_count = get_ue_golomb_31(gb);
     472        2052 :     if (avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
     473           0 :         sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
     474        2052 :     if (sps->ref_frame_count > MAX_DELAYED_PIC_COUNT) {
     475           0 :         av_log(avctx, AV_LOG_ERROR,
     476             :                "too many reference frames %d\n", sps->ref_frame_count);
     477           0 :         goto fail;
     478             :     }
     479        2052 :     sps->gaps_in_frame_num_allowed_flag = get_bits1(gb);
     480        2052 :     sps->mb_width                       = get_ue_golomb(gb) + 1;
     481        2052 :     sps->mb_height                      = get_ue_golomb(gb) + 1;
     482             : 
     483        2052 :     sps->frame_mbs_only_flag = get_bits1(gb);
     484             : 
     485        2052 :     if (sps->mb_height >= INT_MAX / 2U) {
     486           0 :         av_log(avctx, AV_LOG_ERROR, "height overflow\n");
     487           0 :         goto fail;
     488             :     }
     489        2052 :     sps->mb_height *= 2 - sps->frame_mbs_only_flag;
     490             : 
     491        2052 :     if (!sps->frame_mbs_only_flag)
     492         465 :         sps->mb_aff = get_bits1(gb);
     493             :     else
     494        1587 :         sps->mb_aff = 0;
     495             : 
     496        4104 :     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
     497        4104 :         (unsigned)sps->mb_height >= INT_MAX / 16 ||
     498        2052 :         av_image_check_size(16 * sps->mb_width,
     499        2052 :                             16 * sps->mb_height, 0, avctx)) {
     500           0 :         av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
     501           0 :         goto fail;
     502             :     }
     503             : 
     504        2052 :     sps->direct_8x8_inference_flag = get_bits1(gb);
     505             : 
     506             : #ifndef ALLOW_INTERLACE
     507             :     if (sps->mb_aff)
     508             :         av_log(avctx, AV_LOG_ERROR,
     509             :                "MBAFF support not included; enable it at compile-time.\n");
     510             : #endif
     511        2052 :     sps->crop = get_bits1(gb);
     512        2052 :     if (sps->crop) {
     513         198 :         unsigned int crop_left   = get_ue_golomb(gb);
     514         198 :         unsigned int crop_right  = get_ue_golomb(gb);
     515         198 :         unsigned int crop_top    = get_ue_golomb(gb);
     516         198 :         unsigned int crop_bottom = get_ue_golomb(gb);
     517         198 :         int width  = 16 * sps->mb_width;
     518         198 :         int height = 16 * sps->mb_height;
     519             : 
     520         198 :         if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
     521           0 :             av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
     522             :                                            "values are l:%d r:%d t:%d b:%d\n",
     523             :                    crop_left, crop_right, crop_top, crop_bottom);
     524             : 
     525           0 :             sps->crop_left   =
     526           0 :             sps->crop_right  =
     527           0 :             sps->crop_top    =
     528           0 :             sps->crop_bottom = 0;
     529             :         } else {
     530         198 :             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
     531         396 :             int hsub   = (sps->chroma_format_idc == 1 ||
     532         198 :                           sps->chroma_format_idc == 2) ? 1 : 0;
     533         198 :             int step_x = 1 << hsub;
     534         198 :             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
     535             : 
     536         396 :             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
     537         396 :                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
     538         396 :                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
     539         396 :                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
     540         396 :                 (crop_left + crop_right ) * step_x >= width ||
     541         198 :                 (crop_top  + crop_bottom) * step_y >= height
     542             :             ) {
     543           0 :                 av_log(avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
     544           0 :                 goto fail;
     545             :             }
     546             : 
     547         198 :             sps->crop_left   = crop_left   * step_x;
     548         198 :             sps->crop_right  = crop_right  * step_x;
     549         198 :             sps->crop_top    = crop_top    * step_y;
     550         198 :             sps->crop_bottom = crop_bottom * step_y;
     551             :         }
     552             :     } else {
     553        1854 :         sps->crop_left   =
     554        1854 :         sps->crop_right  =
     555        1854 :         sps->crop_top    =
     556        1854 :         sps->crop_bottom =
     557        1854 :         sps->crop        = 0;
     558             :     }
     559             : 
     560        2052 :     sps->vui_parameters_present_flag = get_bits1(gb);
     561        2052 :     if (sps->vui_parameters_present_flag) {
     562         494 :         int ret = decode_vui_parameters(gb, avctx, sps);
     563         494 :         if (ret < 0)
     564           0 :             goto fail;
     565             :     }
     566             : 
     567        2052 :     if (get_bits_left(gb) < 0) {
     568           8 :         av_log(avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
     569           8 :                "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(gb));
     570           4 :         if (!ignore_truncation)
     571           4 :             goto fail;
     572             :     }
     573             : 
     574             :     /* if the maximum delay is not stored in the SPS, derive it based on the
     575             :      * level */
     576        3693 :     if (!sps->bitstream_restriction_flag &&
     577        1704 :         (sps->ref_frame_count || avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT)) {
     578        1586 :         sps->num_reorder_frames = MAX_DELAYED_PIC_COUNT - 1;
     579        8587 :         for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
     580        8587 :             if (level_max_dpb_mbs[i][0] == sps->level_idc) {
     581        1586 :                 sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
     582             :                                                 sps->num_reorder_frames);
     583        1586 :                 break;
     584             :             }
     585             :         }
     586             :     }
     587             : 
     588        2048 :     if (!sps->sar.den)
     589        1891 :         sps->sar.den = 1;
     590             : 
     591        2048 :     if (avctx->debug & FF_DEBUG_PICT_INFO) {
     592             :         static const char csp[4][5] = { "Gray", "420", "422", "444" };
     593           0 :         av_log(avctx, AV_LOG_DEBUG,
     594             :                "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",
     595             :                sps_id, sps->profile_idc, sps->level_idc,
     596             :                sps->poc_type,
     597             :                sps->ref_frame_count,
     598             :                sps->mb_width, sps->mb_height,
     599           0 :                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
     600           0 :                sps->direct_8x8_inference_flag ? "8B8" : "",
     601             :                sps->crop_left, sps->crop_right,
     602             :                sps->crop_top, sps->crop_bottom,
     603           0 :                sps->vui_parameters_present_flag ? "VUI" : "",
     604           0 :                csp[sps->chroma_format_idc],
     605           0 :                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
     606           0 :                sps->timing_info_present_flag ? sps->time_scale : 0,
     607             :                sps->bit_depth_luma,
     608           0 :                sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
     609             :                );
     610             :     }
     611             : 
     612             :     /* check if this is a repeat of an already parsed SPS, then keep the
     613             :      * original one.
     614             :      * otherwise drop all PPSes that depend on it */
     615        3358 :     if (ps->sps_list[sps_id] &&
     616        1310 :         !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
     617        1283 :         av_buffer_unref(&sps_buf);
     618             :     } else {
     619         765 :         remove_sps(ps, sps_id);
     620         765 :         ps->sps_list[sps_id] = sps_buf;
     621             :     }
     622             : 
     623        2048 :     return 0;
     624             : 
     625           4 : fail:
     626           4 :     av_buffer_unref(&sps_buf);
     627           4 :     return AVERROR_INVALIDDATA;
     628             : }
     629             : 
     630         576 : static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
     631             : {
     632             :     int i, j, q, x;
     633         576 :     const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
     634             : 
     635        4032 :     for (i = 0; i < 6; i++) {
     636        3456 :         pps->dequant8_coeff[i] = pps->dequant8_buffer[i];
     637        5310 :         for (j = 0; j < i; j++)
     638        4207 :             if (!memcmp(pps->scaling_matrix8[j], pps->scaling_matrix8[i],
     639             :                         64 * sizeof(uint8_t))) {
     640        2353 :                 pps->dequant8_coeff[i] = pps->dequant8_buffer[j];
     641        2353 :                 break;
     642             :             }
     643        3456 :         if (j < i)
     644        2353 :             continue;
     645             : 
     646       59737 :         for (q = 0; q < max_qp + 1; q++) {
     647       58634 :             int shift = ff_h264_quant_div6[q];
     648       58634 :             int idx   = ff_h264_quant_rem6[q];
     649     3811210 :             for (x = 0; x < 64; x++)
     650     7505152 :                 pps->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =
     651     7505152 :                     ((uint32_t)ff_h264_dequant8_coeff_init[idx][ff_h264_dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *
     652     7505152 :                      pps->scaling_matrix8[i][x]) << shift;
     653             :         }
     654             :     }
     655         576 : }
     656             : 
     657       13767 : static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
     658             : {
     659             :     int i, j, q, x;
     660       13767 :     const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
     661       96369 :     for (i = 0; i < 6; i++) {
     662       82602 :         pps->dequant4_coeff[i] = pps->dequant4_buffer[i];
     663       86761 :         for (j = 0; j < i; j++)
     664       72177 :             if (!memcmp(pps->scaling_matrix4[j], pps->scaling_matrix4[i],
     665             :                         16 * sizeof(uint8_t))) {
     666       68018 :                 pps->dequant4_coeff[i] = pps->dequant4_buffer[j];
     667       68018 :                 break;
     668             :             }
     669       82602 :         if (j < i)
     670       68018 :             continue;
     671             : 
     672      774596 :         for (q = 0; q < max_qp + 1; q++) {
     673      760012 :             int shift = ff_h264_quant_div6[q] + 2;
     674      760012 :             int idx   = ff_h264_quant_rem6[q];
     675    12920204 :             for (x = 0; x < 16; x++)
     676    24320384 :                 pps->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =
     677    24320384 :                     ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *
     678    24320384 :                      pps->scaling_matrix4[i][x]) << shift;
     679             :         }
     680             :     }
     681       13767 : }
     682             : 
     683       13767 : static void init_dequant_tables(PPS *pps, const SPS *sps)
     684             : {
     685             :     int i, x;
     686       13767 :     init_dequant4_coeff_table(pps, sps);
     687       13767 :     memset(pps->dequant8_coeff, 0, sizeof(pps->dequant8_coeff));
     688             : 
     689       13767 :     if (pps->transform_8x8_mode)
     690         576 :         init_dequant8_coeff_table(pps, sps);
     691       13767 :     if (sps->transform_bypass) {
     692         133 :         for (i = 0; i < 6; i++)
     693        1938 :             for (x = 0; x < 16; x++)
     694        1824 :                 pps->dequant4_coeff[i][0][x] = 1 << 6;
     695          19 :         if (pps->transform_8x8_mode)
     696         126 :             for (i = 0; i < 6; i++)
     697        7020 :                 for (x = 0; x < 64; x++)
     698        6912 :                     pps->dequant8_coeff[i][0][x] = 1 << 6;
     699             :     }
     700       13767 : }
     701             : 
     702       27534 : static void build_qp_table(PPS *pps, int t, int index, const int depth)
     703             : {
     704             :     int i;
     705       27534 :     const int max_qp = 51 + 6 * (depth - 8);
     706     1462182 :     for (i = 0; i < max_qp + 1; i++)
     707     1434648 :         pps->chroma_qp_table[t][i] =
     708     1434648 :             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
     709       27534 : }
     710             : 
     711         587 : static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
     712             : {
     713         587 :     int profile_idc = sps->profile_idc;
     714             : 
     715         587 :     if ((profile_idc == 66 || profile_idc == 77 ||
     716          11 :          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
     717           1 :         av_log(logctx, AV_LOG_VERBOSE,
     718             :                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
     719           1 :         return 0;
     720             :     }
     721             : 
     722         586 :     return 1;
     723             : }
     724             : 
     725       13771 : int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
     726             :                                          H264ParamSets *ps, int bit_length)
     727             : {
     728             :     AVBufferRef *pps_buf;
     729             :     const SPS *sps;
     730       13771 :     unsigned int pps_id = get_ue_golomb(gb);
     731             :     PPS *pps;
     732             :     int qp_bd_offset;
     733             :     int bits_left;
     734             :     int ret;
     735             : 
     736       13771 :     if (pps_id >= MAX_PPS_COUNT) {
     737           0 :         av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
     738           0 :         return AVERROR_INVALIDDATA;
     739             :     }
     740             : 
     741       13771 :     pps_buf = av_buffer_allocz(sizeof(*pps));
     742       13771 :     if (!pps_buf)
     743           0 :         return AVERROR(ENOMEM);
     744       13771 :     pps = (PPS*)pps_buf->data;
     745             : 
     746       13771 :     pps->data_size = gb->buffer_end - gb->buffer;
     747       13771 :     if (pps->data_size > sizeof(pps->data)) {
     748           0 :         av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized PPS "
     749             :                "(%"SIZE_SPECIFIER" > %"SIZE_SPECIFIER")\n",
     750             :                pps->data_size, sizeof(pps->data));
     751           0 :         pps->data_size = sizeof(pps->data);
     752             :     }
     753       13771 :     memcpy(pps->data, gb->buffer, pps->data_size);
     754             : 
     755       13771 :     pps->sps_id = get_ue_golomb_31(gb);
     756       27542 :     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
     757       13771 :         !ps->sps_list[pps->sps_id]) {
     758           0 :         av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
     759           0 :         ret = AVERROR_INVALIDDATA;
     760           0 :         goto fail;
     761             :     }
     762       13771 :     sps = (const SPS*)ps->sps_list[pps->sps_id]->data;
     763       13771 :     if (sps->bit_depth_luma > 14) {
     764           0 :         av_log(avctx, AV_LOG_ERROR,
     765             :                "Invalid luma bit depth=%d\n",
     766             :                sps->bit_depth_luma);
     767           0 :         ret = AVERROR_INVALIDDATA;
     768           0 :         goto fail;
     769       13771 :     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
     770           0 :         avpriv_report_missing_feature(avctx,
     771             :                "Unimplemented luma bit depth=%d",
     772             :                sps->bit_depth_luma);
     773           0 :         ret = AVERROR_PATCHWELCOME;
     774           0 :         goto fail;
     775             :     }
     776             : 
     777       13771 :     pps->cabac             = get_bits1(gb);
     778       13771 :     pps->pic_order_present = get_bits1(gb);
     779       13771 :     pps->slice_group_count = get_ue_golomb(gb) + 1;
     780       13771 :     if (pps->slice_group_count > 1) {
     781          14 :         pps->mb_slice_group_map_type = get_ue_golomb(gb);
     782          14 :         av_log(avctx, AV_LOG_ERROR, "FMO not supported\n");
     783             :     }
     784       13771 :     pps->ref_count[0] = get_ue_golomb(gb) + 1;
     785       13771 :     pps->ref_count[1] = get_ue_golomb(gb) + 1;
     786       13771 :     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
     787           4 :         av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
     788           4 :         ret = AVERROR_INVALIDDATA;
     789           4 :         goto fail;
     790             :     }
     791             : 
     792       13767 :     qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
     793             : 
     794       13767 :     pps->weighted_pred                        = get_bits1(gb);
     795       13767 :     pps->weighted_bipred_idc                  = get_bits(gb, 2);
     796       13767 :     pps->init_qp                              = get_se_golomb(gb) + 26U + qp_bd_offset;
     797       13767 :     pps->init_qs                              = get_se_golomb(gb) + 26U + qp_bd_offset;
     798       13767 :     pps->chroma_qp_index_offset[0]            = get_se_golomb(gb);
     799       13767 :     if (pps->chroma_qp_index_offset[0] < -12 || pps->chroma_qp_index_offset[0] > 12) {
     800           0 :         ret = AVERROR_INVALIDDATA;
     801           0 :         goto fail;
     802             :     }
     803             : 
     804       13767 :     pps->deblocking_filter_parameters_present = get_bits1(gb);
     805       13767 :     pps->constrained_intra_pred               = get_bits1(gb);
     806       13767 :     pps->redundant_pic_cnt_present            = get_bits1(gb);
     807             : 
     808       13767 :     pps->transform_8x8_mode = 0;
     809       13767 :     memcpy(pps->scaling_matrix4, sps->scaling_matrix4,
     810             :            sizeof(pps->scaling_matrix4));
     811       13767 :     memcpy(pps->scaling_matrix8, sps->scaling_matrix8,
     812             :            sizeof(pps->scaling_matrix8));
     813             : 
     814       13767 :     bits_left = bit_length - get_bits_count(gb);
     815       13767 :     if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {
     816         586 :         pps->transform_8x8_mode = get_bits1(gb);
     817         586 :         ret = decode_scaling_matrices(gb, sps, pps, 0,
     818         586 :                                 pps->scaling_matrix4, pps->scaling_matrix8);
     819         586 :         if (ret < 0)
     820           0 :             goto fail;
     821             :         // second_chroma_qp_index_offset
     822         586 :         pps->chroma_qp_index_offset[1] = get_se_golomb(gb);
     823        1172 :         if (pps->chroma_qp_index_offset[1] < -12 || pps->chroma_qp_index_offset[1] > 12) {
     824           0 :             ret = AVERROR_INVALIDDATA;
     825           0 :             goto fail;
     826             :         }
     827             :     } else {
     828       13181 :         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
     829             :     }
     830             : 
     831       13767 :     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
     832             :                    sps->bit_depth_luma);
     833       13767 :     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
     834             :                    sps->bit_depth_luma);
     835             : 
     836       13767 :     init_dequant_tables(pps, sps);
     837             : 
     838       13767 :     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
     839          75 :         pps->chroma_qp_diff = 1;
     840             : 
     841       13767 :     if (avctx->debug & FF_DEBUG_PICT_INFO) {
     842           0 :         av_log(avctx, AV_LOG_DEBUG,
     843             :                "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
     844             :                pps_id, pps->sps_id,
     845           0 :                pps->cabac ? "CABAC" : "CAVLC",
     846             :                pps->slice_group_count,
     847             :                pps->ref_count[0], pps->ref_count[1],
     848           0 :                pps->weighted_pred ? "weighted" : "",
     849             :                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
     850           0 :                pps->deblocking_filter_parameters_present ? "LPAR" : "",
     851           0 :                pps->constrained_intra_pred ? "CONSTR" : "",
     852           0 :                pps->redundant_pic_cnt_present ? "REDU" : "",
     853           0 :                pps->transform_8x8_mode ? "8x8DCT" : "");
     854             :     }
     855             : 
     856       13767 :     remove_pps(ps, pps_id);
     857       13767 :     ps->pps_list[pps_id] = pps_buf;
     858             : 
     859       13767 :     return 0;
     860             : 
     861           4 : fail:
     862           4 :     av_buffer_unref(&pps_buf);
     863           4 :     return ret;
     864             : }

Generated by: LCOV version 1.13