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