Merge commit '330ad1f6a53a37dec228cb424ca57e1268fafc64'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 21 Aug 2013 10:56:37 +0000 (12:56 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 21 Aug 2013 10:56:37 +0000 (12:56 +0200)
* commit '330ad1f6a53a37dec228cb424ca57e1268fafc64':
  h264_ps: K&R formatting cosmetics

Conflicts:
libavcodec/h264_ps.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/h264_ps.c

  #define MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
  #define MIN_LOG2_MAX_FRAME_NUM    4
  
- static const AVRational pixel_aspect[17]={
-  {0, 1},
-  {1, 1},
-  {12, 11},
-  {10, 11},
-  {16, 11},
-  {40, 33},
-  {24, 11},
-  {20, 11},
-  {32, 11},
-  {80, 33},
-  {18, 11},
-  {15, 11},
-  {64, 33},
-  {160,99},
-  {4, 3},
-  {3, 2},
-  {2, 1},
+ static const AVRational pixel_aspect[17] = {
+     {   0,  1 },
+     {   1,  1 },
+     {  12, 11 },
+     {  10, 11 },
+     {  16, 11 },
+     {  40, 33 },
+     {  24, 11 },
+     {  20, 11 },
+     {  32, 11 },
+     {  80, 33 },
+     {  18, 11 },
+     {  15, 11 },
+     {  64, 33 },
+     { 160, 99 },
+     {   4,  3 },
+     {   3,  2 },
+     {   2,  1 },
  };
  
- #define QP(qP,depth) ( (qP)+6*((depth)-8) )
- #define CHROMA_QP_TABLE_END(d) \
-      QP(0,d),  QP(1,d),  QP(2,d),  QP(3,d),  QP(4,d),  QP(5,d),\
-      QP(6,d),  QP(7,d),  QP(8,d),  QP(9,d), QP(10,d), QP(11,d),\
-     QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
-     QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
-     QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
-     QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
-     QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
-     QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
-     QP(39,d), QP(39,d), QP(39,d), QP(39,d)
- const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
-     {
-         CHROMA_QP_TABLE_END(8)
-     },
-     {
-         0, 1, 2, 3, 4, 5,
-         CHROMA_QP_TABLE_END(9)
-     },
-     {
-         0, 1, 2, 3,  4,  5,
-         6, 7, 8, 9, 10, 11,
-         CHROMA_QP_TABLE_END(10)
-     },
-     {
-         0,  1, 2, 3,  4,  5,
-         6,  7, 8, 9, 10, 11,
-         12,13,14,15, 16, 17,
-         CHROMA_QP_TABLE_END(11)
-     },
-     {
-         0,  1, 2, 3,  4,  5,
-         6,  7, 8, 9, 10, 11,
-         12,13,14,15, 16, 17,
-         18,19,20,21, 22, 23,
-         CHROMA_QP_TABLE_END(12)
-     },
-     {
-         0,  1, 2, 3,  4,  5,
-         6,  7, 8, 9, 10, 11,
-         12,13,14,15, 16, 17,
-         18,19,20,21, 22, 23,
-         24,25,26,27, 28, 29,
-         CHROMA_QP_TABLE_END(13)
-     },
-     {
-         0,  1, 2, 3,  4,  5,
-         6,  7, 8, 9, 10, 11,
-         12,13,14,15, 16, 17,
-         18,19,20,21, 22, 23,
-         24,25,26,27, 28, 29,
-         30,31,32,33, 34, 35,
-         CHROMA_QP_TABLE_END(14)
-     },
+ #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
+ #define CHROMA_QP_TABLE_END(d)                                          \
+     QP(0,  d), QP(1,  d), QP(2,  d), QP(3,  d), QP(4,  d), QP(5,  d),   \
+     QP(6,  d), QP(7,  d), QP(8,  d), QP(9,  d), QP(10, d), QP(11, d),   \
+     QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d),   \
+     QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d),   \
+     QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d),   \
+     QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d),   \
+     QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d),   \
+     QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d),   \
+     QP(39, d), QP(39, d), QP(39, d), QP(39, d)
 -const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM + 1] = {
++const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
+     { CHROMA_QP_TABLE_END(8) },
+     { 0, 1, 2, 3, 4, 5,
+       CHROMA_QP_TABLE_END(9) },
 -    { 0, 1, 2, 3, 4, 5,
++    { 0, 1, 2, 3,  4,  5,
+       6, 7, 8, 9, 10, 11,
+       CHROMA_QP_TABLE_END(10) },
++    { 0,  1, 2, 3,  4,  5,
++      6,  7, 8, 9, 10, 11,
++      12,13,14,15, 16, 17,
++      CHROMA_QP_TABLE_END(11) },
++    { 0,  1, 2, 3,  4,  5,
++      6,  7, 8, 9, 10, 11,
++      12,13,14,15, 16, 17,
++      18,19,20,21, 22, 23,
++      CHROMA_QP_TABLE_END(12) },
++    { 0,  1, 2, 3,  4,  5,
++      6,  7, 8, 9, 10, 11,
++      12,13,14,15, 16, 17,
++      18,19,20,21, 22, 23,
++      24,25,26,27, 28, 29,
++      CHROMA_QP_TABLE_END(13) },
++    { 0,  1, 2, 3,  4,  5,
++      6,  7, 8, 9, 10, 11,
++      12,13,14,15, 16, 17,
++      18,19,20,21, 22, 23,
++      24,25,26,27, 28, 29,
++      30,31,32,33, 34, 35,
++      CHROMA_QP_TABLE_END(14) },
  };
  
- static const uint8_t default_scaling4[2][16]={
- {   6,13,20,28,
-    13,20,28,32,
-    20,28,32,37,
-    28,32,37,42
- },{
-    10,14,20,24,
-    14,20,24,27,
-    20,24,27,30,
-    24,27,30,34
- }};
- static const uint8_t default_scaling8[2][64]={
- {   6,10,13,16,18,23,25,27,
-    10,11,16,18,23,25,27,29,
-    13,16,18,23,25,27,29,31,
-    16,18,23,25,27,29,31,33,
-    18,23,25,27,29,31,33,36,
-    23,25,27,29,31,33,36,38,
-    25,27,29,31,33,36,38,40,
-    27,29,31,33,36,38,40,42
- },{
-     9,13,15,17,19,21,22,24,
-    13,13,17,19,21,22,24,25,
-    15,17,19,21,22,24,25,27,
-    17,19,21,22,24,25,27,28,
-    19,21,22,24,25,27,28,30,
-    21,22,24,25,27,28,30,32,
-    22,24,25,27,28,30,32,33,
-    24,25,27,28,30,32,33,35
- }};
- static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
+ static const uint8_t default_scaling4[2][16] = {
+     {  6, 13, 20, 28, 13, 20, 28, 32,
+       20, 28, 32, 37, 28, 32, 37, 42 },
+     { 10, 14, 20, 24, 14, 20, 24, 27,
+       20, 24, 27, 30, 24, 27, 30, 34 }
+ };
+ static const uint8_t default_scaling8[2][64] = {
+     {  6, 10, 13, 16, 18, 23, 25, 27,
+       10, 11, 16, 18, 23, 25, 27, 29,
+       13, 16, 18, 23, 25, 27, 29, 31,
+       16, 18, 23, 25, 27, 29, 31, 33,
+       18, 23, 25, 27, 29, 31, 33, 36,
+       23, 25, 27, 29, 31, 33, 36, 38,
+       25, 27, 29, 31, 33, 36, 38, 40,
+       27, 29, 31, 33, 36, 38, 40, 42 },
+     {  9, 13, 15, 17, 19, 21, 22, 24,
+       13, 13, 17, 19, 21, 22, 24, 25,
+       15, 17, 19, 21, 22, 24, 25, 27,
+       17, 19, 21, 22, 24, 25, 27, 28,
+       19, 21, 22, 24, 25, 27, 28, 30,
+       21, 22, 24, 25, 27, 28, 30, 32,
+       22, 24, 25, 27, 28, 30, 32, 33,
+       24, 25, 27, 28, 30, 32, 33, 35 }
+ };
+ static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
+ {
      int cpb_count, i;
      cpb_count = get_ue_golomb_31(&h->gb) + 1;
  
@@@ -219,37 -180,34 +202,40 @@@ static inline int decode_vui_parameters
          get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
      }
  
 +    if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
 +        av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
 +        return 0;
 +    }
 +
      sps->timing_info_present_flag = get_bits1(&h->gb);
