h264_ps.c 26.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
23
 * @file
24 25 26 27
 * H.264 / AVC / MPEG4 part10 parameter set decoding.
 * @author Michael Niedermayer <michaelni@gmx.at>
 */

28
#include "libavutil/imgutils.h"
29 30 31 32 33 34 35 36 37 38
#include "internal.h"
#include "avcodec.h"
#include "h264.h"
#include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
#include "golomb.h"


//#undef NDEBUG
#include <assert.h>

39 40 41
#define MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
#define MIN_LOG2_MAX_FRAME_NUM    4

42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
static const AVRational pixel_aspect[17]={
 {0, 1},
 {1, 1},
 {12, 11},
 {10, 11},
 {16, 11},
 {40, 33},
 {24, 11},
 {20, 11},
 {32, 11},
 {80, 33},
 {18, 11},
 {15, 11},
 {64, 33},
 {160,99},
 {4, 3},
 {3, 2},
 {2, 1},
};

62 63 64 65 66 67 68 69 70 71 72 73 74
#define QP(qP,depth) ( (qP)+6*((depth)-8) )

#define CHROMA_QP_TABLE_END(d) \
     QP(0,d),  QP(1,d),  QP(2,d),  QP(3,d),  QP(4,d),  QP(5,d),\
     QP(6,d),  QP(7,d),  QP(8,d),  QP(9,d), QP(10,d), QP(11,d),\
    QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
    QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
    QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
    QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
    QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
    QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
    QP(39,d), QP(39,d), QP(39,d), QP(39,d)

75
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
76 77 78 79 80 81 82 83 84 85 86 87
    {
        CHROMA_QP_TABLE_END(8)
    },
    {
        0, 1, 2, 3, 4, 5,
        CHROMA_QP_TABLE_END(9)
    },
    {
        0, 1, 2, 3,  4,  5,
        6, 7, 8, 9, 10, 11,
        CHROMA_QP_TABLE_END(10)
    },
88 89 90 91 92 93 94 95 96 97 98 99 100
    {
        0,  1, 2, 3,  4,  5,
        6,  7, 8, 9, 10, 11,
        12,13,14,15, 16, 17,
        CHROMA_QP_TABLE_END(11)
    },
    {
        0,  1, 2, 3,  4,  5,
        6,  7, 8, 9, 10, 11,
        12,13,14,15, 16, 17,
        18,19,20,21, 22, 23,
        CHROMA_QP_TABLE_END(12)
    },
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
    {
        0,  1, 2, 3,  4,  5,
        6,  7, 8, 9, 10, 11,
        12,13,14,15, 16, 17,
        18,19,20,21, 22, 23,
        24,25,26,27, 28, 29,
        CHROMA_QP_TABLE_END(13)
    },
    {
        0,  1, 2, 3,  4,  5,
        6,  7, 8, 9, 10, 11,
        12,13,14,15, 16, 17,
        18,19,20,21, 22, 23,
        24,25,26,27, 28, 29,
        30,31,32,33, 34, 35,
        CHROMA_QP_TABLE_END(14)
    },
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
};

static const uint8_t default_scaling4[2][16]={
{   6,13,20,28,
   13,20,28,32,
   20,28,32,37,
   28,32,37,42
},{
   10,14,20,24,
   14,20,24,27,
   20,24,27,30,
   24,27,30,34
}};

static const uint8_t default_scaling8[2][64]={
{   6,10,13,16,18,23,25,27,
   10,11,16,18,23,25,27,29,
   13,16,18,23,25,27,29,31,
   16,18,23,25,27,29,31,33,
   18,23,25,27,29,31,33,36,
   23,25,27,29,31,33,36,38,
   25,27,29,31,33,36,38,40,
   27,29,31,33,36,38,40,42
},{
    9,13,15,17,19,21,22,24,
   13,13,17,19,21,22,24,25,
   15,17,19,21,22,24,25,27,
   17,19,21,22,24,25,27,28,
   19,21,22,24,25,27,28,30,
   21,22,24,25,27,28,30,32,
   22,24,25,27,28,30,32,33,
   24,25,27,28,30,32,33,35
}};

static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
    int cpb_count, i;
154
    cpb_count = get_ue_golomb_31(&h->gb) + 1;
155 156

    if(cpb_count > 32U){
157
        av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
158 159 160
        return -1;
    }

161 162
    get_bits(&h->gb, 4); /* bit_rate_scale */
    get_bits(&h->gb, 4); /* cpb_size_scale */
163
    for(i=0; i<cpb_count; i++){
164 165 166
        get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
        get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
        get_bits1(&h->gb);     /* cbr_flag */
167
    }
