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                    "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
 256             return AVERROR_INVALIDDATA;
 257         }
 258     }
 259
 260     if (get_bits_left(&h->gb) < 0) {
 261         av_log(h->avctx, AV_LOG_ERROR,
 262                "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
 263         return AVERROR_INVALIDDATA;
 264     }
 265
 266     return 0;
 267 }
 268
 269 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
 270                                 const uint8_t *jvt_list,
 271                                 const uint8_t *fallback_list)
 272 {
 273     int i, last = 8, next = 8;
 274     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
 275     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
 276         memcpy(factors, fallback_list, size * sizeof(uint8_t));
 277     else
 278         for (i = 0; i < size; i++) {
 279             if (next)
 280                 next = (last + get_se_golomb(&h->gb)) & 0xff;
 281             if (!i && !next) { /* matrix not written, we use the preset one */
 282                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
 283                 break;
 284             }
 285             last = factors[scan[i]] = next ? next : last;
 286         }
 287 }
 288
 289 static void decode_scaling_matrices(H264Context *h, SPS *sps,
 290                                     PPS *pps, int is_sps,
 291                                     uint8_t(*scaling_matrix4)[16],
 292                                     uint8_t(*scaling_matrix8)[64])
 293 {
 294     int fallback_sps = !is_sps && sps->scaling_matrix_present;
 295     const uint8_t *fallback[4] = {
 296         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
 297         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
 298         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
 299         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
 300     };
 301     if (get_bits1(&h->gb)) {
 302         sps->scaling_matrix_present |= is_sps;
 303         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
 304         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
 305         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
 306         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
 307         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
 308         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
 309         if (is_sps || pps->transform_8x8_mode) {
 310             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
 311             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
 312             if (sps->chroma_format_idc == 3) {
 313                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
 314                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
 315                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
 316                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
 317             }
 318         }
 319     }
 320 }
 321
 322 int ff_h264_decode_seq_parameter_set(H264Context *h)
 323 {
 324     int profile_idc, level_idc, constraint_set_flags = 0;
 325     unsigned int sps_id;
 326     int i, log2_max_frame_num_minus4;
 327     SPS *sps;
 328
 329     profile_idc           = get_bits(&h->gb, 8);
 330     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
 331     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
 332     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
 333     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
 334     constraint_set_flags |= get_bits1(&h->gb) << 4;   // constraint_set4_flag
 335     constraint_set_flags |= get_bits1(&h->gb) << 5;   // constraint_set5_flag
 336     get_bits(&h->gb, 2); // reserved
 337     level_idc = get_bits(&h->gb, 8);
 338     sps_id    = get_ue_golomb_31(&h->gb);
 339
 340     if (sps_id >= MAX_SPS_COUNT) {
 341         av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
 342         return AVERROR_INVALIDDATA;
 343     }
 344     sps = av_mallocz(sizeof(SPS));
 345     if (!sps)
 346         return AVERROR(ENOMEM);
 347
 348     sps->time_offset_length   = 24;
 349     sps->profile_idc          = profile_idc;
 350     sps->constraint_set_flags = constraint_set_flags;
 351     sps->level_idc            = level_idc;
 352     sps->full_range           = -1;
 353
 354     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
 355     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
 356     sps->scaling_matrix_present = 0;
 357     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
 358
 359     if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
 360         sps->profile_idc == 122 || sps->profile_idc == 244 ||
 361         sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
 362         sps->profile_idc ==  86 || sps->profile_idc == 118 ||
 363         sps->profile_idc == 128 || sps->profile_idc == 144) {
 364         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
 365         if (sps->chroma_format_idc > 3U) {
 366             av_log(h->avctx, AV_LOG_ERROR,
 367                    "chroma_format_idc %d is illegal\n",
 368                    sps->chroma_format_idc);
 369             goto fail;
 370         } else if (sps->chroma_format_idc == 3) {
 371             sps->residual_color_transform_flag = get_bits1(&h->gb);
 372             if (sps->residual_color_transform_flag) {
 373                 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
 374                 goto fail;
 375             }
 376         }
 377         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
 378         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
 379         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
 380             avpriv_request_sample(h->avctx,
 381                                   "Different chroma and luma bit depth");
 382             goto fail;
 383         }
 384         if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
 385             av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
 386                    sps->bit_depth_luma, sps->bit_depth_chroma);
 387             goto fail;
 388         }
 389         sps->transform_bypass = get_bits1(&h->gb);
 390         decode_scaling_matrices(h, sps, NULL, 1,
 391                                 sps->scaling_matrix4, sps->scaling_matrix8);
 392     } else {
 393         sps->chroma_format_idc = 1;
 394         sps->bit_depth_luma    = 8;
 395         sps->bit_depth_chroma  = 8;
 396     }
 397
 398     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
 399     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
 400         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
 401         av_log(h->avctx, AV_LOG_ERROR,
 402                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
 403                log2_max_frame_num_minus4);
 404         goto fail;
 405     }
 406     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
 407
 408     sps->poc_type = get_ue_golomb_31(&h->gb);
 409
 410     if (sps->poc_type == 0) { // FIXME #define
 411         unsigned t = get_ue_golomb(&h->gb);
 412         if (t>12) {
 413             av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
 414             goto fail;
 415         }
 416         sps->log2_max_poc_lsb = t + 4;
 417     } else if (sps->poc_type == 1) { // FIXME #define
 418         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
 419         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
 420         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
 421         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
 422
 423         if ((unsigned)sps->poc_cycle_length >=
 424             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
 425             av_log(h->avctx, AV_LOG_ERROR,
 426                    "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
 427             goto fail;
 428         }
 429
 430         for (i = 0; i < sps->poc_cycle_length; i++)
 431             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
 432     } else if (sps->poc_type != 2) {
 433         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
 434         goto fail;
 435     }
 436
 437     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
 438     if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
 439         sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
 440     if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
 441         sps->ref_frame_count > 16U) {
 442         av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
 443         goto fail;
 444     }
 445     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
 446     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
 447     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
 448     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
 449         (unsigned)sps->mb_height >= INT_MAX / 16 ||
 450         av_image_check_size(16 * sps->mb_width,
 451                             16 * sps->mb_height, 0, h->avctx)) {
 452         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
 453         goto fail;
 454     }
 455
 456     sps->frame_mbs_only_flag = get_bits1(&h->gb);
 457     if (!sps->frame_mbs_only_flag)
 458         sps->mb_aff = get_bits1(&h->gb);
 459     else
 460         sps->mb_aff = 0;
 461
 462     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
 463
 464 #ifndef ALLOW_INTERLACE
 465     if (sps->mb_aff)
 466         av_log(h->avctx, AV_LOG_ERROR,
 467                "MBAFF support not included; enable it at compile-time.\n");
 468 #endif
 469     sps->crop = get_bits1(&h->gb);
 470     if (sps->crop) {
 471         int crop_left   = get_ue_golomb(&h->gb);
 472         int crop_right  = get_ue_golomb(&h->gb);
 473         int crop_top    = get_ue_golomb(&h->gb);
 474         int crop_bottom = get_ue_golomb(&h->gb);
 475         int width  = 16 * sps->mb_width;
 476         int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
 477
 478         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
 479             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
 480                                            "values are l:%u r:%u t:%u b:%u\n",
 481                    crop_left, crop_right, crop_top, crop_bottom);
 482
 483             sps->crop_left   =
 484             sps->crop_right  =
 485             sps->crop_top    =
 486             sps->crop_bottom = 0;
 487         } else {
 488             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
 489             int hsub   = (sps->chroma_format_idc == 1 ||
 490                           sps->chroma_format_idc == 2) ? 1 : 0;
 491             int step_x = 1 << hsub;
 492             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
 493
 494             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
 495                 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
 496                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
 497                 av_log(h->avctx, AV_LOG_WARNING,
 498                        "Reducing left cropping to %d "
 499                        "chroma samples to preserve alignment.\n",
 500                        crop_left);
 501             }
 502
 503             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
 504                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
 505                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
 506                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
 507                 (crop_left + crop_right ) * step_x >= width ||
 508                 (crop_top  + crop_bottom) * step_y >= height
 509             ) {
 510                 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);
 511                 goto fail;
 512             }
 513
 514             sps->crop_left   = crop_left   * step_x;
 515             sps->crop_right  = crop_right  * step_x;
 516             sps->crop_top    = crop_top    * step_y;
 517             sps->crop_bottom = crop_bottom * step_y;
 518         }
 519     } else {
 520         sps->crop_left   =
 521         sps->crop_right  =
 522         sps->crop_top    =
 523         sps->crop_bottom =
 524         sps->crop        = 0;
 525     }
 526
 527     sps->vui_parameters_present_flag = get_bits1(&h->gb);
 528     if (sps->vui_parameters_present_flag) {
 529         int ret = decode_vui_parameters(h, sps);
 530         if (ret < 0)
 531             goto fail;
 532     }
 533
 534     if (!sps->sar.den)
 535         sps->sar.den = 1;
 536
 537     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 538         static const char csp[4][5] = { "Gray", "420", "422", "444" };
 539         av_log(h->avctx, AV_LOG_DEBUG,
 540                "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",
 541                sps_id, sps->profile_idc, sps->level_idc,
 542                sps->poc_type,
 543                sps->ref_frame_count,
 544                sps->mb_width, sps->mb_height,
 545                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 546                sps->direct_8x8_inference_flag ? "8B8" : "",
 547                sps->crop_left, sps->crop_right,
 548                sps->crop_top, sps->crop_bottom,
 549                sps->vui_parameters_present_flag ? "VUI" : "",
 550                csp[sps->chroma_format_idc],
 551                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
 552                sps->timing_info_present_flag ? sps->time_scale : 0,
 553                sps->bit_depth_luma,
 554                h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
 555                );
 556     }
 557     sps->new = 1;
 558
 559     av_free(h->sps_buffers[sps_id]);
 560     h->sps_buffers[sps_id] = sps;
 561
 562     return 0;
 563
 564 fail:
 565     av_free(sps);
 566     return -1;
 567 }
 568
 569 static void build_qp_table(PPS *pps, int t, int index, const int depth)
 570 {
 571     int i;
 572     const int max_qp = 51 + 6 * (depth - 8);
 573     for (i = 0; i < max_qp + 1; i++)
 574         pps->chroma_qp_table[t][i] =
 575             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
 576 }
 577
 578 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
 579 {
 580     const SPS *sps = h->sps_buffers[pps->sps_id];
 581     int profile_idc = sps->profile_idc;
 582
 583     if ((profile_idc == 66 || profile_idc == 77 ||
 584          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
 585         av_log(h->avctx, AV_LOG_VERBOSE,
 586                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 587         return 0;
 588     }
 589
 590     return 1;
 591 }
 592
 593 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
 594 {
 595     unsigned int pps_id = get_ue_golomb(&h->gb);
 596     PPS *pps;
 597     SPS *sps;
 598     int qp_bd_offset;
 599     int bits_left;
 600
 601     if (pps_id >= MAX_PPS_COUNT) {
 602         av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
 603         return AVERROR_INVALIDDATA;
 604     }
 605
 606     pps = av_mallocz(sizeof(PPS));
 607     if (!pps)
 608         return AVERROR(ENOMEM);
 609     pps->sps_id = get_ue_golomb_31(&h->gb);
 610     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
 611         h->sps_buffers[pps->sps_id] == NULL) {
 612         av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
 613         goto fail;
 614     }
 615     sps = h->sps_buffers[pps->sps_id];
 616     qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
 617     if (sps->bit_depth_luma > 14) {
 618         av_log(h->avctx, AV_LOG_ERROR,
 619                "Invalid luma bit depth=%d\n",
 620                sps->bit_depth_luma);
 621         goto fail;
 622     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
 623         av_log(h->avctx, AV_LOG_ERROR,
 624                "Unimplemented luma bit depth=%d\n",
 625                sps->bit_depth_luma);
 626         goto fail;
 627     }
 628
 629     pps->cabac             = get_bits1(&h->gb);
 630     pps->pic_order_present = get_bits1(&h->gb);
 631     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
 632     if (pps->slice_group_count > 1) {
 633         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
 634         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
 635         switch (pps->mb_slice_group_map_type) {
 636         case 0:
 637 #if 0
 638     |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
 639     |           run_length[i]                               |1  |ue(v) |
 640 #endif
 641             break;
 642         case 2:
 643 #if 0
 644     |       for (i = 0; i < num_slice_groups_minus1; i++) { |   |      |
 645     |           top_left_mb[i]                              |1  |ue(v) |
 646     |           bottom_right_mb[i]                          |1  |ue(v) |
 647     |       }                                               |   |      |
 648 #endif
 649             break;
 650         case 3:
 651         case 4:
 652         case 5:
 653 #if 0
 654     |       slice_group_change_direction_flag               |1  |u(1)  |
 655     |       slice_group_change_rate_minus1                  |1  |ue(v) |
 656 #endif
 657             break;
 658         case 6:
 659 #if 0
 660     |       slice_group_id_cnt_minus1                       |1  |ue(v) |
 661     |       for (i = 0; i <= slice_group_id_cnt_minus1; i++)|   |      |
 662     |           slice_group_id[i]                           |1  |u(v)  |
 663 #endif
 664             break;
 665         }
 666     }
 667     pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
 668     pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
 669     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
 670         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
 671         goto fail;
 672     }
 673
 674     pps->weighted_pred                        = get_bits1(&h->gb);
 675     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
 676     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 677     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 678     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
 679     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
 680     pps->constrained_intra_pred               = get_bits1(&h->gb);
 681     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
 682
 683     pps->transform_8x8_mode = 0;
 684     // contents of sps/pps can change even if id doesn't, so reinit
 685     h->dequant_coeff_pps = -1;
 686     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
 687            sizeof(pps->scaling_matrix4));
 688     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
 689            sizeof(pps->scaling_matrix8));
 690
 691     bits_left = bit_length - get_bits_count(&h->gb);
 692     if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
 693         pps->transform_8x8_mode = get_bits1(&h->gb);
 694         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
 695                                 pps->scaling_matrix4, pps->scaling_matrix8);
 696         // second_chroma_qp_index_offset
 697         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
 698     } else {
 699         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
 700     }
 701
 702     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
 703     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
 704     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
 705         pps->chroma_qp_diff = 1;
 706
 707     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 708         av_log(h->avctx, AV_LOG_DEBUG,
 709                "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
 710                pps_id, pps->sps_id,
 711                pps->cabac ? "CABAC" : "CAVLC",
 712                pps->slice_group_count,
 713                pps->ref_count[0], pps->ref_count[1],
 714                pps->weighted_pred ? "weighted" : "",
 715                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
 716                pps->deblocking_filter_parameters_present ? "LPAR" : "",
 717                pps->constrained_intra_pred ? "CONSTR" : "",
 718                pps->redundant_pic_cnt_present ? "REDU" : "",
 719                pps->transform_8x8_mode ? "8x8DCT" : "");
 720     }
 721
 722     av_free(h->pps_buffers[pps_id]);
 723     h->pps_buffers[pps_id] = pps;
 724     return 0;
 725
 726 fail:
 727     av_free(pps);
 728     return -1;
 729 }