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