168 169 170 171
    sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
    sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
    sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
    sps->time_offset_length = get_bits(&h->gb, 5);
172 173 174 175 176 177 178 179
    sps->cpb_cnt = cpb_count;
    return 0;
}

static inline int decode_vui_parameters(H264Context *h, SPS *sps){
    int aspect_ratio_info_present_flag;
    unsigned int aspect_ratio_idc;

180
    aspect_ratio_info_present_flag= get_bits1(&h->gb);
181 182

    if( aspect_ratio_info_present_flag ) {
183
        aspect_ratio_idc= get_bits(&h->gb, 8);
184
        if( aspect_ratio_idc == EXTENDED_SAR ) {
185 186
            sps->sar.num= get_bits(&h->gb, 16);
            sps->sar.den= get_bits(&h->gb, 16);
187 188 189
        }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
            sps->sar=  pixel_aspect[aspect_ratio_idc];
        }else{
190
            av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
191 192 193 194 195 196 197 198
            return -1;
        }
    }else{
        sps->sar.num=
        sps->sar.den= 0;
    }
//            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);

199 200
    if(get_bits1(&h->gb)){      /* overscan_info_present_flag */
        get_bits1(&h->gb);      /* overscan_appropriate_flag */
201 202
    }

203
    sps->video_signal_type_present_flag = get_bits1(&h->gb);
204
    if(sps->video_signal_type_present_flag){
205 206
        get_bits(&h->gb, 3);    /* video_format */
        sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
207

208
        sps->colour_description_present_flag = get_bits1(&h->gb);
209
        if(sps->colour_description_present_flag){
210 211 212
            sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
            sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
            sps->colorspace      = get_bits(&h->gb, 8); /* matrix_coefficients */
213 214 215 216 217 218 219 220 221
            if (sps->color_primaries >= AVCOL_PRI_NB)
                sps->color_primaries  = AVCOL_PRI_UNSPECIFIED;
            if (sps->color_trc >= AVCOL_TRC_NB)
                sps->color_trc  = AVCOL_TRC_UNSPECIFIED;
            if (sps->colorspace >= AVCOL_SPC_NB)
                sps->colorspace  = AVCOL_SPC_UNSPECIFIED;
        }
    }

222 223 224
    if(get_bits1(&h->gb)){      /* chroma_location_info_present_flag */
        h->avctx->chroma_sample_location = get_ue_golomb(&h->gb)+1;  /* chroma_sample_location_type_top_field */
        get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
225 226
    }

227
    sps->timing_info_present_flag = get_bits1(&h->gb);
228
    if(sps->timing_info_present_flag){
229 230
        sps->num_units_in_tick = get_bits_long(&h->gb, 32);
        sps->time_scale = get_bits_long(&h->gb, 32);
231
        if(!sps->num_units_in_tick || !sps->time_scale){
232
            av_log(h->avctx, AV_LOG_ERROR, "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n", sps->time_scale, sps->num_units_in_tick);
233 234
            return -1;
        }
235
        sps->fixed_frame_rate_flag = get_bits1(&h->gb);
236 237
    }

238
    sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
239 240 241
    if(sps->nal_hrd_parameters_present_flag)
        if(decode_hrd_parameters(h, sps) < 0)
            return -1;
242
    sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
243 244 245 246
    if(sps->vcl_hrd_parameters_present_flag)
        if(decode_hrd_parameters(h, sps) < 0)
            return -1;
    if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
247 248
        get_bits1(&h->gb);     /* low_delay_hrd_flag */
    sps->pic_struct_present_flag = get_bits1(&h->gb);
249
    if(!get_bits_left(&h->gb))
250
        return 0;
251
    sps->bitstream_restriction_flag = get_bits1(&h->gb);
252
    if(sps->bitstream_restriction_flag){
253 254 255 256 257 258 259 260 261
        get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
        get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
        get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
        get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
        get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
        sps->num_reorder_frames= get_ue_golomb(&h->gb);
        get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/

        if (get_bits_left(&h->gb) < 0) {
262 263 264 265
            sps->num_reorder_frames=0;
            sps->bitstream_restriction_flag= 0;
        }

266
        if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
267
            av_log(h->avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
268 269 270
            return -1;
        }
    }
271

272 273
    if (get_bits_left(&h->gb) < 0) {
        av_log(h->avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
274
        return AVERROR_INVALIDDATA;
275
    }
276 277 278 279 280 281 282 283

    return 0;
}