-     if(sps->timing_info_present_flag){
+     if (sps->timing_info_present_flag) {
          sps->num_units_in_tick = get_bits_long(&h->gb, 32);
-         sps->time_scale = get_bits_long(&h->gb, 32);
-         if(!sps->num_units_in_tick || !sps->time_scale){
-             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);
+         sps->time_scale        = get_bits_long(&h->gb, 32);
+         if (!sps->num_units_in_tick || !sps->time_scale) {
+             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);
              return -1;
          }
          sps->fixed_frame_rate_flag = get_bits1(&h->gb);
      }
  
      sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
-     if(sps->nal_hrd_parameters_present_flag)
-         if(decode_hrd_parameters(h, sps) < 0)
+     if (sps->nal_hrd_parameters_present_flag)
+         if (decode_hrd_parameters(h, sps) < 0)
              return -1;
      sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
-     if(sps->vcl_hrd_parameters_present_flag)
-         if(decode_hrd_parameters(h, sps) < 0)
+     if (sps->vcl_hrd_parameters_present_flag)
+         if (decode_hrd_parameters(h, sps) < 0)
              return -1;
-     if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
+     if (sps->nal_hrd_parameters_present_flag ||
+         sps->vcl_hrd_parameters_present_flag)
          get_bits1(&h->gb);     /* low_delay_hrd_flag */
      sps->pic_struct_present_flag = get_bits1(&h->gb);
