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 Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; 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[3][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 };
  79
  80 static const uint8_t default_scaling4[2][16] = {
  81     {  6, 13, 20, 28, 13, 20, 28, 32,
  82       20, 28, 32, 37, 28, 32, 37, 42 },
  83     { 10, 14, 20, 24, 14, 20, 24, 27,
  84       20, 24, 27, 30, 24, 27, 30, 34 }
  85 };
  86
  87 static const uint8_t default_scaling8[2][64] = {
  88     {  6, 10, 13, 16, 18, 23, 25, 27,
  89       10, 11, 16, 18, 23, 25, 27, 29,
  90       13, 16, 18, 23, 25, 27, 29, 31,
  91       16, 18, 23, 25, 27, 29, 31, 33,
  92       18, 23, 25, 27, 29, 31, 33, 36,
  93       23, 25, 27, 29, 31, 33, 36, 38,
  94       25, 27, 29, 31, 33, 36, 38, 40,
  95       27, 29, 31, 33, 36, 38, 40, 42 },
  96     {  9, 13, 15, 17, 19, 21, 22, 24,
  97       13, 13, 17, 19, 21, 22, 24, 25,
  98       15, 17, 19, 21, 22, 24, 25, 27,
  99       17, 19, 21, 22, 24, 25, 27, 28,
 100       19, 21, 22, 24, 25, 27, 28, 30,
 101       21, 22, 24, 25, 27, 28, 30, 32,
 102       22, 24, 25, 27, 28, 30, 32, 33,
 103       24, 25, 27, 28, 30, 32, 33, 35 }
 104 };
 105
 106 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
 107 {
 108     int cpb_count, i;
 109     cpb_count = get_ue_golomb_31(&h->gb) + 1;
 110
 111     if (cpb_count > 32U) {
 112         av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
 113         return AVERROR_INVALIDDATA;
 114     }
 115
 116     get_bits(&h->gb, 4); /* bit_rate_scale */
 117     get_bits(&h->gb, 4); /* cpb_size_scale */
 118     for (i = 0; i < cpb_count; i++) {
 119         get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
 120         get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
 121         get_bits1(&h->gb);          /* cbr_flag */
 122     }
 123     sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
 124     sps->cpb_removal_delay_length         = get_bits(&h->gb, 5) + 1;
 125     sps->dpb_output_delay_length          = get_bits(&h->gb, 5) + 1;
 126     sps->time_offset_length               = get_bits(&h->gb, 5);
 127     sps->cpb_cnt                          = cpb_count;
 128     return 0;
 129 }
 130
 131 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
 132 {
 133     int aspect_ratio_info_present_flag;
 134     unsigned int aspect_ratio_idc;
 135
 136     aspect_ratio_info_present_flag = get_bits1(&h->gb);
 137
 138     if (aspect_ratio_info_present_flag) {
 139         aspect_ratio_idc = get_bits(&h->gb, 8);
 140         if (aspect_ratio_idc == EXTENDED_SAR) {
 141             sps->sar.num = get_bits(&h->gb, 16);
 142             sps->sar.den = get_bits(&h->gb, 16);
 143         } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
 144             sps->sar = pixel_aspect[aspect_ratio_idc];
 145         } else {
 146             av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
 147             return AVERROR_INVALIDDATA;
 148         }
 149     } else {
 150         sps->sar.num =
 151         sps->sar.den = 0;
 152     }
 153
 154     if (get_bits1(&h->gb))      /* overscan_info_present_flag */
 155         get_bits1(&h->gb);      /* overscan_appropriate_flag */
 156
 157     sps->video_signal_type_present_flag = get_bits1(&h->gb);
 158     if (sps->video_signal_type_present_flag) {
 159         get_bits(&h->gb, 3);                 /* video_format */
 160         sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
 161
 162         sps->colour_description_present_flag = get_bits1(&h->gb);
 163         if (sps->colour_description_present_flag) {
 164             sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
 165             sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
 166             sps->colorspace      = get_bits(&h->gb, 8); /* matrix_coefficients */
 167             if (sps->color_primaries >= AVCOL_PRI_NB)
 168                 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
 169             if (sps->color_trc >= AVCOL_TRC_NB)
 170                 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
 171             if (sps->colorspace >= AVCOL_SPC_NB)
 172                 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
 173         }
 174     }
 175
 176     /* chroma_location_info_present_flag */
 177     if (get_bits1(&h->gb)) {
 178         /* chroma_sample_location_type_top_field */
 179         h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
 180         get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
 181     }
 182
 183     sps->timing_info_present_flag = get_bits1(&h->gb);
 184     if (sps->timing_info_present_flag) {
 185         sps->num_units_in_tick = get_bits_long(&h->gb, 32);
 186         sps->time_scale        = get_bits_long(&h->gb, 32);
 187         if (!sps->num_units_in_tick || !sps->time_scale) {
 188             av_log(h->avctx, AV_LOG_ERROR,
 189                    "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n",
 190                    sps->time_scale, sps->num_units_in_tick);
 191             return AVERROR_INVALIDDATA;
 192         }
 193         sps->fixed_frame_rate_flag = get_bits1(&h->gb);
 194     }
 195
 196     sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
 197     if (sps->nal_hrd_parameters_present_flag)
 198         if (decode_hrd_parameters(h, sps) < 0)
 199             return AVERROR_INVALIDDATA;
 200     sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
 201     if (sps->vcl_hrd_parameters_present_flag)
 202         if (decode_hrd_parameters(h, sps) < 0)
 203             return AVERROR_INVALIDDATA;
 204     if (sps->nal_hrd_parameters_present_flag ||
 205         sps->vcl_hrd_parameters_present_flag)
 206         get_bits1(&h->gb);     /* low_delay_hrd_flag */
 207     sps->pic_struct_present_flag = get_bits1(&h->gb);
 208
 209     sps->bitstream_restriction_flag = get_bits1(&h->gb);
 210     if (sps->bitstream_restriction_flag) {
 211         get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
 212         get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
 213         get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
 214         get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
 215         get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
 216         sps->num_reorder_frames = get_ue_golomb(&h->gb);
 217         get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
 218
 219         if (get_bits_left(&h->gb) < 0) {
 220             sps->num_reorder_frames         = 0;
 221             sps->bitstream_restriction_flag = 0;
 222         }
 223
 224         if (sps->num_reorder_frames > 16U
 225             /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
 226             av_log(h->avctx, AV_LOG_ERROR,
 227                    "Clipping illegal num_reorder_frames %d\n",
 228                    sps->num_reorder_frames);
 229             sps->num_reorder_frames = 16;
 230             return AVERROR_INVALIDDATA;
 231         }
 232     }
 233     if (get_bits_left(&h->gb) < 0) {
 234         av_log(h->avctx, AV_LOG_ERROR,
 235                "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
 236         return AVERROR_INVALIDDATA;
 237     }
 238
 239     return 0;
 240 }
 241
 242 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
 243                                 const uint8_t *jvt_list,
 244                                 const uint8_t *fallback_list)
 245 {
 246     int i, last = 8, next = 8;
 247     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
 248     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
 249         memcpy(factors, fallback_list, size * sizeof(uint8_t));
 250     else
 251         for (i = 0; i < size; i++) {
 252             if (next)
 253                 next = (last + get_se_golomb(&h->gb)) & 0xff;
 254             if (!i && !next) { /* matrix not written, we use the preset one */
 255                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
 256                 break;
 257             }
 258             last = factors[scan[i]] = next ? next : last;
 259         }
 260 }
 261
 262 static void decode_scaling_matrices(H264Context *h, SPS *sps,
 263                                     PPS *pps, int is_sps,
 264                                     uint8_t(*scaling_matrix4)[16],
 265                                     uint8_t(*scaling_matrix8)[64])
 266 {
 267     int fallback_sps = !is_sps && sps->scaling_matrix_present;
 268     const uint8_t *fallback[4] = {
 269         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
 270         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
 271         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
 272         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
 273     };
 274     if (get_bits1(&h->gb)) {
 275         sps->scaling_matrix_present |= is_sps;
 276         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
 277         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
 278         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
 279         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
 280         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
 281         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
 282         if (is_sps || pps->transform_8x8_mode) {
 283             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
 284             if (sps->chroma_format_idc == 3) {
 285                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
 286                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
 287             }
 288             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
 289             if (sps->chroma_format_idc == 3) {
 290                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
 291                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
 292             }
 293         }
 294     }
 295 }
 296
 297 int ff_h264_decode_seq_parameter_set(H264Context *h)
 298 {
 299     int profile_idc, level_idc, constraint_set_flags = 0;
 300     unsigned int sps_id;
 301     int i, log2_max_frame_num_minus4;
 302     SPS *sps;
 303
 304     profile_idc           = get_bits(&h->gb, 8);
 305     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
 306     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
 307     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
 308     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
 309     get_bits(&h->gb, 4); // reserved
 310     level_idc = get_bits(&h->gb, 8);
 311     sps_id    = get_ue_golomb_31(&h->gb);
 312
 313     if (sps_id >= MAX_SPS_COUNT) {
 314         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
 315         return AVERROR_INVALIDDATA;
 316     }
 317     sps = av_mallocz(sizeof(SPS));
 318     if (!sps)
 319         return AVERROR(ENOMEM);
 320
 321     sps->sps_id               = sps_id;
 322     sps->time_offset_length   = 24;
 323     sps->profile_idc          = profile_idc;
 324     sps->constraint_set_flags = constraint_set_flags;
 325     sps->level_idc            = level_idc;
 326
 327     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
 328     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
 329     sps->scaling_matrix_present = 0;
 330
 331     if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
 332         sps->profile_idc == 122 || sps->profile_idc == 244 ||
 333         sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
 334         sps->profile_idc ==  86 || sps->profile_idc == 118 ||
 335         sps->profile_idc == 128 || sps->profile_idc == 144) {
 336         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
 337         if (sps->chroma_format_idc > 3) {
 338             av_log(h->avctx, AV_LOG_ERROR,
 339                    "chroma_format_idc %u out of range\n",
 340                    sps->chroma_format_idc);
 341             goto fail;
 342         } else if (sps->chroma_format_idc == 3) {
 343             sps->residual_color_transform_flag = get_bits1(&h->gb);
 344         }
 345         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
 346         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
 347         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
 348             avpriv_request_sample(h->avctx,
 349                                   "Different chroma and luma bit depth");
 350             goto fail;
 351         }
 352         sps->transform_bypass = get_bits1(&h->gb);
 353         decode_scaling_matrices(h, sps, NULL, 1,
 354                                 sps->scaling_matrix4, sps->scaling_matrix8);
 355     } else {
 356         sps->chroma_format_idc = 1;
 357         sps->bit_depth_luma    = 8;
 358         sps->bit_depth_chroma  = 8;
 359     }
 360
 361     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
 362     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
 363         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
 364         av_log(h->avctx, AV_LOG_ERROR,
 365                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
 366                log2_max_frame_num_minus4);
 367         goto fail;
 368     }
 369     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
 370
 371     sps->poc_type = get_ue_golomb_31(&h->gb);
 372
 373     if (sps->poc_type == 0) { // FIXME #define
 374         sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
 375     } else if (sps->poc_type == 1) { // FIXME #define
 376         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
 377         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
 378         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
 379         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
 380
 381         if ((unsigned)sps->poc_cycle_length >=
 382             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
 383             av_log(h->avctx, AV_LOG_ERROR,
 384                    "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
 385             goto fail;
 386         }
 387
 388         for (i = 0; i < sps->poc_cycle_length; i++)
 389             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
 390     } else if (sps->poc_type != 2) {
 391         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
 392         goto fail;
 393     }
 394
 395     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
 396     if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
 397         sps->ref_frame_count >= 32U) {
 398         av_log(h->avctx, AV_LOG_ERROR,
 399                "too many reference frames %d\n", sps->ref_frame_count);
 400         goto fail;
 401     }
 402     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
 403     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
 404     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
 405     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
 406         (unsigned)sps->mb_height >= INT_MAX / 16 ||
 407         av_image_check_size(16 * sps->mb_width,
 408                             16 * sps->mb_height, 0, h->avctx)) {
 409         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
 410         goto fail;
 411     }
 412
 413     sps->frame_mbs_only_flag = get_bits1(&h->gb);
 414     if (!sps->frame_mbs_only_flag)
 415         sps->mb_aff = get_bits1(&h->gb);
 416     else
 417         sps->mb_aff = 0;
 418
 419     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
 420     if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
 421         av_log(h->avctx, AV_LOG_ERROR,
 422                "This stream was generated by a broken encoder, invalid 8x8 inference\n");
 423         goto fail;
 424     }
 425
 426 #ifndef ALLOW_INTERLACE
 427     if (sps->mb_aff)
 428         av_log(h->avctx, AV_LOG_ERROR,
 429                "MBAFF support not included; enable it at compile-time.\n");
 430 #endif
 431     sps->crop = get_bits1(&h->gb);
 432     if (sps->crop) {
 433         int crop_left   = get_ue_golomb(&h->gb);
 434         int crop_right  = get_ue_golomb(&h->gb);
 435         int crop_top    = get_ue_golomb(&h->gb);
 436         int crop_bottom = get_ue_golomb(&h->gb);
 437
 438         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
 439             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
 440                                            "values are l:%u r:%u t:%u b:%u\n",
 441                    crop_left, crop_right, crop_top, crop_bottom);
 442
 443             sps->crop_left   =
 444             sps->crop_right  =
 445             sps->crop_top    =
 446             sps->crop_bottom = 0;
 447         } else {
 448             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
 449             int hsub   = (sps->chroma_format_idc == 1 ||
 450                           sps->chroma_format_idc == 2) ? 1 : 0;
 451             int step_x = 1 << hsub;
 452             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
 453
 454             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
 455                 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
 456                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
 457                 av_log(h->avctx, AV_LOG_WARNING,
 458                        "Reducing left cropping to %d "
 459                        "chroma samples to preserve alignment.\n",
 460                        crop_left);
 461             }
 462
 463             sps->crop_left   = crop_left   * step_x;
 464             sps->crop_right  = crop_right  * step_x;
 465             sps->crop_top    = crop_top    * step_y;
 466             sps->crop_bottom = crop_bottom * step_y;
 467         }
 468     } else {
 469         sps->crop_left   =
 470         sps->crop_right  =
 471         sps->crop_top    =
 472         sps->crop_bottom =
 473         sps->crop        = 0;
 474     }
 475
 476     sps->vui_parameters_present_flag = get_bits1(&h->gb);
 477     if (sps->vui_parameters_present_flag) {
 478         int ret = decode_vui_parameters(h, sps);
 479         if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
 480             goto fail;
 481     }
 482
 483     if (!sps->sar.den)
 484         sps->sar.den = 1;
 485
 486     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 487         static const char csp[4][5] = { "Gray", "420", "422", "444" };
 488         av_log(h->avctx, AV_LOG_DEBUG,
 489                "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
 490                sps_id, sps->profile_idc, sps->level_idc,
 491                sps->poc_type,
 492                sps->ref_frame_count,
 493                sps->mb_width, sps->mb_height,
 494                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 495                sps->direct_8x8_inference_flag ? "8B8" : "",
 496                sps->crop_left, sps->crop_right,
 497                sps->crop_top, sps->crop_bottom,
 498                sps->vui_parameters_present_flag ? "VUI" : "",
 499                csp[sps->chroma_format_idc],
 500                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
 501                sps->timing_info_present_flag ? sps->time_scale : 0);
 502     }
 503     sps->new = 1;
 504
 505     av_free(h->sps_buffers[sps_id]);
 506     h->sps_buffers[sps_id] = sps;
 507     h->sps                 = *sps;
 508
 509     return 0;
 510
 511 fail:
 512     av_free(sps);
 513     return -1;
 514 }
 515
 516 static void build_qp_table(PPS *pps, int t, int index, const int depth)
 517 {
 518     int i;
 519     const int max_qp = 51 + 6 * (depth - 8);
 520     for (i = 0; i < max_qp + 1; i++)
 521         pps->chroma_qp_table[t][i] =
 522             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
 523 }
 524
 525 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
 526 {
 527     unsigned int pps_id = get_ue_golomb(&h->gb);
 528     PPS *pps;
 529     const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
 530     int bits_left;
 531
 532     if (pps_id >= MAX_PPS_COUNT) {
 533         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
 534         return AVERROR_INVALIDDATA;
 535     } else if (h->sps.bit_depth_luma > 10) {
 536         av_log(h->avctx, AV_LOG_ERROR,
 537                "Unimplemented luma bit depth=%d (max=10)\n",
 538                h->sps.bit_depth_luma);
 539         return AVERROR_PATCHWELCOME;
 540     }
 541
 542     pps = av_mallocz(sizeof(PPS));
 543     if (!pps)
 544         return AVERROR(ENOMEM);
 545     pps->sps_id = get_ue_golomb_31(&h->gb);
 546     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
 547         h->sps_buffers[pps->sps_id] == NULL) {
 548         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
 549         goto fail;
 550     }
 551
 552     pps->cabac             = get_bits1(&h->gb);
 553     pps->pic_order_present = get_bits1(&h->gb);
 554     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
 555     if (pps->slice_group_count > 1) {
 556         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
 557         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
 558         switch (pps->mb_slice_group_map_type) {
 559         case 0:
 560 #if 0
 561     |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
 562     |           run_length[i]                               |1  |ue(v) |
 563 #endif
 564             break;
 565         case 2:
 566 #if 0
 567     |       for (i = 0; i < num_slice_groups_minus1; i++) { |   |      |
 568     |           top_left_mb[i]                              |1  |ue(v) |
 569     |           bottom_right_mb[i]                          |1  |ue(v) |
 570     |       }                                               |   |      |
 571 #endif
 572             break;
 573         case 3:
 574         case 4:
 575         case 5:
 576 #if 0
 577     |       slice_group_change_direction_flag               |1  |u(1)  |
 578     |       slice_group_change_rate_minus1                  |1  |ue(v) |
 579 #endif
 580             break;
 581         case 6:
 582 #if 0
 583     |       slice_group_id_cnt_minus1                       |1  |ue(v) |
 584     |       for (i = 0; i <= slice_group_id_cnt_minus1; i++)|   |      |
 585     |           slice_group_id[i]                           |1  |u(v)  |
 586 #endif
 587             break;
 588         }
 589     }
 590     pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
 591     pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
 592     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
 593         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
 594         goto fail;
 595     }
 596
 597     pps->weighted_pred                        = get_bits1(&h->gb);
 598     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
 599     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 600     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 601     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
 602     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
 603     pps->constrained_intra_pred               = get_bits1(&h->gb);
 604     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
 605
 606     pps->transform_8x8_mode = 0;
 607     // contents of sps/pps can change even if id doesn't, so reinit
 608     h->dequant_coeff_pps = -1;
 609     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
 610            sizeof(pps->scaling_matrix4));
 611     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
 612            sizeof(pps->scaling_matrix8));
 613
 614     bits_left = bit_length - get_bits_count(&h->gb);
 615     if (bits_left && (bits_left > 8 ||
 616                       show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
 617         pps->transform_8x8_mode = get_bits1(&h->gb);
 618         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
 619                                 pps->scaling_matrix4, pps->scaling_matrix8);
 620         // second_chroma_qp_index_offset
 621         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
 622     } else {
 623         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
 624     }
 625
 626     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
 627                    h->sps.bit_depth_luma);
 628     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
 629                    h->sps.bit_depth_luma);
 630     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
 631         pps->chroma_qp_diff = 1;
 632
 633     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 634         av_log(h->avctx, AV_LOG_DEBUG,
 635                "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
 636                pps_id, pps->sps_id,
 637                pps->cabac ? "CABAC" : "CAVLC",
 638                pps->slice_group_count,
 639                pps->ref_count[0], pps->ref_count[1],
 640                pps->weighted_pred ? "weighted" : "",
 641                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
 642                pps->deblocking_filter_parameters_present ? "LPAR" : "",
 643                pps->constrained_intra_pred ? "CONSTR" : "",
 644                pps->redundant_pic_cnt_present ? "REDU" : "",
 645                pps->transform_8x8_mode ? "8x8DCT" : "");
 646     }
 647
 648     av_free(h->pps_buffers[pps_id]);
 649     h->pps_buffers[pps_id] = pps;
 650     return 0;
 651
 652 fail:
 653     av_free(pps);
 654     return -1;
 655 }