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