-     if(!get_bits_left(&h->gb))
 -
++    if (!get_bits_left(&h->gb))
 +        return 0;
      sps->bitstream_restriction_flag = get_bits1(&h->gb);
-     if(sps->bitstream_restriction_flag){
+     if (sps->bitstream_restriction_flag) {
          get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
          get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
          get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
              return -1;
          }
      }
 +
      if (get_bits_left(&h->gb) < 0) {
-         av_log(h->avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
+         av_log(h->avctx, AV_LOG_ERROR,
+                "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
          return AVERROR_INVALIDDATA;
      }
  
@@@ -304,22 -269,24 +298,22 @@@ static void decode_scaling_matrices(H26
          fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
          fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
      };
-     if(get_bits1(&h->gb)){
+     if (get_bits1(&h->gb)) {
          sps->scaling_matrix_present |= is_sps;
-         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
-         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
-         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
-         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
-         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
-         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
-         if(is_sps || pps->transform_8x8_mode){
-             decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
-             decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);  // Inter, Y
-             if(sps->chroma_format_idc == 3){
-                 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);  // Intra, Cr
-                 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);  // Inter, Cr
-                 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);  // Intra, Cb
-                 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);  // Inter, Cb
+         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
+         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
+         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
+         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
+         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
+         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
+         if (is_sps || pps->transform_8x8_mode) {
+             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
 -            if (sps->chroma_format_idc == 3) {
 -                decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
 -                decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
 -            }
+             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
+             if (sps->chroma_format_idc == 3) {
++                decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
+                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
++                decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
+                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
              }
          }
      }