static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
                                const uint8_t *jvt_list, const uint8_t *fallback_list){
    int i, last = 8, next = 8;
    const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
284
    if(!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
285 286 287 288
        memcpy(factors, fallback_list, size*sizeof(uint8_t));
    else
    for(i=0;i<size;i++){
        if(next)
289
            next = (last + get_se_golomb(&h->gb)) & 0xff;
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
        if(!i && !next){ /* matrix not written, we use the preset one */
            memcpy(factors, jvt_list, size*sizeof(uint8_t));
            break;
        }
        last = factors[scan[i]] = next ? next : last;
    }
}

static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
                                   uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
    int fallback_sps = !is_sps && sps->scaling_matrix_present;
    const uint8_t *fallback[4] = {
        fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
        fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
        fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
305
        fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
306
    };
307
    if(get_bits1(&h->gb)){
308 309 310 311 312 313 314 315 316
        sps->scaling_matrix_present |= is_sps;
        decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
        decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
        decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
        decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
        decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
        decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
        if(is_sps || pps->transform_8x8_mode){
            decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
317
            decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);  // Inter, Y
318
            if(sps->chroma_format_idc == 3){
319
                decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);  // Intra, Cr
320
                decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);  // Inter, Cr
321
                decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);  // Intra, Cb
322 323
                decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);  // Inter, Cb
            }
324 325 326 327 328
        }
    }
}

int ff_h264_decode_seq_parameter_set(H264Context *h){
329
    int profile_idc, level_idc, constraint_set_flags = 0;
330
    unsigned int sps_id;
331
    int i, log2_max_frame_num_minus4;
332 333
    SPS *sps;

334 335 336 337 338
    profile_idc= get_bits(&h->gb, 8);
    constraint_set_flags |= get_bits1(&h->gb) << 0;   //constraint_set0_flag
    constraint_set_flags |= get_bits1(&h->gb) << 1;   //constraint_set1_flag
    constraint_set_flags |= get_bits1(&h->gb) << 2;   //constraint_set2_flag
    constraint_set_flags |= get_bits1(&h->gb) << 3;   //constraint_set3_flag
339 340 341
    constraint_set_flags |= get_bits1(&h->gb) << 4;   //constraint_set4_flag
    constraint_set_flags |= get_bits1(&h->gb) << 5;   //constraint_set5_flag
    get_bits(&h->gb, 2); // reserved
342 343
    level_idc= get_bits(&h->gb, 8);
    sps_id= get_ue_golomb_31(&h->gb);
344 345

    if(sps_id >= MAX_SPS_COUNT) {
346
        av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
347 348 349 350 351 352
        return -1;
    }
    sps= av_mallocz(sizeof(SPS));
    if(sps == NULL)
        return -1;

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 360 361

    memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
    memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
    sps->scaling_matrix_present = 0;
362
    sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
363

364 365 366 367 368
    if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
        sps->profile_idc == 122 || sps->profile_idc == 244 ||
        sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
        sps->profile_idc ==  86 || sps->profile_idc == 118 ||
        sps->profile_idc == 128 || sps->profile_idc == 144) {
369
        sps->chroma_format_idc= get_ue_golomb_31(&h->gb);
370
        if (sps->chroma_format_idc > 3U) {
371
            av_log(h->avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
372
            goto fail;
373
        } else if(sps->chroma_format_idc == 3) {
374
            sps->residual_color_transform_flag = get_bits1(&h->gb);
375
            if(sps->residual_color_transform_flag) {
376
                av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
377 378
                goto fail;
            }
379
        }
380 381
        sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
        sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
382
        if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
383
            av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
384 385 386
                   sps->bit_depth_luma, sps->bit_depth_chroma);
            goto fail;
        }
387
        sps->transform_bypass = get_bits1(&h->gb);
388 389 390 391 392 393 394
        decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
    }else{
        sps->chroma_format_idc= 1;
        sps->bit_depth_luma   = 8;
        sps->bit_depth_chroma = 8;
    }

395
    log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
396 397
    if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
        log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
398
        av_log(h->avctx, AV_LOG_ERROR,
399 400
               "log2_max_frame_num_minus4 out of range (0-12): %d\n",
               log2_max_frame_num_minus4);
401 402
        goto fail;
    }
403
    sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
404

405
    sps->poc_type= get_ue_golomb_31(&h->gb);
