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

   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 / MPEG4 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 "h264.h"
  35 #include "h264data.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 QP(qP, depth) ((qP) + 6 * ((depth) - 8))
  42
  43 #define CHROMA_QP_TABLE_END(d)                                          \
  44     QP(0,  d), QP(1,  d), QP(2,  d), QP(3,  d), QP(4,  d), QP(5,  d),   \
  45     QP(6,  d), QP(7,  d), QP(8,  d), QP(9,  d), QP(10, d), QP(11, d),   \
  46     QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d),   \
  47     QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d),   \
  48     QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d),   \
  49     QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d),   \
  50     QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d),   \
  51     QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d),   \
  52     QP(39, d), QP(39, d), QP(39, d), QP(39, d)
  53
  54 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
  55     { CHROMA_QP_TABLE_END(8) },
  56     { 0, 1, 2, 3, 4, 5,
  57       CHROMA_QP_TABLE_END(9) },
  58     { 0, 1, 2, 3,  4,  5,
  59       6, 7, 8, 9, 10, 11,
  60       CHROMA_QP_TABLE_END(10) },
  61     { 0,  1, 2, 3,  4,  5,
  62       6,  7, 8, 9, 10, 11,
  63       12,13,14,15, 16, 17,
  64       CHROMA_QP_TABLE_END(11) },
  65     { 0,  1, 2, 3,  4,  5,
  66       6,  7, 8, 9, 10, 11,
  67       12,13,14,15, 16, 17,
  68       18,19,20,21, 22, 23,
  69       CHROMA_QP_TABLE_END(12) },
  70     { 0,  1, 2, 3,  4,  5,
  71       6,  7, 8, 9, 10, 11,
  72       12,13,14,15, 16, 17,
  73       18,19,20,21, 22, 23,
  74       24,25,26,27, 28, 29,
  75       CHROMA_QP_TABLE_END(13) },
  76     { 0,  1, 2, 3,  4,  5,
  77       6,  7, 8, 9, 10, 11,
  78       12,13,14,15, 16, 17,
  79       18,19,20,21, 22, 23,
  80       24,25,26,27, 28, 29,
  81       30,31,32,33, 34, 35,
  82       CHROMA_QP_TABLE_END(14) },
  83 };
  84
  85 static const uint8_t default_scaling4[2][16] = {
  86     {  6, 13, 20, 28, 13, 20, 28, 32,
  87       20, 28, 32, 37, 28, 32, 37, 42 },
  88     { 10, 14, 20, 24, 14, 20, 24, 27,
  89       20, 24, 27, 30, 24, 27, 30, 34 }
  90 };
  91
  92 static const uint8_t default_scaling8[2][64] = {
  93     {  6, 10, 13, 16, 18, 23, 25, 27,
  94       10, 11, 16, 18, 23, 25, 27, 29,
  95       13, 16, 18, 23, 25, 27, 29, 31,
  96       16, 18, 23, 25, 27, 29, 31, 33,
  97       18, 23, 25, 27, 29, 31, 33, 36,
  98       23, 25, 27, 29, 31, 33, 36, 38,
  99       25, 27, 29, 31, 33, 36, 38, 40,
 100       27, 29, 31, 33, 36, 38, 40, 42 },
 101     {  9, 13, 15, 17, 19, 21, 22, 24,
 102       13, 13, 17, 19, 21, 22, 24, 25,
 103       15, 17, 19, 21, 22, 24, 25, 27,
 104       17, 19, 21, 22, 24, 25, 27, 28,
 105       19, 21, 22, 24, 25, 27, 28, 30,
 106       21, 22, 24, 25, 27, 28, 30, 32,
 107       22, 24, 25, 27, 28, 30, 32, 33,
 108       24, 25, 27, 28, 30, 32, 33, 35 }
 109 };
 110
 111 /* maximum number of MBs in the DPB for a given level */
 112 static const int level_max_dpb_mbs[][2] = {
 113     { 10, 396       },
 114     { 11, 900       },
 115     { 12, 2376      },
 116     { 13, 2376      },
 117     { 20, 2376      },
 118     { 21, 4752      },
 119     { 22, 8100      },
 120     { 30, 8100      },
 121     { 31, 18000     },
 122     { 32, 20480     },
 123     { 40, 32768     },
 124     { 41, 32768     },
 125     { 42, 34816     },
 126     { 50, 110400    },
 127     { 51, 184320    },
 128     { 52, 184320    },
 129 };
 130
 131 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
 132 {
 133     int cpb_count, i;
 134     cpb_count = get_ue_golomb_31(&h->gb) + 1;
 135
 136     if (cpb_count > 32U) {
 137         av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
 138         return AVERROR_INVALIDDATA;
 139     }
 140
 141     get_bits(&h->gb, 4); /* bit_rate_scale */
 142     get_bits(&h->gb, 4); /* cpb_size_scale */
 143     for (i = 0; i < cpb_count; i++) {
 144         get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
 145         get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
 146         get_bits1(&h->gb);          /* cbr_flag */
 147     }
 148     sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
 149     sps->cpb_removal_delay_length         = get_bits(&h->gb, 5) + 1;
 150     sps->dpb_output_delay_length          = get_bits(&h->gb, 5) + 1;
 151     sps->time_offset_length               = get_bits(&h->gb, 5);
 152     sps->cpb_cnt                          = cpb_count;
 153     return 0;
 154 }
 155
 156 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
 157 {
 158     int aspect_ratio_info_present_flag;
 159     unsigned int aspect_ratio_idc;
 160
 161     aspect_ratio_info_present_flag = get_bits1(&h->gb);
 162
 163     if (aspect_ratio_info_present_flag) {
 164         aspect_ratio_idc = get_bits(&h->gb, 8);
 165         if (aspect_ratio_idc == EXTENDED_SAR) {
 166             sps->sar.num = get_bits(&h->gb, 16);
 167             sps->sar.den = get_bits(&h->gb, 16);
 168         } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
 169             sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
 170         } else {
 171             av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
 172             return AVERROR_INVALIDDATA;
 173         }
 174     } else {
 175         sps->sar.num =
 176         sps->sar.den = 0;
 177     }
 178
 179     if (get_bits1(&h->gb))      /* overscan_info_present_flag */
 180         get_bits1(&h->gb);      /* overscan_appropriate_flag */
 181
 182     sps->video_signal_type_present_flag = get_bits1(&h->gb);
 183     if (sps->video_signal_type_present_flag) {
 184         get_bits(&h->gb, 3);                 /* video_format */
 185         sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
 186
 187         sps->colour_description_present_flag = get_bits1(&h->gb);
 188         if (sps->colour_description_present_flag) {
 189             sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
 190             sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
 191             sps->colorspace      = get_bits(&h->gb, 8); /* matrix_coefficients */
 192             if (sps->color_primaries >= AVCOL_PRI_NB)
 193                 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
 194             if (sps->color_trc >= AVCOL_TRC_NB)
 195                 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
 196             if (sps->colorspace >= AVCOL_SPC_NB)
 197                 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
 198         }
 199     }
 200
 201     /* chroma_location_info_present_flag */
 202     if (get_bits1(&h->gb)) {
 203         /* chroma_sample_location_type_top_field */
 204         h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
 205         get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
 206     }
 207
 208     if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
 209         av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
 210         return 0;
 211     }
 212
 213     sps->timing_info_present_flag = get_bits1(&h->gb);
 214     if (sps->timing_info_present_flag) {
 215         unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
 216         unsigned time_scale        = get_bits_long(&h->gb, 32);
 217         if (!num_units_in_tick || !time_scale) {
 218             av_log(h->avctx, AV_LOG_ERROR,
 219                    "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
 220                    time_scale, num_units_in_tick);
 221             sps->timing_info_present_flag = 0;
 222         } else {
 223             sps->num_units_in_tick = num_units_in_tick;
 224             sps->time_scale = time_scale;
 225         }
 226         sps->fixed_frame_rate_flag = get_bits1(&h->gb);
 227     }
 228
 229     sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
 230     if (sps->nal_hrd_parameters_present_flag)
 231         if (decode_hrd_parameters(h, sps) < 0)
 232             return AVERROR_INVALIDDATA;
 233     sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
 234     if (sps->vcl_hrd_parameters_present_flag)
 235         if (decode_hrd_parameters(h, sps) < 0)
 236             return AVERROR_INVALIDDATA;
 237     if (sps->nal_hrd_parameters_present_flag ||
 238         sps->vcl_hrd_parameters_present_flag)
 239         get_bits1(&h->gb);     /* low_delay_hrd_flag */
 240     sps->pic_struct_present_flag = get_bits1(&h->gb);
 241     if (!get_bits_left(&h->gb))
 242         return 0;
 243     sps->bitstream_restriction_flag = get_bits1(&h->gb);
 244     if (sps->bitstream_restriction_flag) {
 245         get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
 246         get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
 247         get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
 248         get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
 249         get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
 250         sps->num_reorder_frames = get_ue_golomb(&h->gb);
 251         get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
 252
 253         if (get_bits_left(&h->gb) < 0) {
 254             sps->num_reorder_frames         = 0;
 255             sps->bitstream_restriction_flag = 0;
 256         }
 257
 258         if (sps->num_reorder_frames > 16U
 259             /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
 260             av_log(h->avctx, AV_LOG_ERROR,
 261                    "Clipping illegal num_reorder_frames %d\n",
 262                    sps->num_reorder_frames);
 263             sps->num_reorder_frames = 16;
 264             return AVERROR_INVALIDDATA;
 265         }
 266     }
 267
 268     return 0;
 269 }
 270
 271 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
 272                                 const uint8_t *jvt_list,
 273                                 const uint8_t *fallback_list)
 274 {
 275     int i, last = 8, next = 8;
 276     const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
 277     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
 278         memcpy(factors, fallback_list, size * sizeof(uint8_t));
 279     else
 280         for (i = 0; i < size; i++) {
 281             if (next)
 282                 next = (last + get_se_golomb(&h->gb)) & 0xff;
 283             if (!i && !next) { /* matrix not written, we use the preset one */
 284                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
 285                 break;
 286             }
 287             last = factors[scan[i]] = next ? next : last;
 288         }
 289 }
 290
 291 static void decode_scaling_matrices(H264Context *h, SPS *sps,
 292                                     PPS *pps, int is_sps,
 293                                     uint8_t(*scaling_matrix4)[16],
 294                                     uint8_t(*scaling_matrix8)[64])
 295 {
 296     int fallback_sps = !is_sps && sps->scaling_matrix_present;
 297     const uint8_t *fallback[4] = {
 298         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
 299         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
 300         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
 301         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
 302     };
 303     if (get_bits1(&h->gb)) {
 304         sps->scaling_matrix_present |= is_sps;
 305         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
 306         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
 307         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
 308         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
 309         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
 310         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
 311         if (is_sps || pps->transform_8x8_mode) {
 312             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
 313             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
 314             if (sps->chroma_format_idc == 3) {
 315                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
 316                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
 317                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
 318                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
 319             }
 320         }
 321     }
 322 }
 323
 324 int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
 325 {
 326     int profile_idc, level_idc, constraint_set_flags = 0;
 327     unsigned int sps_id;
 328     int i, log2_max_frame_num_minus4;
 329     SPS *sps;
 330
 331     sps = av_mallocz(sizeof(SPS));
 332     if (!sps)
 333         return AVERROR(ENOMEM);
 334
 335     sps->data_size = h->gb.buffer_end - h->gb.buffer;
 336     if (sps->data_size > sizeof(sps->data)) {
 337         av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
 338         sps->data_size = sizeof(sps->data);
 339     }
 340     memcpy(sps->data, h->gb.buffer, sps->data_size);
 341
 342     profile_idc           = get_bits(&h->gb, 8);
 343     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
 344     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
 345     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
 346     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
 347     constraint_set_flags |= get_bits1(&h->gb) << 4;   // constraint_set4_flag
 348     constraint_set_flags |= get_bits1(&h->gb) << 5;   // constraint_set5_flag
 349     skip_bits(&h->gb, 2);                             // reserved_zero_2bits
 350     level_idc = get_bits(&h->gb, 8);
 351     sps_id    = get_ue_golomb_31(&h->gb);
 352
 353     if (sps_id >= MAX_SPS_COUNT) {
 354         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
 355         goto fail;
 356     }
 357
 358     sps->sps_id               = sps_id;
 359     sps->time_offset_length   = 24;
 360     sps->profile_idc          = profile_idc;
 361     sps->constraint_set_flags = constraint_set_flags;
 362     sps->level_idc            = level_idc;
 363     sps->full_range           = -1;
 364
 365     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
 366     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
 367     sps->scaling_matrix_present = 0;
 368     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
 369
 370     if (sps->profile_idc == 100 ||  // High profile
 371         sps->profile_idc == 110 ||  // High10 profile
 372         sps->profile_idc == 122 ||  // High422 profile
 373         sps->profile_idc == 244 ||  // High444 Predictive profile
 374         sps->profile_idc ==  44 ||  // Cavlc444 profile
 375         sps->profile_idc ==  83 ||  // Scalable Constrained High profile (SVC)
 376         sps->profile_idc ==  86 ||  // Scalable High Intra profile (SVC)
 377         sps->profile_idc == 118 ||  // Stereo High profile (MVC)
 378         sps->profile_idc == 128 ||  // Multiview High profile (MVC)
 379         sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)
 380         sps->profile_idc == 144) {  // old High444 profile
 381         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
 382         if (sps->chroma_format_idc > 3U) {
 383             avpriv_request_sample(h->avctx, "chroma_format_idc %u",
 384                                   sps->chroma_format_idc);
 385             goto fail;
 386         } else if (sps->chroma_format_idc == 3) {
 387             sps->residual_color_transform_flag = get_bits1(&h->gb);
 388             if (sps->residual_color_transform_flag) {
 389                 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
 390                 goto fail;
 391             }
 392         }
 393         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
 394         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
 395         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
 396             avpriv_request_sample(h->avctx,
 397                                   "Different chroma and luma bit depth");
 398             goto fail;
 399         }
 400         if (sps->bit_depth_luma   < 8 || sps->bit_depth_luma   > 14 ||
 401             sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
 402             av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
 403                    sps->bit_depth_luma, sps->bit_depth_chroma);
 404             goto fail;
 405         }
 406         sps->transform_bypass = get_bits1(&h->gb);
 407         decode_scaling_matrices(h, sps, NULL, 1,
 408                                 sps->scaling_matrix4, sps->scaling_matrix8);
 409     } else {
 410         sps->chroma_format_idc = 1;
 411         sps->bit_depth_luma    = 8;
 412         sps->bit_depth_chroma  = 8;
 413     }
 414
 415     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
 416     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
 417         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
 418         av_log(h->avctx, AV_LOG_ERROR,
 419                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
 420                log2_max_frame_num_minus4);
 421         goto fail;
 422     }
 423     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
 424
 425     sps->poc_type = get_ue_golomb_31(&h->gb);
 426
 427     if (sps->poc_type == 0) { // FIXME #define
 428         unsigned t = get_ue_golomb(&h->gb);
 429         if (t>12) {
 430             av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
 431             goto fail;
 432         }
 433         sps->log2_max_poc_lsb = t + 4;
 434     } else if (sps->poc_type == 1) { // FIXME #define
 435         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
 436         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
 437         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
 438         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
 439
 440         if ((unsigned)sps->poc_cycle_length >=
 441             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
 442             av_log(h->avctx, AV_LOG_ERROR,
 443                    "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
 444             goto fail;
 445         }
 446
 447         for (i = 0; i < sps->poc_cycle_length; i++)
 448             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
 449     } else if (sps->poc_type != 2) {
 450         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
 451         goto fail;
 452     }
 453
 454     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
 455     if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
 456         sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
 457     if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
 458         sps->ref_frame_count > 16U) {
 459         av_log(h->avctx, AV_LOG_ERROR,
 460                "too many reference frames %d\n", sps->ref_frame_count);
 461         goto fail;
 462     }
 463     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
 464     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
 465     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
 466     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
 467         (unsigned)sps->mb_height >= INT_MAX / 16 ||
 468         av_image_check_size(16 * sps->mb_width,
 469                             16 * sps->mb_height, 0, h->avctx)) {
 470         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
 471         goto fail;
 472     }
 473
 474     sps->frame_mbs_only_flag = get_bits1(&h->gb);
 475     if (!sps->frame_mbs_only_flag)
 476         sps->mb_aff = get_bits1(&h->gb);
 477     else
 478         sps->mb_aff = 0;
 479
 480     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
 481
 482 #ifndef ALLOW_INTERLACE
 483     if (sps->mb_aff)
 484         av_log(h->avctx, AV_LOG_ERROR,
 485                "MBAFF support not included; enable it at compile-time.\n");
 486 #endif
 487     sps->crop = get_bits1(&h->gb);
 488     if (sps->crop) {
 489         unsigned int crop_left   = get_ue_golomb(&h->gb);
 490         unsigned int crop_right  = get_ue_golomb(&h->gb);
 491         unsigned int crop_top    = get_ue_golomb(&h->gb);
 492         unsigned int crop_bottom = get_ue_golomb(&h->gb);
 493         int width  = 16 * sps->mb_width;
 494         int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
 495
 496         if (h->avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
 497             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
 498                                            "values are l:%d r:%d t:%d b:%d\n",
 499                    crop_left, crop_right, crop_top, crop_bottom);
 500
 501             sps->crop_left   =
 502             sps->crop_right  =
 503             sps->crop_top    =
 504             sps->crop_bottom = 0;
 505         } else {
 506             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
 507             int hsub   = (sps->chroma_format_idc == 1 ||
 508                           sps->chroma_format_idc == 2) ? 1 : 0;
 509             int step_x = 1 << hsub;
 510             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
 511
 512             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
 513                 !(h->avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
 514                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
 515                 av_log(h->avctx, AV_LOG_WARNING,
 516                        "Reducing left cropping to %d "
 517                        "chroma samples to preserve alignment.\n",
 518                        crop_left);
 519             }
 520
 521             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
 522                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
 523                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
 524                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
 525                 (crop_left + crop_right ) * step_x >= width ||
 526                 (crop_top  + crop_bottom) * step_y >= height
 527             ) {
 528                 av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
 529                 goto fail;
 530             }
 531
 532             sps->crop_left   = crop_left   * step_x;
 533             sps->crop_right  = crop_right  * step_x;
 534             sps->crop_top    = crop_top    * step_y;
 535             sps->crop_bottom = crop_bottom * step_y;
 536         }
 537     } else {
 538         sps->crop_left   =
 539         sps->crop_right  =
 540         sps->crop_top    =
 541         sps->crop_bottom =
 542         sps->crop        = 0;
 543     }
 544
 545     sps->vui_parameters_present_flag = get_bits1(&h->gb);
 546     if (sps->vui_parameters_present_flag) {
 547         int ret = decode_vui_parameters(h, sps);
 548         if (ret < 0)
 549             goto fail;
 550     }
 551
 552     if (get_bits_left(&h->gb) < 0) {
 553         av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
 554                "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
 555         if (!ignore_truncation)
 556             goto fail;
 557     }
 558
 559     /* if the maximum delay is not stored in the SPS, derive it based on the
 560      * level */
 561     if (!sps->bitstream_restriction_flag) {
 562         sps->num_reorder_frames = MAX_DELAYED_PIC_COUNT - 1;
 563         for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
 564             if (level_max_dpb_mbs[i][0] == sps->level_idc) {
 565                 sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
 566                                                 sps->num_reorder_frames);
 567                 break;
 568             }
 569         }
 570     }
 571
 572     if (!sps->sar.den)
 573         sps->sar.den = 1;
 574
 575     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 576         static const char csp[4][5] = { "Gray", "420", "422", "444" };
 577         av_log(h->avctx, AV_LOG_DEBUG,
 578                "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",
 579                sps_id, sps->profile_idc, sps->level_idc,
 580                sps->poc_type,
 581                sps->ref_frame_count,
 582                sps->mb_width, sps->mb_height,
 583                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 584                sps->direct_8x8_inference_flag ? "8B8" : "",
 585                sps->crop_left, sps->crop_right,
 586                sps->crop_top, sps->crop_bottom,
 587                sps->vui_parameters_present_flag ? "VUI" : "",
 588                csp[sps->chroma_format_idc],
 589                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
 590                sps->timing_info_present_flag ? sps->time_scale : 0,
 591                sps->bit_depth_luma,
 592                sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
 593                );
 594     }
 595     sps->new = 1;
 596
 597     av_free(h->sps_buffers[sps_id]);
 598     h->sps_buffers[sps_id] = sps;
 599
 600     return 0;
 601
 602 fail:
 603     av_free(sps);
 604     return AVERROR_INVALIDDATA;
 605 }
 606
 607 static void build_qp_table(PPS *pps, int t, int index, const int depth)
 608 {
 609     int i;
 610     const int max_qp = 51 + 6 * (depth - 8);
 611     for (i = 0; i < max_qp + 1; i++)
 612         pps->chroma_qp_table[t][i] =
 613             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
 614 }
 615
 616 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
 617 {
 618     const SPS *sps = h->sps_buffers[pps->sps_id];
 619     int profile_idc = sps->profile_idc;
 620
 621     if ((profile_idc == 66 || profile_idc == 77 ||
 622          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
 623         av_log(h->avctx, AV_LOG_VERBOSE,
 624                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 625         return 0;
 626     }
 627
 628     return 1;
 629 }
 630
 631 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
 632 {
 633     const SPS *sps;
 634     unsigned int pps_id = get_ue_golomb(&h->gb);
 635     PPS *pps;
 636     int qp_bd_offset;
 637     int bits_left;
 638     int ret;
 639
 640     if (pps_id >= MAX_PPS_COUNT) {
 641         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
 642         return AVERROR_INVALIDDATA;
 643     }
 644
 645     pps = av_mallocz(sizeof(PPS));
 646     if (!pps)
 647         return AVERROR(ENOMEM);
 648     pps->data_size = h->gb.buffer_end - h->gb.buffer;
 649     if (pps->data_size > sizeof(pps->data)) {
 650         av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
 651         pps->data_size = sizeof(pps->data);
 652     }
 653     memcpy(pps->data, h->gb.buffer, pps->data_size);
 654     pps->sps_id = get_ue_golomb_31(&h->gb);
 655     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
 656         !h->sps_buffers[pps->sps_id]) {
 657         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
 658         ret = AVERROR_INVALIDDATA;
 659         goto fail;
 660     }
 661     sps = h->sps_buffers[pps->sps_id];
 662     if (sps->bit_depth_luma > 14) {
 663         av_log(h->avctx, AV_LOG_ERROR,
 664                "Invalid luma bit depth=%d\n",
 665                sps->bit_depth_luma);
 666         ret = AVERROR_INVALIDDATA;
 667         goto fail;
 668     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
 669         av_log(h->avctx, AV_LOG_ERROR,
 670                "Unimplemented luma bit depth=%d\n",
 671                sps->bit_depth_luma);
 672         ret = AVERROR_PATCHWELCOME;
 673         goto fail;
 674     }
 675
 676     pps->cabac             = get_bits1(&h->gb);
 677     pps->pic_order_present = get_bits1(&h->gb);
 678     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
 679     if (pps->slice_group_count > 1) {
 680         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
 681         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
 682         switch (pps->mb_slice_group_map_type) {
 683         case 0:
 684 #if 0
 685     |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
 686     |           run_length[i]                               |1  |ue(v) |
 687 #endif
 688             break;
 689         case 2:
 690 #if 0
 691     |       for (i = 0; i < num_slice_groups_minus1; i++) { |   |      |
 692     |           top_left_mb[i]                              |1  |ue(v) |
 693     |           bottom_right_mb[i]                          |1  |ue(v) |
 694     |       }                                               |   |      |
 695 #endif
 696             break;
 697         case 3:
 698         case 4:
 699         case 5:
 700 #if 0
 701     |       slice_group_change_direction_flag               |1  |u(1)  |
 702     |       slice_group_change_rate_minus1                  |1  |ue(v) |
 703 #endif
 704             break;
 705         case 6:
 706 #if 0
 707     |       slice_group_id_cnt_minus1                       |1  |ue(v) |
 708     |       for (i = 0; i <= slice_group_id_cnt_minus1; i++)|   |      |
 709     |           slice_group_id[i]                           |1  |u(v)  |
 710 #endif
 711             break;
 712         }
 713     }
 714     pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
 715     pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
 716     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
 717         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
 718         ret = AVERROR_INVALIDDATA;
 719         goto fail;
 720     }
 721
 722     qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
 723
 724     pps->weighted_pred                        = get_bits1(&h->gb);
 725     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
 726     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 727     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 728     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
 729     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
 730     pps->constrained_intra_pred               = get_bits1(&h->gb);
 731     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
 732
 733     pps->transform_8x8_mode = 0;
 734     // contents of sps/pps can change even if id doesn't, so reinit
 735     h->dequant_coeff_pps = -1;
 736     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
 737            sizeof(pps->scaling_matrix4));
 738     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
 739            sizeof(pps->scaling_matrix8));
 740
 741     bits_left = bit_length - get_bits_count(&h->gb);
 742     if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
 743         pps->transform_8x8_mode = get_bits1(&h->gb);
 744         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
 745                                 pps->scaling_matrix4, pps->scaling_matrix8);
 746         // second_chroma_qp_index_offset
 747         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
 748     } else {
 749         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
 750     }
 751
 752     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
 753                    sps->bit_depth_luma);
 754     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
 755                    sps->bit_depth_luma);
 756     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
 757         pps->chroma_qp_diff = 1;
 758
 759     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 760         av_log(h->avctx, AV_LOG_DEBUG,
 761                "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
 762                pps_id, pps->sps_id,
 763                pps->cabac ? "CABAC" : "CAVLC",
 764                pps->slice_group_count,
 765                pps->ref_count[0], pps->ref_count[1],
 766                pps->weighted_pred ? "weighted" : "",
 767                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
 768                pps->deblocking_filter_parameters_present ? "LPAR" : "",
 769                pps->constrained_intra_pred ? "CONSTR" : "",
 770                pps->redundant_pic_cnt_present ? "REDU" : "",
 771                pps->transform_8x8_mode ? "8x8DCT" : "");
 772     }
 773
 774     av_free(h->pps_buffers[pps_id]);
 775     h->pps_buffers[pps_id] = pps;
 776     return 0;
 777
 778 fail:
 779     av_free(pps);
 780     return ret;
 781 }