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 "avcodec.h"
  31 #include "h264.h"
  32 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
  33 #include "golomb.h"
  34
  35
  36 //#undef NDEBUG
  37 #include <assert.h>
  38
  39 #define MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
  40 #define MIN_LOG2_MAX_FRAME_NUM    4
  41
  42 static const AVRational pixel_aspect[17]={
  43  {0, 1},
  44  {1, 1},
  45  {12, 11},
  46  {10, 11},
  47  {16, 11},
  48  {40, 33},
  49  {24, 11},
  50  {20, 11},
  51  {32, 11},
  52  {80, 33},
  53  {18, 11},
  54  {15, 11},
  55  {64, 33},
  56  {160,99},
  57  {4, 3},
  58  {3, 2},
  59  {2, 1},
  60 };
  61
  62 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
  63
  64 #define CHROMA_QP_TABLE_END(d) \
  65      QP(0,d),  QP(1,d),  QP(2,d),  QP(3,d),  QP(4,d),  QP(5,d),\
  66      QP(6,d),  QP(7,d),  QP(8,d),  QP(9,d), QP(10,d), QP(11,d),\
  67     QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
  68     QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
  69     QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
  70     QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
  71     QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
  72     QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
  73     QP(39,d), QP(39,d), QP(39,d), QP(39,d)
  74
  75 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
  76     {
  77         CHROMA_QP_TABLE_END(8)
  78     },
  79     {
  80         0, 1, 2, 3, 4, 5,
  81         CHROMA_QP_TABLE_END(9)
  82     },
  83     {
  84         0, 1, 2, 3,  4,  5,
  85         6, 7, 8, 9, 10, 11,
  86         CHROMA_QP_TABLE_END(10)
  87     },
  88     {
  89         0,  1, 2, 3,  4,  5,
  90         6,  7, 8, 9, 10, 11,
  91         12,13,14,15, 16, 17,
  92         CHROMA_QP_TABLE_END(11)
  93     },
  94     {
  95         0,  1, 2, 3,  4,  5,
  96         6,  7, 8, 9, 10, 11,
  97         12,13,14,15, 16, 17,
  98         18,19,20,21, 22, 23,
  99         CHROMA_QP_TABLE_END(12)
 100     },
 101     {
 102         0,  1, 2, 3,  4,  5,
 103         6,  7, 8, 9, 10, 11,
 104         12,13,14,15, 16, 17,
 105         18,19,20,21, 22, 23,
 106         24,25,26,27, 28, 29,
 107         CHROMA_QP_TABLE_END(13)
 108     },
 109     {
 110         0,  1, 2, 3,  4,  5,
 111         6,  7, 8, 9, 10, 11,
 112         12,13,14,15, 16, 17,
 113         18,19,20,21, 22, 23,
 114         24,25,26,27, 28, 29,
 115         30,31,32,33, 34, 35,
 116         CHROMA_QP_TABLE_END(14)
 117     },
 118 };
 119
 120 static const uint8_t default_scaling4[2][16]={
 121 {   6,13,20,28,
 122    13,20,28,32,
 123    20,28,32,37,
 124    28,32,37,42
 125 },{
 126    10,14,20,24,
 127    14,20,24,27,
 128    20,24,27,30,
 129    24,27,30,34
 130 }};
 131
 132 static const uint8_t default_scaling8[2][64]={
 133 {   6,10,13,16,18,23,25,27,
 134    10,11,16,18,23,25,27,29,
 135    13,16,18,23,25,27,29,31,
 136    16,18,23,25,27,29,31,33,
 137    18,23,25,27,29,31,33,36,
 138    23,25,27,29,31,33,36,38,
 139    25,27,29,31,33,36,38,40,
 140    27,29,31,33,36,38,40,42
 141 },{
 142     9,13,15,17,19,21,22,24,
 143    13,13,17,19,21,22,24,25,
 144    15,17,19,21,22,24,25,27,
 145    17,19,21,22,24,25,27,28,
 146    19,21,22,24,25,27,28,30,
 147    21,22,24,25,27,28,30,32,
 148    22,24,25,27,28,30,32,33,
 149    24,25,27,28,30,32,33,35
 150 }};
 151
 152 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
 153     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         return -1;
 159     }
 160
 161     get_bits(&h->gb, 4); /* bit_rate_scale */
 162     get_bits(&h->gb, 4); /* cpb_size_scale */
 163     for(i=0; i<cpb_count; i++){
 164         get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
 165         get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
 166         get_bits1(&h->gb);     /* cbr_flag */
 167     }
 168     sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
 169     sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
 170     sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
 171     sps->time_offset_length = get_bits(&h->gb, 5);
 172     sps->cpb_cnt = cpb_count;
 173     return 0;
 174 }
 175
 176 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
 177     int aspect_ratio_info_present_flag;
 178     unsigned int aspect_ratio_idc;
 179
 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             sps->sar.num= get_bits(&h->gb, 16);
 186             sps->sar.den= get_bits(&h->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->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(&h->gb)){      /* overscan_info_present_flag */
 200         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         get_bits(&h->gb, 3);    /* video_format */
 206         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             sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
 211             sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
 212             sps->colorspace      = get_bits(&h->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(&h->gb)){      /* chroma_location_info_present_flag */
 223         h->avctx->chroma_sample_location = get_ue_golomb(&h->gb)+1;  /* chroma_sample_location_type_top_field */
 224         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         sps->num_units_in_tick = get_bits_long(&h->gb, 32);
 230         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             return -1;
 234         }
 235         sps->fixed_frame_rate_flag = get_bits1(&h->gb);
 236     }
 237
 238     sps->nal_hrd_parameters_present_flag = get_bits1(&h->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(&h->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(&h->gb);     /* low_delay_hrd_flag */
 248     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         get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
 254         get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
 255         get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
 256         get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
 257         get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
 258         sps->num_reorder_frames= get_ue_golomb(&h->gb);
 259         get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
 260
 261         if (get_bits_left(&h->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->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(&h->gb) < 0) {
 273         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     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     int i, last = 8, next = 8;
 283     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         memcpy(factors, fallback_list, size*sizeof(uint8_t));
 286     else
 287     for(i=0;i<size;i++){
 288         if(next)
 289             next = (last + get_se_golomb(&h->gb)) & 0xff;
 290         if(!i && !next){ /* matrix not written, we use the preset one */
 291             memcpy(factors, jvt_list, size*sizeof(uint8_t));
 292             break;
 293         }
 294         last = factors[scan[i]] = next ? next : last;
 295     }
 296 }
 297
 298 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
 299                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
 300     int fallback_sps = !is_sps && sps->scaling_matrix_present;
 301     const uint8_t *fallback[4] = {
 302         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
 303         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
 304         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         sps->scaling_matrix_present |= is_sps;
 309         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
 310         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
 311         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
 312         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
 313         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
 314         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
 315         if(is_sps || pps->transform_8x8_mode){
 316             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                 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);  // Inter, Cb
 323             }
 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     SPS *sps;
 333
 334     profile_idc= get_bits(&h->gb, 8);
 335     constraint_set_flags |= get_bits1(&h->gb) << 0;   //constraint_set0_flag
 336     constraint_set_flags |= get_bits1(&h->gb) << 1;   //constraint_set1_flag
 337     constraint_set_flags |= get_bits1(&h->gb) << 2;   //constraint_set2_flag
 338     constraint_set_flags |= get_bits1(&h->gb) << 3;   //constraint_set3_flag
 339     constraint_set_flags |= get_bits1(&h->gb) << 4;   //constraint_set4_flag
 340     constraint_set_flags |= get_bits1(&h->gb) << 5;   //constraint_set5_flag
 341     get_bits(&h->gb, 2); // reserved
 342     level_idc= get_bits(&h->gb, 8);
 343     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         return -1;
 348     }
 349     sps= av_mallocz(sizeof(SPS));
 350     if(sps == NULL)
 351         return -1;
 352
 353     sps->time_offset_length = 24;
 354     sps->profile_idc= profile_idc;
 355     sps->constraint_set_flags = constraint_set_flags;
 356     sps->level_idc= level_idc;
 357     sps->full_range = -1;
 358
 359     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
 360     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
 361     sps->scaling_matrix_present = 0;
 362     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
 363
 364     if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
 365         sps->profile_idc == 122 || sps->profile_idc == 244 ||
 366         sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
 367         sps->profile_idc ==  86 || sps->profile_idc == 118 ||
 368         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                 goto fail;
 378             }
 379         }
 380         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
 381         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                    sps->bit_depth_luma, sps->bit_depth_chroma);
 385             goto fail;
 386         }
 387         sps->transform_bypass = get_bits1(&h->gb);
 388         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
 389     }else{
 390         sps->chroma_format_idc= 1;
 391         sps->bit_depth_luma   = 8;
 392         sps->bit_depth_chroma = 8;
 393     }
 394
 395     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
 396     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
 397         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
 398         av_log(h->avctx, AV_LOG_ERROR,
 399                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
 400                log2_max_frame_num_minus4);
 401         goto fail;
 402     }
 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             goto fail;
 412         }
 413         sps->log2_max_poc_lsb= t + 4;
 414     } else if(sps->poc_type == 1){//FIXME #define
 415         sps->delta_pic_order_always_zero_flag= get_bits1(&h->gb);
 416         sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
 417         sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
 418         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             goto fail;
 423         }
 424
 425         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         goto fail;
 430     }
 431
 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         goto fail;
 438     }
 439     sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
 440     sps->mb_width = get_ue_golomb(&h->gb) + 1;
 441     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        av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->avctx)){
 444         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
 445         goto fail;
 446     }
 447
 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     else
 452         sps->mb_aff= 0;
 453
 454     sps->direct_8x8_inference_flag= get_bits1(&h->gb);
 455
 456 #ifndef ALLOW_INTERLACE
 457     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         sps->crop_left  = get_ue_golomb(&h->gb);
 465         sps->crop_right = get_ue_golomb(&h->gb);
 466         sps->crop_top   = get_ue_golomb(&h->gb);
 467         sps->crop_bottom= get_ue_golomb(&h->gb);
 468         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
 469             av_log(h->avctx, AV_LOG_DEBUG,
 470                    "discarding sps cropping, "
 471                    "original values are l:%u r:%u t:%u b:%u\n",
 472                    sps->crop_left,
 473                    sps->crop_right,
 474                    sps->crop_top,
 475                    sps->crop_bottom);
 476
 477             sps->crop_left   =
 478             sps->crop_right  =
 479             sps->crop_top    =
 480             sps->crop_bottom = 0;
 481         }
 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         /* It is very unlikely that partial cropping will make anybody happy.
 488          * Not cropping at all fixes for example playback of Sisvel 3D streams
 489          * in applications supporting Sisvel 3D. */
 490         sps->crop_left  =
 491         sps->crop_right =
 492         sps->crop_top   =
 493         sps->crop_bottom= 0;
 494         }
 495     }else{
 496         sps->crop_left  =
 497         sps->crop_right =
 498         sps->crop_top   =
 499         sps->crop_bottom= 0;
 500     }
 501
 502     sps->vui_parameters_present_flag= get_bits1(&h->gb);
 503     if( sps->vui_parameters_present_flag )
 504         if (decode_vui_parameters(h, sps) < 0)
 505             goto fail;
 506
 507     if(!sps->sar.den)
 508         sps->sar.den= 1;
 509
 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                sps_id, sps->profile_idc, sps->level_idc,
 514                sps->poc_type,
 515                sps->ref_frame_count,
 516                sps->mb_width, sps->mb_height,
 517                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 518                sps->direct_8x8_inference_flag ? "8B8" : "",
 519                sps->crop_left, sps->crop_right,
 520                sps->crop_top, sps->crop_bottom,
 521                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                sps->bit_depth_luma,
 526                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     h->sps_buffers[sps_id] = sps;
 533     h->sps                 = *sps;
 534     h->current_sps_id      = sps_id;
 535
 536     return 0;
 537 fail:
 538     av_free(sps);
 539     return -1;
 540 }
 541
 542 static void
 543 build_qp_table(PPS *pps, int t, int index, const int depth)
 544 {
 545     int i;
 546     const int max_qp = 51 + 6*(depth-8);
 547     for(i = 0; i < max_qp+1; i++)
 548         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
 549 }
 550
 551 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
 552 {
 553     const SPS *sps = h->sps_buffers[pps->sps_id];
 554     int profile_idc = sps->profile_idc;
 555
 556     if ((profile_idc == 66 || profile_idc == 77 ||
 557          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
 558         av_log(h->avctx, AV_LOG_VERBOSE,
 559                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 560         return 0;
 561     }
 562
 563     return 1;
 564 }
 565
 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         return AVERROR_INVALIDDATA;
 578     } 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     pps= av_mallocz(sizeof(PPS));
 584     if(pps == NULL)
 585         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         goto fail;
 590     }
 591
 592     pps->cabac= get_bits1(&h->gb);
 593     pps->pic_order_present= get_bits1(&h->gb);
 594     pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
 595     if(pps->slice_group_count > 1 ){
 596         pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
 597         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
 598         switch(pps->mb_slice_group_map_type){
 599         case 0:
 600 #if 0
 601 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
 602 |    run_length[ i ]                                |1  |ue(v)   |
 603 #endif
 604             break;
 605         case 2:
 606 #if 0
 607 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
 608 |{                                                  |   |        |
 609 |    top_left_mb[ i ]                               |1  |ue(v)   |
 610 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
 611 |   }                                               |   |        |
 612 #endif
 613             break;
 614         case 3:
 615         case 4:
 616         case 5:
 617 #if 0
 618 |   slice_group_change_direction_flag               |1  |u(1)    |
 619 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
 620 #endif
 621             break;
 622         case 6:
 623 #if 0
 624 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
 625 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
 626 |)                                                  |   |        |
 627 |    slice_group_id[ i ]                            |1  |u(v)    |
 628 #endif
 629             break;
 630         }
 631     }
 632     pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
 633     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         goto fail;
 637     }
 638
 639     pps->weighted_pred= get_bits1(&h->gb);
 640     pps->weighted_bipred_idc= get_bits(&h->gb, 2);
 641     pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 642     pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 643     pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
 644     pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
 645     pps->constrained_intra_pred= get_bits1(&h->gb);
 646     pps->redundant_pic_cnt_present = get_bits1(&h->gb);
 647
 648     pps->transform_8x8_mode= 0;
 649     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
 650     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
 651     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
 652
 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     } else {
 659         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
 660     }
 661
 662     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
 663     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     if(h->avctx->debug&FF_DEBUG_PICT_INFO){
 668         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                pps_id, pps->sps_id,
 670                pps->cabac ? "CABAC" : "CAVLC",
 671                pps->slice_group_count,
 672                pps->ref_count[0], pps->ref_count[1],
 673                pps->weighted_pred ? "weighted" : "",
 674                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
 675                pps->deblocking_filter_parameters_present ? "LPAR" : "",
 676                pps->constrained_intra_pred ? "CONSTR" : "",
 677                pps->redundant_pic_cnt_present ? "REDU" : "",
 678                pps->transform_8x8_mode ? "8x8DCT" : ""
 679                );
 680     }
 681
 682     av_free(h->pps_buffers[pps_id]);
 683     h->pps_buffers[pps_id]= pps;
 684     return 0;
 685 fail:
 686     av_free(pps);
 687     return -1;
 688 }