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