406 407

    if(sps->poc_type == 0){ //FIXME #define
408
        unsigned t = get_ue_golomb(&h->gb);
409
        if(t>12){
410
            av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
411 412 413
            goto fail;
        }
        sps->log2_max_poc_lsb= t + 4;
414
    } else if(sps->poc_type == 1){//FIXME #define
415 416 417 418
        sps->delta_pic_order_always_zero_flag= get_bits1(&h->gb);
        sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
        sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
        sps->poc_cycle_length                = get_ue_golomb(&h->gb);
419 420

        if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
421
            av_log(h->avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
422 423 424 425
            goto fail;
        }

        for(i=0; i<sps->poc_cycle_length; i++)
426
            sps->offset_for_ref_frame[i]= get_se_golomb(&h->gb);
427
    }else if(sps->poc_type != 2){
428
        av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
429 430 431
        goto fail;
    }

432
    sps->ref_frame_count= get_ue_golomb_31(&h->gb);
433
    if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
434
        sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
435
    if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
436
        av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
437 438
        goto fail;
    }
439 440 441
    sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
    sps->mb_width = get_ue_golomb(&h->gb) + 1;
    sps->mb_height= get_ue_golomb(&h->gb) + 1;
442
    if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
443 444
       av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->avctx)){
        av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
445 446 447
        goto fail;
    }

448
    sps->frame_mbs_only_flag= get_bits1(&h->gb);
449
    if(!sps->frame_mbs_only_flag)
450
        sps->mb_aff= get_bits1(&h->gb);
451 452 453
    else
        sps->mb_aff= 0;

454
    sps->direct_8x8_inference_flag= get_bits1(&h->gb);
455 456 457

#ifndef ALLOW_INTERLACE
    if(sps->mb_aff)
458
        av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
459
#endif
460
    sps->crop= get_bits1(&h->gb);
461
    if(sps->crop){
462
        int crop_vertical_limit   = sps->chroma_format_idc  & 2 ? 16 : 8;
463
        int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
464 465 466 467 468 469
        sps->crop_left  = get_ue_golomb(&h->gb);
        sps->crop_right = get_ue_golomb(&h->gb);
        sps->crop_top   = get_ue_golomb(&h->gb);
        sps->crop_bottom= get_ue_golomb(&h->gb);
        if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
            av_log(h->avctx, AV_LOG_DEBUG,
470 471 472 473 474 475 476 477 478 479 480 481
                   "discarding sps cropping, "
                   "original values are l:%u r:%u t:%u b:%u\n",
                   sps->crop_left,
                   sps->crop_right,
                   sps->crop_top,
                   sps->crop_bottom);

            sps->crop_left   =
            sps->crop_right  =
            sps->crop_top    =
            sps->crop_bottom = 0;
        }
482
        if(sps->crop_left || sps->crop_top){
483
            av_log(h->avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ... (left: %d, top: %d)\n", sps->crop_left, sps->crop_top);
484
        }
485
        if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
486
            av_log(h->avctx, AV_LOG_ERROR, "brainfart cropping not supported, cropping disabled (right: %d, bottom: %d)\n", sps->crop_right, sps->crop_bottom);
487 488 489 490 491 492 493
        /* It is very unlikely that partial cropping will make anybody happy.
         * Not cropping at all fixes for example playback of Sisvel 3D streams
         * in applications supporting Sisvel 3D. */
        sps->crop_left  =
        sps->crop_right =
        sps->crop_top   =
        sps->crop_bottom= 0;
494 495 496 497 498 499 500 501
        }
    }else{
        sps->crop_left  =
        sps->crop_right =
        sps->crop_top   =
        sps->crop_bottom= 0;
    }

502
    sps->vui_parameters_present_flag= get_bits1(&h->gb);
503 504 505 506
    if( sps->vui_parameters_present_flag )
        if (decode_vui_parameters(h, sps) < 0)
            goto fail;

507 508 509
    if(!sps->sar.den)
        sps->sar.den= 1;

510
    if(h->avctx->debug&FF_DEBUG_PICT_INFO){
511
        static const char csp[4][5] = { "Gray", "420", "422", "444" };
512
        av_log(h->avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d b%d reo:%d\n",
513 514 515 516 517 518 519 520 521
               sps_id, sps->profile_idc, sps->level_idc,
               sps->poc_type,
               sps->ref_frame_count,
               sps->mb_width, sps->mb_height,
               sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
               sps->direct_8x8_inference_flag ? "8B8" : "",
               sps->crop_left, sps->crop_right,
               sps->crop_top, sps->crop_bottom,
               sps->vui_parameters_present_flag ? "VUI" : "",
522
               csp[sps->chroma_format_idc],
523
               sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
524
               sps->timing_info_present_flag ? sps->time_scale : 0,
525 526
               sps->bit_depth_luma,
               h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
527 528
               );
    }
529
    sps->new = 1;
530 531

    av_free(h->sps_buffers[sps_id]);
