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