@@@ -331,30 -299,27 +326,30 @@@ int ff_h264_decode_seq_parameter_set(H2
      int i, log2_max_frame_num_minus4;
      SPS *sps;
  
-     profile_idc= get_bits(&h->gb, 8);
-     constraint_set_flags |= get_bits1(&h->gb) << 0;   //constraint_set0_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 1;   //constraint_set1_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 2;   //constraint_set2_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 3;   //constraint_set3_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 4;   //constraint_set4_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 5;   //constraint_set5_flag
+     profile_idc           = get_bits(&h->gb, 8);
+     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
+     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
+     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
+     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
 -    get_bits(&h->gb, 4); // reserved
++    constraint_set_flags |= get_bits1(&h->gb) << 4;   // constraint_set4_flag
++    constraint_set_flags |= get_bits1(&h->gb) << 5;   // constraint_set5_flag
 +    get_bits(&h->gb, 2); // reserved
-     level_idc= get_bits(&h->gb, 8);
-     sps_id= get_ue_golomb_31(&h->gb);
+     level_idc = get_bits(&h->gb, 8);
+     sps_id    = get_ue_golomb_31(&h->gb);
  
-     if(sps_id >= MAX_SPS_COUNT) {
+     if (sps_id >= MAX_SPS_COUNT) {
          av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
          return -1;
      }
-     sps= av_mallocz(sizeof(SPS));
-     if(sps == NULL)
+     sps = av_mallocz(sizeof(SPS));
+     if (sps == NULL)
          return -1;
  
-     sps->time_offset_length = 24;
-     sps->profile_idc= profile_idc;
+     sps->time_offset_length   = 24;
+     sps->profile_idc          = profile_idc;
      sps->constraint_set_flags = constraint_set_flags;
-     sps->level_idc= level_idc;
-     sps->full_range = -1;
+     sps->level_idc            = level_idc;
++    sps->full_range           = -1;
  
      memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
      memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
          sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
          sps->profile_idc ==  86 || sps->profile_idc == 118 ||
          sps->profile_idc == 128 || sps->profile_idc == 144) {
-         sps->chroma_format_idc= get_ue_golomb_31(&h->gb);
+         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
 -        if (sps->chroma_format_idc > 3) {
 +        if (sps->chroma_format_idc > 3U) {
-             av_log(h->avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
+             av_log(h->avctx, AV_LOG_ERROR,
 -                   "chroma_format_idc (%u) out of range\n",
++                   "chroma_format_idc %d is illegal\n",
+                    sps->chroma_format_idc);
              goto fail;
-         } else if(sps->chroma_format_idc == 3) {
+         } else if (sps->chroma_format_idc == 3) {
              sps->residual_color_transform_flag = get_bits1(&h->gb);
-             if(sps->residual_color_transform_flag) {
++            if (sps->residual_color_transform_flag) {
 +                av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
 +                goto fail;
 +            }
          }
          sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
          sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
 +        if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
 +            av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
 +                   sps->bit_depth_luma, sps->bit_depth_chroma);
 +            goto fail;
 +        }
          sps->transform_bypass = get_bits1(&h->gb);
-         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
-     }else{
-         sps->chroma_format_idc= 1;
-         sps->bit_depth_luma   = 8;
-         sps->bit_depth_chroma = 8;
+         decode_scaling_matrices(h, sps, NULL, 1,
+                                 sps->scaling_matrix4, sps->scaling_matrix8);
+     } else {
+         sps->chroma_format_idc = 1;
+         sps->bit_depth_luma    = 8;
+         sps->bit_depth_chroma  = 8;
      }
  
      log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
      }
      sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
  
-     sps->poc_type= get_ue_golomb_31(&h->gb);
+     sps->poc_type = get_ue_golomb_31(&h->gb);
  
-     if(sps->poc_type == 0){ //FIXME #define
+     if (sps->poc_type == 0) { // FIXME #define
 -        sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
 +        unsigned t = get_ue_golomb(&h->gb);
-         if(t>12){
++        if (t>12) {
 +            av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
 +            goto fail;
 +        }
-         sps->log2_max_poc_lsb= t + 4;
-     } else if(sps->poc_type == 1){//FIXME #define
-         sps->delta_pic_order_always_zero_flag= get_bits1(&h->gb);
-         sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
-         sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
-         sps->poc_cycle_length                = get_ue_golomb(&h->gb);
-         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
-             av_log(h->avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
++        sps->log2_max_poc_lsb = t + 4;
+     } else if (sps->poc_type == 1) { // FIXME #define
+         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
+         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
+         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
+         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
+         if ((unsigned)sps->poc_cycle_length >=
+             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
+             av_log(h->avctx, AV_LOG_ERROR,
+                    "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
              goto fail;
          }
  
          goto fail;
      }
  
-     sps->ref_frame_count= get_ue_golomb_31(&h->gb);
+     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
 +    if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
-         sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
-     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
++        sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
+     if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
 -        sps->ref_frame_count >= 32U) {
++        sps->ref_frame_count > 16U) {
          av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
          goto fail;
      }
          goto fail;
      }
  
-     sps->frame_mbs_only_flag= get_bits1(&h->gb);
-     if(!sps->frame_mbs_only_flag)
-         sps->mb_aff= get_bits1(&h->gb);
+     sps->frame_mbs_only_flag = get_bits1(&h->gb);
+     if (!sps->frame_mbs_only_flag)
+         sps->mb_aff = get_bits1(&h->gb);
      else
-         sps->mb_aff= 0;
+         sps->mb_aff = 0;
  
-     sps->direct_8x8_inference_flag= get_bits1(&h->gb);
+     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
 -    if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
 -        av_log(h->avctx, AV_LOG_ERROR,
 -               "This stream was generated by a broken encoder, invalid 8x8 inference\n");
 -        goto fail;
 -    }
  
  #ifndef ALLOW_INTERLACE
-     if(sps->mb_aff)
-         av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
+     if (sps->mb_aff)
+         av_log(h->avctx, AV_LOG_ERROR,
+                "MBAFF support not included; enable it at compile-time.\n");
  #endif
-     sps->crop= get_bits1(&h->gb);
-     if(sps->crop){
+     sps->crop = get_bits1(&h->gb);
+     if (sps->crop) {
          int crop_left   = get_ue_golomb(&h->gb);
          int crop_right  = get_ue_golomb(&h->gb);
          int crop_top    = get_ue_golomb(&h->gb);
          if (decode_vui_parameters(h, sps) < 0)
              goto fail;
  
-     if(!sps->sar.den)
-         sps->sar.den= 1;
+     if (!sps->sar.den)
+         sps->sar.den = 1;
  
-     if(h->avctx->debug&FF_DEBUG_PICT_INFO){
+     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
          static const char csp[4][5] = { "Gray", "420", "422", "444" };
-         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",
+         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\n",
++               "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",
                 sps_id, sps->profile_idc, sps->level_idc,
                 sps->poc_type,
                 sps->ref_frame_count,
  
      av_free(h->sps_buffers[sps_id]);
      h->sps_buffers[sps_id] = sps;
 -    h->sps                 = *sps;
 -    h->current_sps_id      = sps_id;
  
      return 0;
  fail:
      av_free(sps);
      return -1;
  }
  
- static void
- build_qp_table(PPS *pps, int t, int index, const int depth)
+ static void build_qp_table(PPS *pps, int t, int index, const int depth)
  {
      int i;
-     const int max_qp = 51 + 6*(depth-8);
-     for(i = 0; i < max_qp+1; i++)
-         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
+     const int max_qp = 51 + 6 * (depth - 8);
+     for (i = 0; i < max_qp + 1; i++)
+         pps->chroma_qp_table[t][i] =
+             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
  }
  
- int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
-     unsigned int pps_id= get_ue_golomb(&h->gb);
 +static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
 +{
 +    const SPS *sps = h->sps_buffers[pps->sps_id];
 +    int profile_idc = sps->profile_idc;
 +
 +    if ((profile_idc == 66 || profile_idc == 77 ||
 +         profile_idc == 88) && (sps->constraint_set_flags & 7)) {
 +        av_log(h->avctx, AV_LOG_VERBOSE,
 +               "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 +        return 0;
 +    }
 +
 +    return 1;
 +}
 +
+ int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
+ {
+     unsigned int pps_id = get_ue_golomb(&h->gb);
      PPS *pps;
 -    const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
 +    SPS *sps;
 +    int qp_bd_offset;
      int bits_left;
  
-     if(pps_id >= MAX_PPS_COUNT) {
+     if (pps_id >= MAX_PPS_COUNT) {
          av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
 -        return -1;
 -    } else if (h->sps.bit_depth_luma > 10) {
 -        av_log(h->avctx, AV_LOG_ERROR,
 -               "Unimplemented luma bit depth=%d (max=10)\n",
 -               h->sps.bit_depth_luma);
 -        return AVERROR_PATCHWELCOME;
 +        return AVERROR_INVALIDDATA;
      }
  
-     pps= av_mallocz(sizeof(PPS));
-     if(pps == NULL)
+     pps = av_mallocz(sizeof(PPS));
+     if (pps == NULL)
          return -1;
-     pps->sps_id= get_ue_golomb_31(&h->gb);
-     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
+     pps->sps_id = get_ue_golomb_31(&h->gb);
+     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
+         h->sps_buffers[pps->sps_id] == NULL) {
          av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
          goto fail;
      }
-     qp_bd_offset = 6*(sps->bit_depth_luma-8);
 +    sps = h->sps_buffers[pps->sps_id];
-         av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", sps->bit_depth_luma);
++    qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
 +    if (sps->bit_depth_luma > 14) {
-         av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", sps->bit_depth_luma);
++        av_log(h->avctx, AV_LOG_ERROR,
++               "Invalid luma bit depth=%d\n",
++               sps->bit_depth_luma);
 +        goto fail;
 +    } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
++        av_log(h->avctx, AV_LOG_ERROR,
++               "Unimplemented luma bit depth=%d\n",
++               sps->bit_depth_luma);
 +        goto fail;
 +    }
  
-     pps->cabac= get_bits1(&h->gb);
-     pps->pic_order_present= get_bits1(&h->gb);
-     pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
-     if(pps->slice_group_count > 1 ){
-         pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
+     pps->cabac             = get_bits1(&h->gb);
+     pps->pic_order_present = get_bits1(&h->gb);
+     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
+     if (pps->slice_group_count > 1) {
+         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
          av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
-         switch(pps->mb_slice_group_map_type){
+         switch (pps->mb_slice_group_map_type) {
          case 0:
  #if 0
|   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
|    run_length[ i ]                                |1  |ue(v)   |
    |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
    |           run_length[i]                               |1  |ue(v) |
  #endif
              break;
          case 2:
          goto fail;
      }
  
-     pps->weighted_pred= get_bits1(&h->gb);
-     pps->weighted_bipred_idc= get_bits(&h->gb, 2);
-     pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
-     pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
-     pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
-     pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
-     pps->constrained_intra_pred= get_bits1(&h->gb);
-     pps->redundant_pic_cnt_present = get_bits1(&h->gb);
-     pps->transform_8x8_mode= 0;
-     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
-     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
-     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
+     pps->weighted_pred                        = get_bits1(&h->gb);
+     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
+     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
+     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
+     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
+     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
+     pps->constrained_intra_pred               = get_bits1(&h->gb);
+     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
+     pps->transform_8x8_mode = 0;
+     // contents of sps/pps can change even if id doesn't, so reinit
+     h->dequant_coeff_pps = -1;
+     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
+            sizeof(pps->scaling_matrix4));
+     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
+            sizeof(pps->scaling_matrix8));
  
      bits_left = bit_length - get_bits_count(&h->gb);
-     if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
-         pps->transform_8x8_mode= get_bits1(&h->gb);
-         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
-         pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
 -    if (bits_left && (bits_left > 8 ||
 -                      show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
++    if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
+         pps->transform_8x8_mode = get_bits1(&h->gb);
+         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
+                                 pps->scaling_matrix4, pps->scaling_matrix8);
+         // second_chroma_qp_index_offset
+         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
      } else {
-         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
+         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
      }
  
 -    build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
 -                   h->sps.bit_depth_luma);
 -    build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
 -                   h->sps.bit_depth_luma);
 +    build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
 +    build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
-     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
-         pps->chroma_qp_diff= 1;
+     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
+         pps->chroma_qp_diff = 1;
  
-     if(h->avctx->debug&FF_DEBUG_PICT_INFO){
-         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",
+     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
+         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",
                 pps_id, pps->sps_id,
                 pps->cabac ? "CABAC" : "CAVLC",
                 pps->slice_group_count,