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