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     if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
 228         av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
 229         return 0;
 230     }
 231
 232     sps->timing_info_present_flag = get_bits1(&h->gb);
 233     if(sps->timing_info_present_flag){
 234         sps->num_units_in_tick = get_bits_long(&h->gb, 32);
 235         sps->time_scale = get_bits_long(&h->gb, 32);
 236         if(!sps->num_units_in_tick || !sps->time_scale){
 237             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);
 238             return -1;
 239         }
 240         sps->fixed_frame_rate_flag = get_bits1(&h->gb);
 241     }
 242
 243     sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
 244     if(sps->nal_hrd_parameters_present_flag)
 245         if(decode_hrd_parameters(h, sps) < 0)
 246             return -1;
 247     sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
 248     if(sps->vcl_hrd_parameters_present_flag)
 249         if(decode_hrd_parameters(h, sps) < 0)
 250             return -1;
 251     if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
 252         get_bits1(&h->gb);     /* low_delay_hrd_flag */
 253     sps->pic_struct_present_flag = get_bits1(&h->gb);
 254     if(!get_bits_left(&h->gb))
 255         return 0;
 256     sps->bitstream_restriction_flag = get_bits1(&h->gb);
 257     if(sps->bitstream_restriction_flag){
 258         get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
 259         get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
 260         get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
 261         get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
 262         get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
 263         sps->num_reorder_frames= get_ue_golomb(&h->gb);
 264         get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
 265
 266         if (get_bits_left(&h->gb) < 0) {
 267             sps->num_reorder_frames=0;
 268             sps->bitstream_restriction_flag= 0;
 269         }
 270
 271         if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
 272             av_log(h->avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
 273             return -1;
 274         }
 275     }
 276
 277     if (get_bits_left(&h->gb) < 0) {
 278         av_log(h->avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
 279         return AVERROR_INVALIDDATA;
 280     }
 281
 282     return 0;
 283 }
 284
 285 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
 286                                 const uint8_t *jvt_list, const uint8_t *fallback_list){
 287     int i, last = 8, next = 8;
 288     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
 289     if(!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
 290         memcpy(factors, fallback_list, size*sizeof(uint8_t));
 291     else
 292     for(i=0;i<size;i++){
 293         if(next)
 294             next = (last + get_se_golomb(&h->gb)) & 0xff;
 295         if(!i && !next){ /* matrix not written, we use the preset one */
 296             memcpy(factors, jvt_list, size*sizeof(uint8_t));
 297             break;
 298         }
 299         last = factors[scan[i]] = next ? next : last;
 300     }
 301 }
 302
 303 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
 304                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
 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(&h->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     int profile_idc, level_idc, constraint_set_flags = 0;
 335     unsigned int sps_id;
 336     int i, log2_max_frame_num_minus4;
 337     SPS *sps;
 338
 339     profile_idc= get_bits(&h->gb, 8);
 340     constraint_set_flags |= get_bits1(&h->gb) << 0;   //constraint_set0_flag
 341     constraint_set_flags |= get_bits1(&h->gb) << 1;   //constraint_set1_flag
 342     constraint_set_flags |= get_bits1(&h->gb) << 2;   //constraint_set2_flag
 343     constraint_set_flags |= get_bits1(&h->gb) << 3;   //constraint_set3_flag
 344     constraint_set_flags |= get_bits1(&h->gb) << 4;   //constraint_set4_flag
 345     constraint_set_flags |= get_bits1(&h->gb) << 5;   //constraint_set5_flag
 346     get_bits(&h->gb, 2); // reserved
 347     level_idc= get_bits(&h->gb, 8);
 348     sps_id= get_ue_golomb_31(&h->gb);
 349
 350     if(sps_id >= MAX_SPS_COUNT) {
 351         av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
 352         return -1;
 353     }
 354     sps= av_mallocz(sizeof(SPS));
 355     if(sps == NULL)
 356         return -1;
 357
 358     sps->time_offset_length = 24;
 359     sps->profile_idc= profile_idc;
 360     sps->constraint_set_flags = constraint_set_flags;
 361     sps->level_idc= level_idc;
 362     sps->full_range = -1;
 363
 364     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
 365     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
 366     sps->scaling_matrix_present = 0;
 367     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
 368
 369     if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
 370         sps->profile_idc == 122 || sps->profile_idc == 244 ||
 371         sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
 372         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(&h->gb);
 375         if (sps->chroma_format_idc > 3U) {
 376             av_log(h->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(&h->gb);
 380             if(sps->residual_color_transform_flag) {
 381                 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
 382                 goto fail;
 383             }
 384         }
 385         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
 386         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
 387         if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
 388             av_log(h->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(&h->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(&h->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->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(&h->gb);
 411
 412     if(sps->poc_type == 0){ //FIXME #define
 413         unsigned t = get_ue_golomb(&h->gb);
 414         if(t>12){
 415             av_log(h->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(&h->gb);
 421         sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
 422         sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
 423         sps->poc_cycle_length                = get_ue_golomb(&h->gb);
 424
 425         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
 426             av_log(h->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(&h->gb);
 432     }else if(sps->poc_type != 2){
 433         av_log(h->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(&h->gb);
 438     if (h->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->avctx, AV_LOG_ERROR, "too many reference frames\n");
 442         goto fail;
 443     }
 444     sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
 445     sps->mb_width = get_ue_golomb(&h->gb) + 1;
 446     sps->mb_height= get_ue_golomb(&h->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->avctx)){
 449         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
 450         goto fail;
 451     }
 452
 453     sps->frame_mbs_only_flag= get_bits1(&h->gb);
 454     if(!sps->frame_mbs_only_flag)
 455         sps->mb_aff= get_bits1(&h->gb);
 456     else
 457         sps->mb_aff= 0;
 458
 459     sps->direct_8x8_inference_flag= get_bits1(&h->gb);
 460
 461 #ifndef ALLOW_INTERLACE
 462     if(sps->mb_aff)
 463         av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
 464 #endif
 465     sps->crop= get_bits1(&h->gb);
 466     if(sps->crop){
 467         int crop_left   = get_ue_golomb(&h->gb);
 468         int crop_right  = get_ue_golomb(&h->gb);
 469         int crop_top    = get_ue_golomb(&h->gb);
 470         int crop_bottom = get_ue_golomb(&h->gb);
 471         int width  = 16 * sps->mb_width;
 472         int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
 473
 474         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
 475             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
 476                    "values are l:%u r:%u t:%u b:%u\n", crop_left, crop_right,
 477                    crop_top, crop_bottom);
 478
 479             sps->crop_left   =
 480             sps->crop_right  =
 481             sps->crop_top    =
 482             sps->crop_bottom = 0;
 483         } else {
 484             int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
 485             int hsub = (sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2) ? 1 : 0;
 486             int step_x = 1 << hsub;
 487             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
 488
 489             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
 490                 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
 491                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
 492                 av_log(h->avctx, AV_LOG_WARNING, "Reducing left cropping to %d "
 493                        "chroma samples to preserve alignment.\n",
 494                        crop_left);
 495             }
 496
 497             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
 498                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
 499                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
 500                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
 501                 (crop_left + crop_right ) * step_x >= width ||
 502                 (crop_top  + crop_bottom) * step_y >= height
 503             ) {
 504                 av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
 505                 goto fail;
 506             }
 507
 508             sps->crop_left   = crop_left   * step_x;
 509             sps->crop_right  = crop_right  * step_x;
 510             sps->crop_top    = crop_top    * step_y;
 511             sps->crop_bottom = crop_bottom * step_y;
 512         }
 513     }else{
 514         sps->crop_left  =
 515         sps->crop_right =
 516         sps->crop_top   =
 517         sps->crop_bottom= 0;
 518         sps->crop = 0;
 519     }
 520
 521     sps->vui_parameters_present_flag= get_bits1(&h->gb);
 522     if( sps->vui_parameters_present_flag )
 523         if (decode_vui_parameters(h, sps) < 0)
 524             goto fail;
 525
 526     if(!sps->sar.den)
 527         sps->sar.den= 1;
 528
 529     if(h->avctx->debug&FF_DEBUG_PICT_INFO){
 530         static const char csp[4][5] = { "Gray", "420", "422", "444" };
 531         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",
 532                sps_id, sps->profile_idc, sps->level_idc,
 533                sps->poc_type,
 534                sps->ref_frame_count,
 535                sps->mb_width, sps->mb_height,
 536                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
 537                sps->direct_8x8_inference_flag ? "8B8" : "",
 538                sps->crop_left, sps->crop_right,
 539                sps->crop_top, sps->crop_bottom,
 540                sps->vui_parameters_present_flag ? "VUI" : "",
 541                csp[sps->chroma_format_idc],
 542                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
 543                sps->timing_info_present_flag ? sps->time_scale : 0,
 544                sps->bit_depth_luma,
 545                h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
 546                );
 547     }
 548     sps->new = 1;
 549
 550     av_free(h->sps_buffers[sps_id]);
 551     h->sps_buffers[sps_id] = sps;
 552
 553     return 0;
 554 fail:
 555     av_free(sps);
 556     return -1;
 557 }
 558
 559 static void
 560 build_qp_table(PPS *pps, int t, int index, const int depth)
 561 {
 562     int i;
 563     const int max_qp = 51 + 6*(depth-8);
 564     for(i = 0; i < max_qp+1; i++)
 565         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
 566 }
 567
 568 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
 569 {
 570     const SPS *sps = h->sps_buffers[pps->sps_id];
 571     int profile_idc = sps->profile_idc;
 572
 573     if ((profile_idc == 66 || profile_idc == 77 ||
 574          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
 575         av_log(h->avctx, AV_LOG_VERBOSE,
 576                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 577         return 0;
 578     }
 579
 580     return 1;
 581 }
 582
 583 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
 584     unsigned int pps_id= get_ue_golomb(&h->gb);
 585     PPS *pps;
 586     SPS *sps;
 587     int qp_bd_offset;
 588     int bits_left;
 589
 590     if(pps_id >= MAX_PPS_COUNT) {
 591         av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
 592         return AVERROR_INVALIDDATA;
 593     }
 594
 595     pps= av_mallocz(sizeof(PPS));
 596     if(pps == NULL)
 597         return -1;
 598     pps->sps_id= get_ue_golomb_31(&h->gb);
 599     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
 600         av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
 601         goto fail;
 602     }
 603     sps = h->sps_buffers[pps->sps_id];
 604     qp_bd_offset = 6*(sps->bit_depth_luma-8);
 605     if (sps->bit_depth_luma > 14) {
 606         av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", sps->bit_depth_luma);
 607         goto fail;
 608     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
 609         av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", sps->bit_depth_luma);
 610         goto fail;
 611     }
 612
 613     pps->cabac= get_bits1(&h->gb);
 614     pps->pic_order_present= get_bits1(&h->gb);
 615     pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
 616     if(pps->slice_group_count > 1 ){
 617         pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
 618         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
 619         switch(pps->mb_slice_group_map_type){
 620         case 0:
 621 #if 0
 622 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
 623 |    run_length[ i ]                                |1  |ue(v)   |
 624 #endif
 625             break;
 626         case 2:
 627 #if 0
 628 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
 629 |{                                                  |   |        |
 630 |    top_left_mb[ i ]                               |1  |ue(v)   |
 631 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
 632 |   }                                               |   |        |
 633 #endif
 634             break;
 635         case 3:
 636         case 4:
 637         case 5:
 638 #if 0
 639 |   slice_group_change_direction_flag               |1  |u(1)    |
 640 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
 641 #endif
 642             break;
 643         case 6:
 644 #if 0
 645 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
 646 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
 647 |)                                                  |   |        |
 648 |    slice_group_id[ i ]                            |1  |u(v)    |
 649 #endif
 650             break;
 651         }
 652     }
 653     pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
 654     pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
 655     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
 656         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
 657         goto fail;
 658     }
 659
 660     pps->weighted_pred= get_bits1(&h->gb);
 661     pps->weighted_bipred_idc= get_bits(&h->gb, 2);
 662     pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 663     pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
 664     pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
 665     pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
 666     pps->constrained_intra_pred= get_bits1(&h->gb);
 667     pps->redundant_pic_cnt_present = get_bits1(&h->gb);
 668
 669     pps->transform_8x8_mode= 0;
 670     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
 671     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
 672     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
 673
 674     bits_left = bit_length - get_bits_count(&h->gb);
 675     if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
 676         pps->transform_8x8_mode= get_bits1(&h->gb);
 677         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
 678         pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
 679     } else {
 680         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
 681     }
 682
 683     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
 684     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
 685     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
 686         pps->chroma_qp_diff= 1;
 687
 688     if(h->avctx->debug&FF_DEBUG_PICT_INFO){
 689         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",
 690                pps_id, pps->sps_id,
 691                pps->cabac ? "CABAC" : "CAVLC",
 692                pps->slice_group_count,
 693                pps->ref_count[0], pps->ref_count[1],
 694                pps->weighted_pred ? "weighted" : "",
 695                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
 696                pps->deblocking_filter_parameters_present ? "LPAR" : "",
 697                pps->constrained_intra_pred ? "CONSTR" : "",
 698                pps->redundant_pic_cnt_present ? "REDU" : "",
 699                pps->transform_8x8_mode ? "8x8DCT" : ""
 700                );
 701     }
 702
 703     av_free(h->pps_buffers[pps_id]);
 704     h->pps_buffers[pps_id]= pps;
 705     return 0;
 706 fail:
 707     av_free(pps);
 708     return -1;
 709 }