532 533 534 535
    h->sps_buffers[sps_id] = sps;
    h->sps                 = *sps;
    h->current_sps_id      = sps_id;

536 537 538 539 540 541 542
    return 0;
fail:
    av_free(sps);
    return -1;
}

static void
543
build_qp_table(PPS *pps, int t, int index, const int depth)
544 545
{
    int i;
546 547 548
    const int max_qp = 51 + 6*(depth-8);
    for(i = 0; i < max_qp+1; i++)
        pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
549 550
}

551 552 553
static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
{
    const SPS *sps = h->sps_buffers[pps->sps_id];
554 555 556 557
    int profile_idc = sps->profile_idc;

    if ((profile_idc == 66 || profile_idc == 77 ||
         profile_idc == 88) && (sps->constraint_set_flags & 7)) {
558
        av_log(h->avctx, AV_LOG_VERBOSE,
559 560 561 562 563 564 565
               "Current profile doesn't provide more RBSP data in PPS, skipping\n");
        return 0;
    }

    return 1;
}

566
int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
567
    unsigned int pps_id= get_ue_golomb(&h->gb);
568
    PPS *pps;
569
    const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
570
    int bits_left;
571 572

    if(pps_id >= MAX_PPS_COUNT) {
573
        av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
574
        return -1;
575
    } else if (h->sps.bit_depth_luma > 14) {
576
        av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
577 578
        return AVERROR_INVALIDDATA;
    } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
579
        av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
580
        return AVERROR_PATCHWELCOME;
581 582 583 584 585
    }

    pps= av_mallocz(sizeof(PPS));
    if(pps == NULL)
        return -1;
586
    pps->sps_id= get_ue_golomb_31(&h->gb);
587
    if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
588
        av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
589 590 591
        goto fail;
    }

592 593 594
    pps->cabac= get_bits1(&h->gb);
    pps->pic_order_present= get_bits1(&h->gb);
    pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
595
    if(pps->slice_group_count > 1 ){
596 597
        pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
        av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
        switch(pps->mb_slice_group_map_type){
        case 0:
#if 0
|   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
|    run_length[ i ]                                |1  |ue(v)   |
#endif
            break;
        case 2:
#if 0
|   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
|{                                                  |   |        |
|    top_left_mb[ i ]                               |1  |ue(v)   |
|    bottom_right_mb[ i ]                           |1  |ue(v)   |
|   }                                               |   |        |
#endif
            break;
        case 3:
        case 4:
        case 5:
#if 0
|   slice_group_change_direction_flag               |1  |u(1)    |
|   slice_group_change_rate_minus1                  |1  |ue(v)   |
#endif
            break;
        case 6:
#if 0
|   slice_group_id_cnt_minus1                       |1  |ue(v)   |
|   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
|)                                                  |   |        |
|    slice_group_id[ i ]                            |1  |u(v)    |
#endif
            break;
        }
    }
632 633
    pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
    pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
634
    if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
635
        av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
636 637 638
        goto fail;
    }

639 640 641 642 643 644 645 646
    pps->weighted_pred= get_bits1(&h->gb);
    pps->weighted_bipred_idc= get_bits(&h->gb, 2);
    pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
    pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
    pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
    pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
    pps->constrained_intra_pred= get_bits1(&h->gb);
    pps->redundant_pic_cnt_present = get_bits1(&h->gb);
647 648 649 650 651 652

    pps->transform_8x8_mode= 0;
    h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
    memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
    memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));

653
    bits_left = bit_length - get_bits_count(&h->gb);
654
    if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
655
        pps->transform_8x8_mode= get_bits1(&h->gb);
656
        decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
657
        pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
658 659 660 661
    } else {
        pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
    }

662 663
    build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
    build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
664
    if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
665
        pps->chroma_qp_diff= 1;
666

667 668
    if(h->avctx->debug&FF_DEBUG_PICT_INFO){
        av_log(h->avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
               pps_id, pps->sps_id,
               pps->cabac ? "CABAC" : "CAVLC",
               pps->slice_group_count,
               pps->ref_count[0], pps->ref_count[1],
               pps->weighted_pred ? "weighted" : "",
               pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
               pps->deblocking_filter_parameters_present ? "LPAR" : "",
               pps->constrained_intra_pred ? "CONSTR" : "",
               pps->redundant_pic_cnt_present ? "REDU" : "",
               pps->transform_8x8_mode ? "8x8DCT" : ""
               );
    }

    av_free(h->pps_buffers[pps_id]);
    h->pps_buffers[pps_id]= pps;
    return 0;
fail:
    av_free(pps);
    return -1;
}