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