falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
93664 Commits
32 Branches
837MB
Tree: a42e761b96
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a42e761b96'
${ noResults }
FFmpeg/libavcodec/h264_ps.c

864 lines
32KB
Raw Blame History 

  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 / MPEG-4 part10 parameter set decoding.

  25.  * @author Michael Niedermayer <michaelni@gmx.at>

  26.  */

  27. 

  28. #include <inttypes.h>

  29. 

  30. #include "libavutil/imgutils.h"

  31. #include "internal.h"

  32. #include "mathops.h"

  33. #include "avcodec.h"

  34. #include "h264data.h"

  35. #include "h264_ps.h"

  36. #include "golomb.h"

  37. 

  38. #define MIN_LOG2_MAX_FRAME_NUM    4

  39. 

  40. #define EXTENDED_SAR       255

  41. 

  42. static const uint8_t default_scaling4[2][16] = {

  43.     {  6, 13, 20, 28, 13, 20, 28, 32,

  44.       20, 28, 32, 37, 28, 32, 37, 42 },

  45.     { 10, 14, 20, 24, 14, 20, 24, 27,

  46.       20, 24, 27, 30, 24, 27, 30, 34 }

  47. };

  48. 

  49. static const uint8_t default_scaling8[2][64] = {

  50.     {  6, 10, 13, 16, 18, 23, 25, 27,

  51.       10, 11, 16, 18, 23, 25, 27, 29,

  52.       13, 16, 18, 23, 25, 27, 29, 31,

  53.       16, 18, 23, 25, 27, 29, 31, 33,

  54.       18, 23, 25, 27, 29, 31, 33, 36,

  55.       23, 25, 27, 29, 31, 33, 36, 38,

  56.       25, 27, 29, 31, 33, 36, 38, 40,

  57.       27, 29, 31, 33, 36, 38, 40, 42 },

  58.     {  9, 13, 15, 17, 19, 21, 22, 24,

  59.       13, 13, 17, 19, 21, 22, 24, 25,

  60.       15, 17, 19, 21, 22, 24, 25, 27,

  61.       17, 19, 21, 22, 24, 25, 27, 28,

  62.       19, 21, 22, 24, 25, 27, 28, 30,

  63.       21, 22, 24, 25, 27, 28, 30, 32,

  64.       22, 24, 25, 27, 28, 30, 32, 33,

  65.       24, 25, 27, 28, 30, 32, 33, 35 }

  66. };

  67. 

  68. /* maximum number of MBs in the DPB for a given level */

  69. static const int level_max_dpb_mbs[][2] = {

  70.     { 10, 396       },

  71.     { 11, 900       },

  72.     { 12, 2376      },

  73.     { 13, 2376      },

  74.     { 20, 2376      },

  75.     { 21, 4752      },

  76.     { 22, 8100      },

  77.     { 30, 8100      },

  78.     { 31, 18000     },

  79.     { 32, 20480     },

  80.     { 40, 32768     },

  81.     { 41, 32768     },

  82.     { 42, 34816     },

  83.     { 50, 110400    },

  84.     { 51, 184320    },

  85.     { 52, 184320    },

  86. };

  87. 

  88. static void remove_pps(H264ParamSets *s, int id)

  89. {

  90.     av_buffer_unref(&s->pps_list[id]);

  91. }

  92. 

  93. static void remove_sps(H264ParamSets *s, int id)

  94. {

  95. #if 0

  96.     int i;

  97.     if (s->sps_list[id]) {

  98.         /* drop all PPS that depend on this SPS */

  99.         for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)

  100.             if (s->pps_list[i] && ((PPS*)s->pps_list[i]->data)->sps_id == id)

  101.                 remove_pps(s, i);

  102.     }

  103. #endif

  104.     av_buffer_unref(&s->sps_list[id]);

  105. }

  106. 

  107. static inline int decode_hrd_parameters(GetBitContext *gb, AVCodecContext *avctx,

  108.                                         SPS *sps)

  109. {

  110.     int cpb_count, i;

  111.     cpb_count = get_ue_golomb_31(gb) + 1;

  112. 

  113.     if (cpb_count > 32U) {

  114.         av_log(avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);

  115.         return AVERROR_INVALIDDATA;

  116.     }

  117. 

  118.     get_bits(gb, 4); /* bit_rate_scale */

  119.     get_bits(gb, 4); /* cpb_size_scale */

  120.     for (i = 0; i < cpb_count; i++) {

  121.         get_ue_golomb_long(gb); /* bit_rate_value_minus1 */

  122.         get_ue_golomb_long(gb); /* cpb_size_value_minus1 */

  123.         get_bits1(gb);          /* cbr_flag */

  124.     }

  125.     sps->initial_cpb_removal_delay_length = get_bits(gb, 5) + 1;

  126.     sps->cpb_removal_delay_length         = get_bits(gb, 5) + 1;

  127.     sps->dpb_output_delay_length          = get_bits(gb, 5) + 1;

  128.     sps->time_offset_length               = get_bits(gb, 5);

  129.     sps->cpb_cnt                          = cpb_count;

  130.     return 0;

  131. }

  132. 

  133. static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx,

  134.                                         SPS *sps)

  135. {

  136.     int aspect_ratio_info_present_flag;

  137.     unsigned int aspect_ratio_idc;

  138. 

  139.     aspect_ratio_info_present_flag = get_bits1(gb);

  140. 

  141.     if (aspect_ratio_info_present_flag) {

  142.         aspect_ratio_idc = get_bits(gb, 8);

  143.         if (aspect_ratio_idc == EXTENDED_SAR) {

  144.             sps->sar.num = get_bits(gb, 16);

  145.             sps->sar.den = get_bits(gb, 16);

  146.         } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {

  147.             sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];

  148.         } else {

  149.             av_log(avctx, AV_LOG_ERROR, "illegal aspect ratio\n");

  150.             return AVERROR_INVALIDDATA;

  151.         }

  152.     } else {

  153.         sps->sar.num =

  154.         sps->sar.den = 0;

  155.     }

  156. 

  157.     if (get_bits1(gb))      /* overscan_info_present_flag */

  158.         get_bits1(gb);      /* overscan_appropriate_flag */

  159. 

  160.     sps->video_signal_type_present_flag = get_bits1(gb);

  161.     if (sps->video_signal_type_present_flag) {

  162.         get_bits(gb, 3);                 /* video_format */

  163.         sps->full_range = get_bits1(gb); /* video_full_range_flag */

  164. 

  165.         sps->colour_description_present_flag = get_bits1(gb);

  166.         if (sps->colour_description_present_flag) {

  167.             sps->color_primaries = get_bits(gb, 8); /* colour_primaries */

  168.             sps->color_trc       = get_bits(gb, 8); /* transfer_characteristics */

  169.             sps->colorspace      = get_bits(gb, 8); /* matrix_coefficients */

  170. 

  171.             // Set invalid values to "unspecified"

  172.             if (!av_color_primaries_name(sps->color_primaries))

  173.                 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;

  174.             if (!av_color_transfer_name(sps->color_trc))

  175.                 sps->color_trc = AVCOL_TRC_UNSPECIFIED;

  176.             if (!av_color_space_name(sps->colorspace))

  177.                 sps->colorspace = AVCOL_SPC_UNSPECIFIED;

  178.         }

  179.     }

  180. 

  181.     /* chroma_location_info_present_flag */

  182.     if (get_bits1(gb)) {

  183.         /* chroma_sample_location_type_top_field */

  184.         avctx->chroma_sample_location = get_ue_golomb(gb) + 1;

  185.         get_ue_golomb(gb);  /* chroma_sample_location_type_bottom_field */

  186.     }

  187. 

  188.     if (show_bits1(gb) && get_bits_left(gb) < 10) {

  189.         av_log(avctx, AV_LOG_WARNING, "Truncated VUI\n");

  190.         return 0;

  191.     }

  192. 

  193.     sps->timing_info_present_flag = get_bits1(gb);

  194.     if (sps->timing_info_present_flag) {

  195.         unsigned num_units_in_tick = get_bits_long(gb, 32);

  196.         unsigned time_scale        = get_bits_long(gb, 32);

  197.         if (!num_units_in_tick || !time_scale) {

  198.             av_log(avctx, AV_LOG_ERROR,

  199.                    "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",

  200.                    time_scale, num_units_in_tick);

  201.             sps->timing_info_present_flag = 0;

  202.         } else {

  203.             sps->num_units_in_tick = num_units_in_tick;

  204.             sps->time_scale = time_scale;

  205.         }

  206.         sps->fixed_frame_rate_flag = get_bits1(gb);

  207.     }

  208. 

  209.     sps->nal_hrd_parameters_present_flag = get_bits1(gb);

  210.     if (sps->nal_hrd_parameters_present_flag)

  211.         if (decode_hrd_parameters(gb, avctx, sps) < 0)

  212.             return AVERROR_INVALIDDATA;

  213.     sps->vcl_hrd_parameters_present_flag = get_bits1(gb);

  214.     if (sps->vcl_hrd_parameters_present_flag)

  215.         if (decode_hrd_parameters(gb, avctx, sps) < 0)

  216.             return AVERROR_INVALIDDATA;

  217.     if (sps->nal_hrd_parameters_present_flag ||

  218.         sps->vcl_hrd_parameters_present_flag)

  219.         get_bits1(gb);     /* low_delay_hrd_flag */

  220.     sps->pic_struct_present_flag = get_bits1(gb);

  221.     if (!get_bits_left(gb))

  222.         return 0;

  223.     sps->bitstream_restriction_flag = get_bits1(gb);

  224.     if (sps->bitstream_restriction_flag) {

  225.         get_bits1(gb);     /* motion_vectors_over_pic_boundaries_flag */

  226.         get_ue_golomb(gb); /* max_bytes_per_pic_denom */

  227.         get_ue_golomb(gb); /* max_bits_per_mb_denom */

  228.         get_ue_golomb(gb); /* log2_max_mv_length_horizontal */

  229.         get_ue_golomb(gb); /* log2_max_mv_length_vertical */

  230.         sps->num_reorder_frames = get_ue_golomb(gb);

  231.         get_ue_golomb(gb); /*max_dec_frame_buffering*/

  232. 

  233.         if (get_bits_left(gb) < 0) {

  234.             sps->num_reorder_frames         = 0;

  235.             sps->bitstream_restriction_flag = 0;

  236.         }

  237. 

  238.         if (sps->num_reorder_frames > 16U

  239.             /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {

  240.             av_log(avctx, AV_LOG_ERROR,

  241.                    "Clipping illegal num_reorder_frames %d\n",

  242.                    sps->num_reorder_frames);

  243.             sps->num_reorder_frames = 16;

  244.             return AVERROR_INVALIDDATA;

  245.         }

  246.     }

  247. 

  248.     return 0;

  249. }

  250. 

  251. static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,

  252.                                 const uint8_t *jvt_list,

  253.                                 const uint8_t *fallback_list)

  254. {

  255.     int i, last = 8, next = 8;

  256.     const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;

  257.     if (!get_bits1(gb)) /* matrix not written, we use the predicted one */

  258.         memcpy(factors, fallback_list, size * sizeof(uint8_t));

  259.     else

  260.         for (i = 0; i < size; i++) {

  261.             if (next) {

  262.                 int v = get_se_golomb(gb);

  263.                 if (v < -128 || v > 127) {

  264.                     av_log(NULL, AV_LOG_ERROR, "delta scale %d is invalid\n", v);

  265.                     return AVERROR_INVALIDDATA;

  266.                 }

  267.                 next = (last + v) & 0xff;

  268.             }

  269.             if (!i && !next) { /* matrix not written, we use the preset one */

  270.                 memcpy(factors, jvt_list, size * sizeof(uint8_t));

  271.                 break;

  272.             }

  273.             last = factors[scan[i]] = next ? next : last;

  274.         }

  275.     return 0;

  276. }

  277. 

  278. /* returns non zero if the provided SPS scaling matrix has been filled */

  279. static int decode_scaling_matrices(GetBitContext *gb, const SPS *sps,

  280.                                     const PPS *pps, int is_sps,

  281.                                     uint8_t(*scaling_matrix4)[16],

  282.                                     uint8_t(*scaling_matrix8)[64])

  283. {

  284.     int fallback_sps = !is_sps && sps->scaling_matrix_present;

  285.     const uint8_t *fallback[4] = {

  286.         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],

  287.         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],

  288.         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],

  289.         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]

  290.     };

  291.     int ret = 0;

  292.     if (get_bits1(gb)) {

  293.         ret |= decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y

  294.         ret |= decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr

  295.         ret |= decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb

  296.         ret |= decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y

  297.         ret |= decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr

  298.         ret |= decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb

  299.         if (is_sps || pps->transform_8x8_mode) {

  300.             ret |= decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y

  301.             ret |= decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y

  302.             if (sps->chroma_format_idc == 3) {

  303.                 ret |= decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr

  304.                 ret |= decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr

  305.                 ret |= decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb

  306.                 ret |= decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb

  307.             }

  308.         }

  309.         if (!ret)

  310.             ret = is_sps;

  311.     }

  312. 

  313.     return ret;

  314. }

  315. 

  316. void ff_h264_ps_uninit(H264ParamSets *ps)

  317. {

  318.     int i;

  319. 

  320.     for (i = 0; i < MAX_SPS_COUNT; i++)

  321.         av_buffer_unref(&ps->sps_list[i]);

  322. 

  323.     for (i = 0; i < MAX_PPS_COUNT; i++)

  324.         av_buffer_unref(&ps->pps_list[i]);

  325. 

  326.     av_buffer_unref(&ps->sps_ref);

  327.     av_buffer_unref(&ps->pps_ref);

  328. 

  329.     ps->pps = NULL;

  330.     ps->sps = NULL;

  331. }

  332. 

  333. int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,

  334.                                      H264ParamSets *ps, int ignore_truncation)

  335. {

  336.     AVBufferRef *sps_buf;

  337.     int profile_idc, level_idc, constraint_set_flags = 0;

  338.     unsigned int sps_id;

  339.     int i, log2_max_frame_num_minus4;

  340.     SPS *sps;

  341.     int ret;

  342. 

  343.     sps_buf = av_buffer_allocz(sizeof(*sps));

  344.     if (!sps_buf)

  345.         return AVERROR(ENOMEM);

  346.     sps = (SPS*)sps_buf->data;

  347. 

  348.     sps->data_size = gb->buffer_end - gb->buffer;

  349.     if (sps->data_size > sizeof(sps->data)) {

  350.         av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized SPS\n");

  351.         sps->data_size = sizeof(sps->data);

  352.     }

  353.     memcpy(sps->data, gb->buffer, sps->data_size);

  354. 

  355.     profile_idc           = get_bits(gb, 8);

  356.     constraint_set_flags |= get_bits1(gb) << 0;   // constraint_set0_flag

  357.     constraint_set_flags |= get_bits1(gb) << 1;   // constraint_set1_flag

  358.     constraint_set_flags |= get_bits1(gb) << 2;   // constraint_set2_flag

  359.     constraint_set_flags |= get_bits1(gb) << 3;   // constraint_set3_flag

  360.     constraint_set_flags |= get_bits1(gb) << 4;   // constraint_set4_flag

  361.     constraint_set_flags |= get_bits1(gb) << 5;   // constraint_set5_flag

  362.     skip_bits(gb, 2);                             // reserved_zero_2bits

  363.     level_idc = get_bits(gb, 8);

  364.     sps_id    = get_ue_golomb_31(gb);

  365. 

  366.     if (sps_id >= MAX_SPS_COUNT) {

  367.         av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);

  368.         goto fail;

  369.     }

  370. 

  371.     sps->sps_id               = sps_id;

  372.     sps->time_offset_length   = 24;

  373.     sps->profile_idc          = profile_idc;

  374.     sps->constraint_set_flags = constraint_set_flags;

  375.     sps->level_idc            = level_idc;

  376.     sps->full_range           = -1;

  377. 

  378.     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));

  379.     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));

  380.     sps->scaling_matrix_present = 0;

  381.     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED

  382. 

  383.     if (sps->profile_idc == 100 ||  // High profile

  384.         sps->profile_idc == 110 ||  // High10 profile

  385.         sps->profile_idc == 122 ||  // High422 profile

  386.         sps->profile_idc == 244 ||  // High444 Predictive profile

  387.         sps->profile_idc ==  44 ||  // Cavlc444 profile

  388.         sps->profile_idc ==  83 ||  // Scalable Constrained High profile (SVC)

  389.         sps->profile_idc ==  86 ||  // Scalable High Intra profile (SVC)

  390.         sps->profile_idc == 118 ||  // Stereo High profile (MVC)

  391.         sps->profile_idc == 128 ||  // Multiview High profile (MVC)

  392.         sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)

  393.         sps->profile_idc == 144) {  // old High444 profile

  394.         sps->chroma_format_idc = get_ue_golomb_31(gb);

  395.         if (sps->chroma_format_idc > 3U) {

  396.             avpriv_request_sample(avctx, "chroma_format_idc %u",

  397.                                   sps->chroma_format_idc);

  398.             goto fail;

  399.         } else if (sps->chroma_format_idc == 3) {

  400.             sps->residual_color_transform_flag = get_bits1(gb);

  401.             if (sps->residual_color_transform_flag) {

  402.                 av_log(avctx, AV_LOG_ERROR, "separate color planes are not supported\n");

  403.                 goto fail;

  404.             }

  405.         }

  406.         sps->bit_depth_luma   = get_ue_golomb(gb) + 8;

  407.         sps->bit_depth_chroma = get_ue_golomb(gb) + 8;

  408.         if (sps->bit_depth_chroma != sps->bit_depth_luma) {

  409.             avpriv_request_sample(avctx,

  410.                                   "Different chroma and luma bit depth");

  411.             goto fail;

  412.         }

  413.         if (sps->bit_depth_luma   < 8 || sps->bit_depth_luma   > 14 ||

  414.             sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {

  415.             av_log(avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",

  416.                    sps->bit_depth_luma, sps->bit_depth_chroma);

  417.             goto fail;

  418.         }

  419.         sps->transform_bypass = get_bits1(gb);

  420.         ret = decode_scaling_matrices(gb, sps, NULL, 1,

  421.                                       sps->scaling_matrix4, sps->scaling_matrix8);

  422.         if (ret < 0)

  423.             goto fail;

  424.         sps->scaling_matrix_present |= ret;

  425.     } else {

  426.         sps->chroma_format_idc = 1;

  427.         sps->bit_depth_luma    = 8;

  428.         sps->bit_depth_chroma  = 8;

  429.     }

  430. 

  431.     log2_max_frame_num_minus4 = get_ue_golomb(gb);

  432.     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||

  433.         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {

  434.         av_log(avctx, AV_LOG_ERROR,

  435.                "log2_max_frame_num_minus4 out of range (0-12): %d\n",

  436.                log2_max_frame_num_minus4);

  437.         goto fail;

  438.     }

  439.     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;

  440. 

  441.     sps->poc_type = get_ue_golomb_31(gb);

  442. 

  443.     if (sps->poc_type == 0) { // FIXME #define

  444.         unsigned t = get_ue_golomb(gb);

  445.         if (t>12) {

  446.             av_log(avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);

  447.             goto fail;

  448.         }

  449.         sps->log2_max_poc_lsb = t + 4;

  450.     } else if (sps->poc_type == 1) { // FIXME #define

  451.         sps->delta_pic_order_always_zero_flag = get_bits1(gb);

  452.         sps->offset_for_non_ref_pic           = get_se_golomb_long(gb);

  453.         sps->offset_for_top_to_bottom_field   = get_se_golomb_long(gb);

  454.         sps->poc_cycle_length                 = get_ue_golomb(gb);

  455. 

  456.         if ((unsigned)sps->poc_cycle_length >=

  457.             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {

  458.             av_log(avctx, AV_LOG_ERROR,

  459.                    "poc_cycle_length overflow %d\n", sps->poc_cycle_length);

  460.             goto fail;

  461.         }

  462. 

  463.         for (i = 0; i < sps->poc_cycle_length; i++)

  464.             sps->offset_for_ref_frame[i] = get_se_golomb_long(gb);

  465.     } else if (sps->poc_type != 2) {

  466.         av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);

  467.         goto fail;

  468.     }

  469. 

  470.     sps->ref_frame_count = get_ue_golomb_31(gb);

  471.     if (avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))

  472.         sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);

  473.     if (sps->ref_frame_count > MAX_DELAYED_PIC_COUNT) {

  474.         av_log(avctx, AV_LOG_ERROR,

  475.                "too many reference frames %d\n", sps->ref_frame_count);

  476.         goto fail;

  477.     }

  478.     sps->gaps_in_frame_num_allowed_flag = get_bits1(gb);

  479.     sps->mb_width                       = get_ue_golomb(gb) + 1;

  480.     sps->mb_height                      = get_ue_golomb(gb) + 1;

  481. 

  482.     sps->frame_mbs_only_flag = get_bits1(gb);

  483. 

  484.     if (sps->mb_height >= INT_MAX / 2U) {

  485.         av_log(avctx, AV_LOG_ERROR, "height overflow\n");

  486.         goto fail;

  487.     }

  488.     sps->mb_height *= 2 - sps->frame_mbs_only_flag;

  489. 

  490.     if (!sps->frame_mbs_only_flag)

  491.         sps->mb_aff = get_bits1(gb);

  492.     else

  493.         sps->mb_aff = 0;

  494. 

  495.     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||

  496.         (unsigned)sps->mb_height >= INT_MAX / 16 ||

  497.         av_image_check_size(16 * sps->mb_width,

  498.                             16 * sps->mb_height, 0, avctx)) {

  499.         av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");

  500.         goto fail;

  501.     }

  502. 

  503.     sps->direct_8x8_inference_flag = get_bits1(gb);

  504. 

  505. #ifndef ALLOW_INTERLACE

  506.     if (sps->mb_aff)

  507.         av_log(avctx, AV_LOG_ERROR,

  508.                "MBAFF support not included; enable it at compile-time.\n");

  509. #endif

  510.     sps->crop = get_bits1(gb);

  511.     if (sps->crop) {

  512.         unsigned int crop_left   = get_ue_golomb(gb);

  513.         unsigned int crop_right  = get_ue_golomb(gb);

  514.         unsigned int crop_top    = get_ue_golomb(gb);

  515.         unsigned int crop_bottom = get_ue_golomb(gb);

  516.         int width  = 16 * sps->mb_width;

  517.         int height = 16 * sps->mb_height;

  518. 

  519.         if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {

  520.             av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "

  521.                                            "values are l:%d r:%d t:%d b:%d\n",

  522.                    crop_left, crop_right, crop_top, crop_bottom);

  523. 

  524.             sps->crop_left   =

  525.             sps->crop_right  =

  526.             sps->crop_top    =

  527.             sps->crop_bottom = 0;

  528.         } else {

  529.             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;

  530.             int hsub   = (sps->chroma_format_idc == 1 ||

  531.                           sps->chroma_format_idc == 2) ? 1 : 0;

  532.             int step_x = 1 << hsub;

  533.             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;

  534. 

  535.             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||

  536.                 crop_right > (unsigned)INT_MAX / 4 / step_x ||

  537.                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||

  538.                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||

  539.                 (crop_left + crop_right ) * step_x >= width ||

  540.                 (crop_top  + crop_bottom) * step_y >= height

  541.             ) {

  542.                 av_log(avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);

  543.                 goto fail;

  544.             }

  545. 

  546.             sps->crop_left   = crop_left   * step_x;

  547.             sps->crop_right  = crop_right  * step_x;

  548.             sps->crop_top    = crop_top    * step_y;

  549.             sps->crop_bottom = crop_bottom * step_y;

  550.         }

  551.     } else {

  552.         sps->crop_left   =

  553.         sps->crop_right  =

  554.         sps->crop_top    =

  555.         sps->crop_bottom =

  556.         sps->crop        = 0;

  557.     }

  558. 

  559.     sps->vui_parameters_present_flag = get_bits1(gb);

  560.     if (sps->vui_parameters_present_flag) {

  561.         int ret = decode_vui_parameters(gb, avctx, sps);

  562.         if (ret < 0)

  563.             goto fail;

  564.     }

  565. 

  566.     if (get_bits_left(gb) < 0) {

  567.         av_log(avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,

  568.                "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(gb));

  569.         if (!ignore_truncation)

  570.             goto fail;

  571.     }

  572. 

  573.     /* if the maximum delay is not stored in the SPS, derive it based on the

  574.      * level */

  575.     if (!sps->bitstream_restriction_flag &&

  576.         (sps->ref_frame_count || avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT)) {

  577.         sps->num_reorder_frames = MAX_DELAYED_PIC_COUNT - 1;

  578.         for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {

  579.             if (level_max_dpb_mbs[i][0] == sps->level_idc) {

  580.                 sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),

  581.                                                 sps->num_reorder_frames);

  582.                 break;

  583.             }

  584.         }

  585.     }

  586. 

  587.     if (!sps->sar.den)

  588.         sps->sar.den = 1;

  589. 

  590.     if (avctx->debug & FF_DEBUG_PICT_INFO) {

  591.         static const char csp[4][5] = { "Gray", "420", "422", "444" };

  592.         av_log(avctx, AV_LOG_DEBUG,

  593.                "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",

  594.                sps_id, sps->profile_idc, sps->level_idc,

  595.                sps->poc_type,

  596.                sps->ref_frame_count,

  597.                sps->mb_width, sps->mb_height,

  598.                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),

  599.                sps->direct_8x8_inference_flag ? "8B8" : "",

  600.                sps->crop_left, sps->crop_right,

  601.                sps->crop_top, sps->crop_bottom,

  602.                sps->vui_parameters_present_flag ? "VUI" : "",

  603.                csp[sps->chroma_format_idc],

  604.                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,

  605.                sps->timing_info_present_flag ? sps->time_scale : 0,

  606.                sps->bit_depth_luma,

  607.                sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1

  608.                );

  609.     }

  610. 

  611.     /* check if this is a repeat of an already parsed SPS, then keep the

  612.      * original one.

  613.      * otherwise drop all PPSes that depend on it */

  614.     if (ps->sps_list[sps_id] &&

  615.         !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {

  616.         av_buffer_unref(&sps_buf);

  617.     } else {

  618.         remove_sps(ps, sps_id);

  619.         ps->sps_list[sps_id] = sps_buf;

  620.     }

  621. 

  622.     return 0;

  623. 

  624. fail:

  625.     av_buffer_unref(&sps_buf);

  626.     return AVERROR_INVALIDDATA;

  627. }

  628. 

  629. static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)

  630. {

  631.     int i, j, q, x;

  632.     const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);

  633. 

  634.     for (i = 0; i < 6; i++) {

  635.         pps->dequant8_coeff[i] = pps->dequant8_buffer[i];

  636.         for (j = 0; j < i; j++)

  637.             if (!memcmp(pps->scaling_matrix8[j], pps->scaling_matrix8[i],

  638.                         64 * sizeof(uint8_t))) {

  639.                 pps->dequant8_coeff[i] = pps->dequant8_buffer[j];

  640.                 break;

  641.             }

  642.         if (j < i)

  643.             continue;

  644. 

  645.         for (q = 0; q < max_qp + 1; q++) {

  646.             int shift = ff_h264_quant_div6[q];

  647.             int idx   = ff_h264_quant_rem6[q];

  648.             for (x = 0; x < 64; x++)

  649.                 pps->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =

  650.                     ((uint32_t)ff_h264_dequant8_coeff_init[idx][ff_h264_dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *

  651.                      pps->scaling_matrix8[i][x]) << shift;

  652.         }

  653.     }

  654. }

  655. 

  656. static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)

  657. {

  658.     int i, j, q, x;

  659.     const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);

  660.     for (i = 0; i < 6; i++) {

  661.         pps->dequant4_coeff[i] = pps->dequant4_buffer[i];

  662.         for (j = 0; j < i; j++)

  663.             if (!memcmp(pps->scaling_matrix4[j], pps->scaling_matrix4[i],

  664.                         16 * sizeof(uint8_t))) {

  665.                 pps->dequant4_coeff[i] = pps->dequant4_buffer[j];

  666.                 break;

  667.             }

  668.         if (j < i)

  669.             continue;

  670. 

  671.         for (q = 0; q < max_qp + 1; q++) {

  672.             int shift = ff_h264_quant_div6[q] + 2;

  673.             int idx   = ff_h264_quant_rem6[q];

  674.             for (x = 0; x < 16; x++)

  675.                 pps->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =

  676.                     ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *

  677.                      pps->scaling_matrix4[i][x]) << shift;

  678.         }

  679.     }

  680. }

  681. 

  682. static void init_dequant_tables(PPS *pps, const SPS *sps)

  683. {

  684.     int i, x;

  685.     init_dequant4_coeff_table(pps, sps);

  686.     memset(pps->dequant8_coeff, 0, sizeof(pps->dequant8_coeff));

  687. 

  688.     if (pps->transform_8x8_mode)

  689.         init_dequant8_coeff_table(pps, sps);

  690.     if (sps->transform_bypass) {

  691.         for (i = 0; i < 6; i++)

  692.             for (x = 0; x < 16; x++)

  693.                 pps->dequant4_coeff[i][0][x] = 1 << 6;

  694.         if (pps->transform_8x8_mode)

  695.             for (i = 0; i < 6; i++)

  696.                 for (x = 0; x < 64; x++)

  697.                     pps->dequant8_coeff[i][0][x] = 1 << 6;

  698.     }

  699. }

  700. 

  701. static void build_qp_table(PPS *pps, int t, int index, const int depth)

  702. {

  703.     int i;

  704.     const int max_qp = 51 + 6 * (depth - 8);

  705.     for (i = 0; i < max_qp + 1; i++)

  706.         pps->chroma_qp_table[t][i] =

  707.             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];

  708. }

  709. 

  710. static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)

  711. {

  712.     int profile_idc = sps->profile_idc;

  713. 

  714.     if ((profile_idc == 66 || profile_idc == 77 ||

  715.          profile_idc == 88) && (sps->constraint_set_flags & 7)) {

  716.         av_log(logctx, AV_LOG_VERBOSE,

  717.                "Current profile doesn't provide more RBSP data in PPS, skipping\n");

  718.         return 0;

  719.     }

  720. 

  721.     return 1;

  722. }

  723. 

  724. int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,

  725.                                          H264ParamSets *ps, int bit_length)

  726. {

  727.     AVBufferRef *pps_buf;

  728.     const SPS *sps;

  729.     unsigned int pps_id = get_ue_golomb(gb);

  730.     PPS *pps;

  731.     int qp_bd_offset;

  732.     int bits_left;

  733.     int ret;

  734. 

  735.     if (pps_id >= MAX_PPS_COUNT) {

  736.         av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);

  737.         return AVERROR_INVALIDDATA;

  738.     }

  739. 

  740.     pps_buf = av_buffer_allocz(sizeof(*pps));

  741.     if (!pps_buf)

  742.         return AVERROR(ENOMEM);

  743.     pps = (PPS*)pps_buf->data;

  744. 

  745.     pps->data_size = gb->buffer_end - gb->buffer;

  746.     if (pps->data_size > sizeof(pps->data)) {

  747.         av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized PPS "

  748.                "(%"SIZE_SPECIFIER" > %"SIZE_SPECIFIER")\n",

  749.                pps->data_size, sizeof(pps->data));

  750.         pps->data_size = sizeof(pps->data);

  751.     }

  752.     memcpy(pps->data, gb->buffer, pps->data_size);

  753. 

  754.     pps->sps_id = get_ue_golomb_31(gb);

  755.     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||

  756.         !ps->sps_list[pps->sps_id]) {

  757.         av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);

  758.         ret = AVERROR_INVALIDDATA;

  759.         goto fail;

  760.     }

  761.     sps = (const SPS*)ps->sps_list[pps->sps_id]->data;

  762.     if (sps->bit_depth_luma > 14) {

  763.         av_log(avctx, AV_LOG_ERROR,

  764.                "Invalid luma bit depth=%d\n",

  765.                sps->bit_depth_luma);

  766.         ret = AVERROR_INVALIDDATA;

  767.         goto fail;

  768.     } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {

  769.         avpriv_report_missing_feature(avctx,

  770.                "Unimplemented luma bit depth=%d",

  771.                sps->bit_depth_luma);

  772.         ret = AVERROR_PATCHWELCOME;

  773.         goto fail;

  774.     }

  775. 

  776.     pps->cabac             = get_bits1(gb);

  777.     pps->pic_order_present = get_bits1(gb);

  778.     pps->slice_group_count = get_ue_golomb(gb) + 1;

  779.     if (pps->slice_group_count > 1) {

  780.         pps->mb_slice_group_map_type = get_ue_golomb(gb);

  781.         av_log(avctx, AV_LOG_ERROR, "FMO not supported\n");

  782.     }

  783.     pps->ref_count[0] = get_ue_golomb(gb) + 1;

  784.     pps->ref_count[1] = get_ue_golomb(gb) + 1;

  785.     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {

  786.         av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");

  787.         ret = AVERROR_INVALIDDATA;

  788.         goto fail;

  789.     }

  790. 

  791.     qp_bd_offset = 6 * (sps->bit_depth_luma - 8);

  792. 

  793.     pps->weighted_pred                        = get_bits1(gb);

  794.     pps->weighted_bipred_idc                  = get_bits(gb, 2);

  795.     pps->init_qp                              = get_se_golomb(gb) + 26U + qp_bd_offset;

  796.     pps->init_qs                              = get_se_golomb(gb) + 26U + qp_bd_offset;

  797.     pps->chroma_qp_index_offset[0]            = get_se_golomb(gb);

  798.     if (pps->chroma_qp_index_offset[0] < -12 || pps->chroma_qp_index_offset[0] > 12) {

  799.         ret = AVERROR_INVALIDDATA;

  800.         goto fail;

  801.     }

  802. 

  803.     pps->deblocking_filter_parameters_present = get_bits1(gb);

  804.     pps->constrained_intra_pred               = get_bits1(gb);

  805.     pps->redundant_pic_cnt_present            = get_bits1(gb);

  806. 

  807.     pps->transform_8x8_mode = 0;

  808.     memcpy(pps->scaling_matrix4, sps->scaling_matrix4,

  809.            sizeof(pps->scaling_matrix4));

  810.     memcpy(pps->scaling_matrix8, sps->scaling_matrix8,

  811.            sizeof(pps->scaling_matrix8));

  812. 

  813.     bits_left = bit_length - get_bits_count(gb);

  814.     if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {

  815.         pps->transform_8x8_mode = get_bits1(gb);

  816.         ret = decode_scaling_matrices(gb, sps, pps, 0,

  817.                                 pps->scaling_matrix4, pps->scaling_matrix8);

  818.         if (ret < 0)

  819.             goto fail;

  820.         // second_chroma_qp_index_offset

  821.         pps->chroma_qp_index_offset[1] = get_se_golomb(gb);

  822.         if (pps->chroma_qp_index_offset[1] < -12 || pps->chroma_qp_index_offset[1] > 12) {

  823.             ret = AVERROR_INVALIDDATA;

  824.             goto fail;

  825.         }

  826.     } else {

  827.         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];

  828.     }

  829. 

  830.     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],

  831.                    sps->bit_depth_luma);

  832.     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],

  833.                    sps->bit_depth_luma);

  834. 

  835.     init_dequant_tables(pps, sps);

  836. 

  837.     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])

  838.         pps->chroma_qp_diff = 1;

  839. 

  840.     if (avctx->debug & FF_DEBUG_PICT_INFO) {

  841.         av_log(avctx, AV_LOG_DEBUG,

  842.                "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",

  843.                pps_id, pps->sps_id,

  844.                pps->cabac ? "CABAC" : "CAVLC",

  845.                pps->slice_group_count,

  846.                pps->ref_count[0], pps->ref_count[1],

  847.                pps->weighted_pred ? "weighted" : "",

  848.                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],

  849.                pps->deblocking_filter_parameters_present ? "LPAR" : "",

  850.                pps->constrained_intra_pred ? "CONSTR" : "",

  851.                pps->redundant_pic_cnt_present ? "REDU" : "",

  852.                pps->transform_8x8_mode ? "8x8DCT" : "");

  853.     }

  854. 

  855.     remove_pps(ps, pps_id);

  856.     ps->pps_list[pps_id] = pps_buf;

  857. 

  858.     return 0;

  859. 

  860. fail:

  861.     av_buffer_unref(&pps_buf);

  862.     return ret;

  863. }