src/third_party/ffmpeg/libavcodec/h264_ps.c

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
   3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * H.264 / AVC / MPEG4 part10 parameter set decoding.
  25  * @author Michael Niedermayer <michaelni@gmx.at>
  26  */
  27
  28 #include <inttypes.h>
  29
  30 #include "libavutil/imgutils.h"
  31 #include "internal.h"
  32 #include "avcodec.h"
  33 #include "h264.h"
  34 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
  35 #include "golomb.h"
  36
  37 #define MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
  38 #define MIN_LOG2_MAX_FRAME_NUM    4
  39
  40 static const AVRational pixel_aspect[17] = {
  41     {   0,  1 },
  42     {   1,  1 },
  43     {  12, 11 },
  44     {  10, 11 },
  45     {  16, 11 },
  46     {  40, 33 },
  47     {  24, 11 },
  48     {  20, 11 },
  49     {  32, 11 },
  50     {  80, 33 },
  51     {  18, 11 },
  52     {  15, 11 },
  53     {  64, 33 },
  54     { 160, 99 },
  55     {   4,  3 },
  56     {   3,  2 },
  57     {   2,  1 },
  58 };
  59
  60 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
  61
  62 #define CHROMA_QP_TABLE_END(d)                                          \
  63     QP(0,  d), QP(1,  d), QP(2,  d), QP(3,  d), QP(4,  d), QP(5,  d),   \
  64     QP(6,  d), QP(7,  d), QP(8,  d), QP(9,  d), QP(10, d), QP(11, d),   \
  65     QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d),   \
  66     QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d),   \
  67     QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d),   \
  68     QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d),   \
  69     QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d),   \
  70     QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d),   \
  71     QP(39, d), QP(39, d), QP(39, d), QP(39, d)
  72
  73 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
  74     { CHROMA_QP_TABLE_END(8) },
  75     { 0, 1, 2, 3, 4, 5,
  76       CHROMA_QP_TABLE_END(9) },
  77     { 0, 1, 2, 3,  4,  5,
  78       6, 7, 8, 9, 10, 11,
  79       CHROMA_QP_TABLE_END(10) },
  80     { 0,  1, 2, 3,  4,  5,
  81       6,  7, 8, 9, 10, 11,
  82       12,13,14,15, 16, 17,
  83       CHROMA_QP_TABLE_END(11) },
  84     { 0,  1, 2, 3,  4,  5,
  85       6,  7, 8, 9, 10, 11,
  86       12,13,14,15, 16, 17,
  87       18,19,20,21, 22, 23,
  88       CHROMA_QP_TABLE_END(12) },
  89     { 0,  1, 2, 3,  4,  5,
  90       6,  7, 8, 9, 10, 11,
  91       12,13,14,15, 16, 17,
  92       18,19,20,21, 22, 23,
  93       24,25,26,27, 28, 29,
  94       CHROMA_QP_TABLE_END(13) },
  95     { 0,  1, 2, 3,  4,  5,
  96       6,  7, 8, 9, 10, 11,
  97       12,13,14,15, 16, 17,
  98       18,19,20,21, 22, 23,
  99       24,25,26,27, 28, 29,
 100       30,31,32,33, 34, 35,
 101       CHROMA_QP_TABLE_END(14) },
 102 };
 103
 104 static const uint8_t default_scaling4[2][16] = {
 105     {  6, 13, 20, 28, 13, 20, 28, 32,
 106       20, 28, 32, 37, 28, 32, 37, 42 },
 107     { 10, 14, 20, 24, 14, 20, 24, 27,
 108       20, 24, 27, 30, 24, 27, 30, 34 }
 109 };
 110
 111 static const uint8_t default_scaling8[2][64] = {
 112     {  6, 10, 13, 16, 18, 23, 25, 27,
 113       10, 11, 16, 18, 23, 25, 27, 29,
 114       13, 16, 18, 23, 25, 27, 29, 31,
 115       16, 18, 23, 25, 27, 29, 31, 33,
 116       18, 23, 25, 27, 29, 31, 33, 36,
 117       23, 25, 27, 29, 31, 33, 36, 38,
 118       25, 27, 29, 31, 33, 36, 38, 40,
 119       27, 29, 31, 33, 36, 38, 40, 42 },
 120     {  9, 13, 15, 17, 19, 21, 22, 24,
 121       13, 13, 17, 19, 21, 22, 24, 25,
 122       15, 17, 19, 21, 22, 24, 25, 27,
 123       17, 19, 21, 22, 24, 25, 27, 28,
 124       19, 21, 22, 24, 25, 27, 28, 30,
 125       21, 22, 24, 25, 27, 28, 30, 32,
 126       22, 24, 25, 27, 28, 30, 32, 33,
 127       24, 25, 27, 28, 30, 32, 33, 35 }
 128 };
 129
 130 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
 131 {
 132     int cpb_count, i;
 133     cpb_count = get_ue_golomb_31(&h->gb) + 1;
 134
 135     if (cpb_count > 32U) {
 136         av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
 137         return AVERROR_INVALIDDATA;
 138     }
 139
 140     get_bits(&h->gb, 4); /* bit_rate_scale */
 141     get_bits(&h->gb, 4); /* cpb_size_scale */
 142     for (i = 0; i < cpb_count; i++) {
 143         get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
 144         get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
 145         get_bits1(&h->gb);          /* cbr_flag */
 146     }
 147     sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
 148     sps->cpb_removal_delay_length         = get_bits(&h->gb, 5) + 1;
 149     sps->dpb_output_delay_length          = get_bits(&h->gb, 5) + 1;
 150     sps->time_offset_length               = get_bits(&h->gb, 5);
 151     sps->cpb_cnt                          = cpb_count;
 152     return 0;
 153 }
 154
 155 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
 156 {
 157     int aspect_ratio_info_present_flag;
 158     unsigned int aspect_ratio_idc;
 159
 160     aspect_ratio_info_present_flag = get_bits1(&h->gb);
 161
 162     if (aspect_ratio_info_present_flag) {
 163         aspect_ratio_idc = get_bits(&h->gb, 8);
 164         if (aspect_ratio_idc == EXTENDED_SAR) {
 165             sps->sar.num = get_bits(&h->gb, 16);
 166             sps->sar.den = get_bits(&h->gb, 16);
 167         } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
 168             sps->sar = pixel_aspect[aspect_ratio_idc];
 169         } else {
 170             av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
 171             return AVERROR_INVALIDDATA;
 172         }
 173     } else {
 174         sps->sar.num =
 175         sps->sar.den = 0;
 176     }
 177
 178     if (get_bits1(&h->gb))      /* overscan_info_present_flag */
 179         get_bits1(&h->gb);      /* overscan_appropriate_flag */
 180
 181     sps->video_signal_type_present_flag = get_bits1(&h->gb);
 182     if (sps->video_signal_type_present_flag) {
 183         get_bits(&h->gb, 3);                 /* video_format */
 184         sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
 185
 186         sps->colour_description_present_flag = get_bits1(&h->gb);
 187         if (sps->colour_description_present_flag) {
 188             sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
 189             sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
 190             sps->colorspace      = get_bits(&h->gb, 8); /* matrix_coefficients */
 191             if (sps->color_primaries >= AVCOL_PRI_NB)
 192                 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
 193             if (sps->color_trc >= AVCOL_TRC_NB)
 194                 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
 195             if (sps->colorspace >= AVCOL_SPC_NB)
 196                 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
 197         }
 198     }
 199
 200     /* chroma_location_info_present_flag */
 201     if (get_bits1(&h->gb)) {
 202         /* chroma_sample_location_type_top_field */
 203         h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
 204         get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
 205     }
 206
 207     if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
 208         av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
 209         return 0;
 210     }
 211
 212     sps->timing_info_present_flag = get_bits1(&h->gb);
 213     if (sps->timing_info_present_flag) {
 214         sps->num_units_in_tick = get_bits_long(&h->gb, 32);
 215         sps->time_scale        = get_bits_long(&h->gb, 32);
 216         if (!sps->num_units_in_tick || !sps->time_scale) {
 217             av_log(h->avctx, AV_LOG_ERROR,
 218                    "time_scale/num_units_in_tick invalid or unsupported (%"PRIu32"/%"PRIu32")\n",
 219                    sps->time_scale, sps->num_units_in_tick);
 220             return AVERROR_INVALIDDATA;
 221         }
 222         sps->fixed_frame_rate_flag = get_bits1(&h->gb);
 223     }
 224
 225     sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
 226     if (sps->nal_hrd_parameters_present_flag)
 227         if (decode_hrd_parameters(h, sps) < 0)
 228             return AVERROR_INVALIDDATA;
 229     sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
 230     if (sps->vcl_hrd_parameters_present_flag)
 231         if (decode_hrd_parameters(h, sps) < 0)
 232             return AVERROR_INVALIDDATA;
 233     if (sps->nal_hrd_parameters_present_flag ||
 234         sps->vcl_hrd_parameters_present_flag)
 235         get_bits1(&h->gb);     /* low_delay_hrd_flag */
 236     sps->pic_struct_present_flag = get_bits1(&h->gb);
 237     if (!get_bits_left(&h->gb))
 238         return 0;
 239     sps->bitstream_restriction_flag = get_bits1(&h->gb);
 240     if (sps->bitstream_restriction_flag) {
 241         get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
 242         get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
 243         get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
 244         get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
 245         get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
 246         sps->num_reorder_frames = get_ue_golomb(&h->gb);
 247         get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
 248
 249         if (get_bits_left(&h->gb) < 0) {
 250             sps->num_reorder_frames         = 0;
 251             sps->bitstream_restriction_flag = 0;
 252         }
 253
 254         if (sps->num_reorder_frames > 16U
 255             /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
 256             av_log(h->avctx, AV_LOG_ERROR,
 257                    "Clipping illegal num_reorder_frames %d\n",
 258                    sps->num_reorder_frames);
 259             sps->num_reorder_frames = 16;
 260             return AVERROR_INVALIDDATA;
 261         }
 262     }
 263
 264     if (get_bits_left(&h->gb) < 0) {
 265         av_log(h->avctx, AV_LOG_ERROR,
 266                "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
 267         return AVERROR_INVALIDDATA;
 268     }
 269
 270     return 0;
 271 }
 272
 273 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
 274                                 const uint8_t *jvt_list,
 275                                 const uint8_t *fallback_list)
 276 {
 277     int i, last = 8, next = 8;
 278     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
 279     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
 280         memcpy(factors, fallback_list, size * sizeof(uint8_t));
 281     else
 282         for (i = 0; i < size; i++) {
 283             if (next)
 284                 next = (last + get_se_golomb(&h->gb)) & 0xff;
 285             if (!i && !next) { /* matrix not written, we use the preset one */
 286                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
 287                 break;
 288             }
 289             last = factors[scan[i]] = next ? next : last;
 290         }
 291 }
 292
 293 static void decode_scaling_matrices(H264Context *h, SPS *sps,
 294                                     PPS *pps, int is_sps,
 295                                     uint8_t(*scaling_matrix4)[16],
 296                                     uint8_t(*scaling_matrix8)[64])
 297 {
 298     int fallback_sps = !is_sps && sps->scaling_matrix_present;
 299     const uint8_t *fallback[4] = {
 300         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
 301         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
 302         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
 303         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
 304     };
 305     if (get_bits1(&h->gb)) {
 306         sps->scaling_matrix_present |= is_sps;
 307         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
 308         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
 309         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
 310         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
 311         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
 312         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
 313         if (is_sps || pps->transform_8x8_mode) {
 314             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
 315             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
 316             if (sps->chroma_format_idc == 3) {
 317                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
 318                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
 319                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
 320                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
 321             }
 322         }
 323     }
 324 }
 325
 326 int ff_h264_decode_seq_parameter_set(H264Context *h)
 327 {
 328     int profile_idc, level_idc, constraint_set_flags = 0;
 329     unsigned int sps_id;
 330     int i, log2_max_frame_num_minus4;
 331     SPS *sps;
 332
 333     profile_idc           = get_bits(&h->gb, 8);
 334     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
 335     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
 336     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
 337     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
 338     constraint_set_flags |= get_bits1(&h->gb) << 4;   // constraint_set4_flag
 339     constraint_set_flags |= get_bits1(&h->gb) << 5;   // constraint_set5_flag
 340     skip_bits(&h->gb, 2);                             // reserved_zero_2bits
 341     level_idc = get_bits(&h->gb, 8);
 342     sps_id    = get_ue_golomb_31(&h->gb);
 343
 344     if (sps_id >= MAX_SPS_COUNT) {
 345         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
 346         return AVERROR_INVALIDDATA;
 347     }
 348     sps = av_mallocz(sizeof(SPS));
 349     if (!sps)
 350         return AVERROR(ENOMEM);
 351
 352     sps->sps_id               = sps_id;
 353     sps->time_offset_length   = 24;
 354     sps->profile_idc          = profile_idc;
 355     sps->constraint_set_flags = constraint_set_flags;
 356     sps->level_idc            = level_idc;
 357     sps->full_range           = -1;
 358
 359     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
 360     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
 361     sps->scaling_matrix_present = 0;
 362     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
 363
 364     if (sps->profile_idc == 100 ||  // High profile
 365         sps->profile_idc == 110 ||  // High10 profile
 366         sps->profile_idc == 122 ||  // High422 profile
 367         sps->profile_idc == 244 ||  // High444 Predictive profile
 368         sps->profile_idc ==  44 ||  // Cavlc444 profile
 369         sps->profile_idc ==  83 ||  // Scalable Constrained High profile (SVC)
 370         sps->profile_idc ==  86 ||  // Scalable High Intra profile (SVC)
 371         sps->profile_idc == 118 ||  // Stereo High profile (MVC)
 372         sps->profile_idc == 128 ||  // Multiview High profile (MVC)
 373         sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)
 374         sps->profile_idc == 144) {  // old High444 profile
 375         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
 376         if (sps->chroma_format_idc > 3U) {
 377             avpriv_request_sample(h->avctx, "chroma_format_idc %u",
 378                                   sps->chroma_format_idc);
 379             goto fail;
 380         } else if (sps->chroma_format_idc == 3) {
 381             sps->residual_color_transform_flag = get_bits1(&h->gb);
 382             if (sps->residual_color_transform_flag) {
 383                 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
 384                 goto fail;
 385             }
 386         }
 387         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
 388         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
 389         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
 390             avpriv_request_sample(h->avctx,
 391                                   "Different chroma and luma bit depth");
 392             goto fail;
 393         }
 394         if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
 395             av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
 396                    sps->bit_depth_luma, sps->bit_depth_chroma);
 397             goto fail;
 398         }
 399         sps->transform_bypass = get_bits1(&h->gb);
 400         decode_scaling_matrices(h, sps, NULL, 1,
 401                                 sps->scaling_matrix4, sps->scaling_matrix8);
 402     } else {
 403         sps->chroma_format_idc = 1;
 404         sps->bit_depth_luma    = 8;
 405         sps->bit_depth_chroma  = 8;
 406     }
 407
 408     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
 409     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
 410         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
 411         av_log(h->avctx, AV_LOG_ERROR,
 412                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
 413                log2_max_frame_num_minus4);
 414         goto fail;
 415     }
 416     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
 417
 418     sps->poc_type = get_ue_golomb_31(&h->gb);
 419
 420     if (sps->poc_type == 0) { // FIXME #define
 421         unsigned t = get_ue_golomb(&h->gb);
 422         if (t>12) {
 423             av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
 424             goto fail;
 425         }
 426         sps->log2_max_poc_lsb = t + 4;
 427     } else if (sps->poc_type == 1) { // FIXME #define
 428         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
 429         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
 430         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
 431         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
 432
 433         if ((unsigned)sps->poc_cycle_length >=
 434             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
 435             av_log(h->avctx, AV_LOG_ERROR,
 436                    "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
 437             goto fail;
 438         }
 439
 440         for (i = 0; i < sps->poc_cycle_length; i++)
 441             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
 442     } else if (sps->poc_type != 2) {
 443         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
 444         goto fail;
 445     }
 446
 447     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
 448     if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
 449         sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
 450     if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
 451         sps->ref_frame_count > 16U) {
 452         av_log(h->avctx, AV_LOG_ERROR,
 453                "too many reference frames %d\n", sps->ref_frame_count);
 454         goto fail;
 455     }
 456     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
 457     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
 458     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
 459     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
 460         (unsigned)sps->mb_height >= INT_MAX / 16 ||
 461         av_image_check_size(16 * sps->mb_width,
 462                             16 * sps->mb_height, 0, h->avctx)) {
 463         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
 464         goto fail;
 465     }
 466
 467     sps->frame_mbs_only_flag = get_bits1(&h->gb);
 468     if (!sps->frame_mbs_only_flag)
 469         sps->mb_aff = get_bits1(&h->gb);
 470     else
 471         sps->mb_aff = 0;
 472
 473     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
 474
 475 #ifndef ALLOW_INTERLACE
 476     if (sps->mb_aff)
 477         av_log(h->avctx, AV_LOG_ERROR,
 478                "MBAFF support not included; enable it at compile-time.\n");
 479 #endif
 480     sps->crop = get_bits1(&h->gb);
 481     if (sps->crop) {
 482         int crop_left   = get_ue_golomb(&h->gb);
 483         int crop_right  = get_ue_golomb(&h->gb);
 484         int crop_top    = get_ue_golomb(&h->gb);
 485         int crop_bottom = get_ue_golomb(&h->gb);
 486         int width  = 16 * sps->mb_width;
 487         int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
 488
 489         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
 490             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
 491                                            "values are l:%d r:%d t:%d b:%d\n",
 492                    crop_left, crop_right, crop_top, crop_bottom);
 493
 494             sps->crop_left   =
 495             sps->crop_right  =
 496             sps->crop_top    =
 497             sps->crop_bottom = 0;
 498         } else {
 499             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
 500             int hsub   = (sps->chroma_format_idc == 1 ||
 501                           sps->chroma_format_idc == 2) ? 1 : 0;
 502             int step_x = 1 << hsub;
 503             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
 504
 505             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
 506                 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
 507                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
 508                 av_log(h->avctx, AV_LOG_WARNING,
 509                        "Reducing left cropping to %d "
 510                        "chroma samples to preserve alignment.\n",
 511                        crop_left);
 512             }
 513
 514             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
 515                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
 516                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
 517                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
 518                 (crop_left + crop_right ) * step_x >= width ||
 519                 (crop_top  + crop_bottom) * step_y >= height
 520             ) {
 521                 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);
 522                 goto fail;
 523             }
 524
 525             sps->crop_left   = crop_left   * step_x;
 526             sps->crop_right  = crop_right  * step_x;
 527             sps->crop_top    = crop_top    * step_y;
 528             sps->crop_bottom = crop_bottom * step_y;
 529         }
 530     } else {
 531         sps->crop_left   =
 532         sps->crop_right  =
 533         sps->crop_top    =
 534         sps->crop_bottom =
 535         sps->crop        = 0;
 536     }
 537
 538     sps->vui_parameters_present_flag = get_bits1(&h->gb);
 539     if (sps->vui_parameters_present_flag) {
 540         int ret = decode_vui_parameters(h, sps);
 541         if (ret < 0)
 542             goto fail;
 543     }
 544
 545     if (!sps->sar.den)
 546         sps->sar.den = 1;
 547
 548     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 549         static const char csp[4][5] = { "Gray", "420", "422", "444" };
 550         av_log(h->avctx, AV_LOG_DEBUG,
 551                "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",
 552                sps_id, sps->profile_idc, sps->level_idc,
 553                sps->poc_type,
 554                sps->ref_frame_count,
 555                sps->mb_width, sps->mb_height,
 556                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 557                sps->direct_8x8_inference_flag ? "8B8" : "",
 558                sps->crop_left, sps->crop_right,
 559                sps->crop_top, sps->crop_bottom,
 560                sps->vui_parameters_present_flag ? "VUI" : "",
 561                csp[sps->chroma_format_idc],
 562                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
 563                sps->timing_info_present_flag ? sps->time_scale : 0,
 564                sps->bit_depth_luma,
 565                sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
 566                );
 567     }
 568     sps->new = 1;
 569
 570     av_free(h->sps_buffers[sps_id]);
 571     h->sps_buffers[sps_id] = sps;
 572
 573     return 0;
 574
 575 fail:
 576     av_free(sps);
 577     return -1;
 578 }
 579
 580 static void build_qp_table(PPS *pps, int t, int index, const int depth)
 581 {
 582     int i;
 583     const int max_qp = 51 + 6 * (depth - 8);
 584     for (i = 0; i < max_qp + 1; i++)
 585         pps->chroma_qp_table[t][i] =
 586             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
 587 }
 588
 589 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
 590 {
 591     const SPS *sps = h->sps_buffers[pps->sps_id];
 592     int profile_idc = sps->profile_idc;
 593
 594     if ((profile_idc == 66 || profile_idc == 77 ||
 595          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
 596         av_log(h->avctx, AV_LOG_VERBOSE,
 597                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 598         return 0;
 599     }
 600
 601     return 1;
 602 }
 603
 604 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
 605 {
 606     unsigned int pps_id = get_ue_golomb(&h->gb);
 607     PPS *pps;
 608     SPS *sps;
 609     int qp_bd_offset;
 610     int bits_left;
 611
 612     if (pps_id >= MAX_PPS_COUNT) {
 613         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
 614         return AVERROR_INVALIDDATA;
 615     }
 616
 617     pps = av_mallocz(sizeof(PPS));
 618     if (!pps)
 619         return AVERROR(ENOMEM);
 620     pps->sps_id = get_ue_golomb_31(&h->gb);
 621     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
 622         !h->sps_buffers[pps->sps_id]) {
 623         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
 624         goto fail;
 625     }
 626     sps = h->sps_buffers[pps->sps_id];
 627     qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
 628     if (sps->bit_depth_luma > 14) {
 629         av_log(h->avctx, AV_LOG_ERROR,
 630                "Invalid luma bit depth=%d\n",
 631                sps->bit_depth_luma);
 632         goto fail;
 633     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
 634         av_log(h->avctx, AV_LOG_ERROR,
 635                "Unimplemented luma bit depth=%d\n",
 636                sps->bit_depth_luma);
 637         goto fail;
 638     }
 639
 640     pps->cabac             = get_bits1(&h->gb);
 641     pps->pic_order_present = get_bits1(&h->gb);
 642     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
 643     if (pps->slice_group_count > 1) {
 644         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
 645         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
 646         switch (pps->mb_slice_group_map_type) {
 647         case 0:
 648 #if 0
 649     |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
 650     |           run_length[i]                               |1  |ue(v) |
 651 #endif
 652             break;
 653         case 2:
 654 #if 0
 655     |       for (i = 0; i < num_slice_groups_minus1; i++) { |   |      |
 656     |           top_left_mb[i]                              |1  |ue(v) |
 657     |           bottom_right_mb[i]                          |1  |ue(v) |
 658     |       }                                               |   |      |
 659 #endif
 660             break;
 661         case 3:
 662         case 4:
 663         case 5:
 664 #if 0
 665     |       slice_group_change_direction_flag               |1  |u(1)  |
 666     |       slice_group_change_rate_minus1                  |1  |ue(v) |
 667 #endif
 668             break;
 669         case 6:
 670 #if 0
 671     |       slice_group_id_cnt_minus1                       |1  |ue(v) |
 672     |       for (i = 0; i <= slice_group_id_cnt_minus1; i++)|   |      |
 673     |           slice_group_id[i]                           |1  |u(v)  |
 674 #endif
 675             break;
 676         }
 677     }
 678     pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
 679     pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
 680     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
 681         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
 682         goto fail;
 683     }
 684
 685     pps->weighted_pred                        = get_bits1(&h->gb);
 686     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
 687     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 688     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 689     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
 690     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
 691     pps->constrained_intra_pred               = get_bits1(&h->gb);
 692     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
 693
 694     pps->transform_8x8_mode = 0;
 695     // contents of sps/pps can change even if id doesn't, so reinit
 696     h->dequant_coeff_pps = -1;
 697     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
 698            sizeof(pps->scaling_matrix4));
 699     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
 700            sizeof(pps->scaling_matrix8));
 701
 702     bits_left = bit_length - get_bits_count(&h->gb);
 703     if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
 704         pps->transform_8x8_mode = get_bits1(&h->gb);
 705         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
 706                                 pps->scaling_matrix4, pps->scaling_matrix8);
 707         // second_chroma_qp_index_offset
 708         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
 709     } else {
 710         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
 711     }
 712
 713     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
 714     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
 715     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
 716         pps->chroma_qp_diff = 1;
 717
 718     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
 719         av_log(h->avctx, AV_LOG_DEBUG,
 720                "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
 721                pps_id, pps->sps_id,
 722                pps->cabac ? "CABAC" : "CAVLC",
 723                pps->slice_group_count,
 724                pps->ref_count[0], pps->ref_count[1],
 725                pps->weighted_pred ? "weighted" : "",
 726                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
 727                pps->deblocking_filter_parameters_present ? "LPAR" : "",
 728                pps->constrained_intra_pred ? "CONSTR" : "",
 729                pps->redundant_pic_cnt_present ? "REDU" : "",
 730                pps->transform_8x8_mode ? "8x8DCT" : "");
 731     }
 732
 733     av_free(h->pps_buffers[pps_id]);
 734     h->pps_buffers[pps_id] = pps;
 735     return 0;
 736
 737 fail:
 738     av_free(pps);
 739     return -1;
 740 }