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