FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
h264_ps.c
Go to the documentation of this file.
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 <inttypes.h>
29 
30 #include "libavutil/imgutils.h"
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "h264.h"
34 #include "h264data.h"
35 #include "golomb.h"
36 
37 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
38 #define MIN_LOG2_MAX_FRAME_NUM 4
39 
40 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
41 
42 #define CHROMA_QP_TABLE_END(d) \
43  QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
44  QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
45  QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
46  QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
47  QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
48  QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
49  QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
50  QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
51  QP(39, d), QP(39, d), QP(39, d), QP(39, d)
52 
53 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
54  { CHROMA_QP_TABLE_END(8) },
55  { 0, 1, 2, 3, 4, 5,
56  CHROMA_QP_TABLE_END(9) },
57  { 0, 1, 2, 3, 4, 5,
58  6, 7, 8, 9, 10, 11,
59  CHROMA_QP_TABLE_END(10) },
60  { 0, 1, 2, 3, 4, 5,
61  6, 7, 8, 9, 10, 11,
62  12,13,14,15, 16, 17,
63  CHROMA_QP_TABLE_END(11) },
64  { 0, 1, 2, 3, 4, 5,
65  6, 7, 8, 9, 10, 11,
66  12,13,14,15, 16, 17,
67  18,19,20,21, 22, 23,
68  CHROMA_QP_TABLE_END(12) },
69  { 0, 1, 2, 3, 4, 5,
70  6, 7, 8, 9, 10, 11,
71  12,13,14,15, 16, 17,
72  18,19,20,21, 22, 23,
73  24,25,26,27, 28, 29,
74  CHROMA_QP_TABLE_END(13) },
75  { 0, 1, 2, 3, 4, 5,
76  6, 7, 8, 9, 10, 11,
77  12,13,14,15, 16, 17,
78  18,19,20,21, 22, 23,
79  24,25,26,27, 28, 29,
80  30,31,32,33, 34, 35,
81  CHROMA_QP_TABLE_END(14) },
82 };
83 
84 static const uint8_t default_scaling4[2][16] = {
85  { 6, 13, 20, 28, 13, 20, 28, 32,
86  20, 28, 32, 37, 28, 32, 37, 42 },
87  { 10, 14, 20, 24, 14, 20, 24, 27,
88  20, 24, 27, 30, 24, 27, 30, 34 }
89 };
90 
91 static const uint8_t default_scaling8[2][64] = {
92  { 6, 10, 13, 16, 18, 23, 25, 27,
93  10, 11, 16, 18, 23, 25, 27, 29,
94  13, 16, 18, 23, 25, 27, 29, 31,
95  16, 18, 23, 25, 27, 29, 31, 33,
96  18, 23, 25, 27, 29, 31, 33, 36,
97  23, 25, 27, 29, 31, 33, 36, 38,
98  25, 27, 29, 31, 33, 36, 38, 40,
99  27, 29, 31, 33, 36, 38, 40, 42 },
100  { 9, 13, 15, 17, 19, 21, 22, 24,
101  13, 13, 17, 19, 21, 22, 24, 25,
102  15, 17, 19, 21, 22, 24, 25, 27,
103  17, 19, 21, 22, 24, 25, 27, 28,
104  19, 21, 22, 24, 25, 27, 28, 30,
105  21, 22, 24, 25, 27, 28, 30, 32,
106  22, 24, 25, 27, 28, 30, 32, 33,
107  24, 25, 27, 28, 30, 32, 33, 35 }
108 };
109 
110 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
111 {
112  int cpb_count, i;
113  cpb_count = get_ue_golomb_31(&h->gb) + 1;
114 
115  if (cpb_count > 32U) {
116  av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
117  return AVERROR_INVALIDDATA;
118  }
119 
120  get_bits(&h->gb, 4); /* bit_rate_scale */
121  get_bits(&h->gb, 4); /* cpb_size_scale */
122  for (i = 0; i < cpb_count; i++) {
123  get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
124  get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
125  get_bits1(&h->gb); /* cbr_flag */
126  }
127  sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
128  sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
129  sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
130  sps->time_offset_length = get_bits(&h->gb, 5);
131  sps->cpb_cnt = cpb_count;
132  return 0;
133 }
134 
135 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
136 {
137  int aspect_ratio_info_present_flag;
138  unsigned int aspect_ratio_idc;
139 
140  aspect_ratio_info_present_flag = get_bits1(&h->gb);
141 
142  if (aspect_ratio_info_present_flag) {
143  aspect_ratio_idc = get_bits(&h->gb, 8);
144  if (aspect_ratio_idc == EXTENDED_SAR) {
145  sps->sar.num = get_bits(&h->gb, 16);
146  sps->sar.den = get_bits(&h->gb, 16);
147  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
148  sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
149  } else {
150  av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
151  return AVERROR_INVALIDDATA;
152  }
153  } else {
154  sps->sar.num =
155  sps->sar.den = 0;
156  }
157 
158  if (get_bits1(&h->gb)) /* overscan_info_present_flag */
159  get_bits1(&h->gb); /* overscan_appropriate_flag */
160 
161  sps->video_signal_type_present_flag = get_bits1(&h->gb);
162  if (sps->video_signal_type_present_flag) {
163  get_bits(&h->gb, 3); /* video_format */
164  sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
165 
166  sps->colour_description_present_flag = get_bits1(&h->gb);
167  if (sps->colour_description_present_flag) {
168  sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
169  sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
170  sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
171  if (sps->color_primaries >= AVCOL_PRI_NB)
172  sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
173  if (sps->color_trc >= AVCOL_TRC_NB)
174  sps->color_trc = AVCOL_TRC_UNSPECIFIED;
175  if (sps->colorspace >= AVCOL_SPC_NB)
176  sps->colorspace = AVCOL_SPC_UNSPECIFIED;
177  }
178  }
179 
180  /* chroma_location_info_present_flag */
181  if (get_bits1(&h->gb)) {
182  /* chroma_sample_location_type_top_field */
183  h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
184  get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
185  }
186 
187  if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
188  av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
189  return 0;
190  }
191 
192  sps->timing_info_present_flag = get_bits1(&h->gb);
193  if (sps->timing_info_present_flag) {
194  sps->num_units_in_tick = get_bits_long(&h->gb, 32);
195  sps->time_scale = get_bits_long(&h->gb, 32);
196  if (!sps->num_units_in_tick || !sps->time_scale) {
197  av_log(h->avctx, AV_LOG_ERROR,
198  "time_scale/num_units_in_tick invalid or unsupported (%"PRIu32"/%"PRIu32")\n",
199  sps->time_scale, sps->num_units_in_tick);
200  return AVERROR_INVALIDDATA;
201  }
202  sps->fixed_frame_rate_flag = get_bits1(&h->gb);
203  }
204 
205  sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
206  if (sps->nal_hrd_parameters_present_flag)
207  if (decode_hrd_parameters(h, sps) < 0)
208  return AVERROR_INVALIDDATA;
209  sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
210  if (sps->vcl_hrd_parameters_present_flag)
211  if (decode_hrd_parameters(h, sps) < 0)
212  return AVERROR_INVALIDDATA;
213  if (sps->nal_hrd_parameters_present_flag ||
214  sps->vcl_hrd_parameters_present_flag)
215  get_bits1(&h->gb); /* low_delay_hrd_flag */
216  sps->pic_struct_present_flag = get_bits1(&h->gb);
217  if (!get_bits_left(&h->gb))
218  return 0;
219  sps->bitstream_restriction_flag = get_bits1(&h->gb);
220  if (sps->bitstream_restriction_flag) {
221  get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
222  get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
223  get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
224  get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
225  get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
226  sps->num_reorder_frames = get_ue_golomb(&h->gb);
227  get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
228 
229  if (get_bits_left(&h->gb) < 0) {
230  sps->num_reorder_frames = 0;
231  sps->bitstream_restriction_flag = 0;
232  }
233 
234  if (sps->num_reorder_frames > 16U
235  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
236  av_log(h->avctx, AV_LOG_ERROR,
237  "Clipping illegal num_reorder_frames %d\n",
238  sps->num_reorder_frames);
239  sps->num_reorder_frames = 16;
240  return AVERROR_INVALIDDATA;
241  }
242  }
243 
244  if (get_bits_left(&h->gb) < 0) {
245  av_log(h->avctx, AV_LOG_ERROR,
246  "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
247  return AVERROR_INVALIDDATA;
248  }
249 
250  return 0;
251 }
252 
253 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
254  const uint8_t *jvt_list,
255  const uint8_t *fallback_list)
256 {
257  int i, last = 8, next = 8;
258  const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
259  if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
260  memcpy(factors, fallback_list, size * sizeof(uint8_t));
261  else
262  for (i = 0; i < size; i++) {
263  if (next)
264  next = (last + get_se_golomb(&h->gb)) & 0xff;
265  if (!i && !next) { /* matrix not written, we use the preset one */
266  memcpy(factors, jvt_list, size * sizeof(uint8_t));
267  break;
268  }
269  last = factors[scan[i]] = next ? next : last;
270  }
271 }
272 
273 static void decode_scaling_matrices(H264Context *h, SPS *sps,
274  PPS *pps, int is_sps,
275  uint8_t(*scaling_matrix4)[16],
276  uint8_t(*scaling_matrix8)[64])
277 {
278  int fallback_sps = !is_sps && sps->scaling_matrix_present;
279  const uint8_t *fallback[4] = {
280  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
281  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
282  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
283  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
284  };
285  if (get_bits1(&h->gb)) {
286  sps->scaling_matrix_present |= is_sps;
287  decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
288  decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
289  decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
290  decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
291  decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
292  decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
293  if (is_sps || pps->transform_8x8_mode) {
294  decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
295  decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
296  if (sps->chroma_format_idc == 3) {
297  decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
298  decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
299  decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
300  decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
301  }
302  }
303  }
304 }
305 
306 int ff_h264_decode_seq_parameter_set(H264Context *h)
307 {
308  int profile_idc, level_idc, constraint_set_flags = 0;
309  unsigned int sps_id;
310  int i, log2_max_frame_num_minus4;
311  SPS *sps;
312 
313  profile_idc = get_bits(&h->gb, 8);
314  constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
315  constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
316  constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
317  constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
318  constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
319  constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
320  skip_bits(&h->gb, 2); // reserved_zero_2bits
321  level_idc = get_bits(&h->gb, 8);
322  sps_id = get_ue_golomb_31(&h->gb);
323 
324  if (sps_id >= MAX_SPS_COUNT) {
325  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
326  return AVERROR_INVALIDDATA;
327  }
328  sps = av_mallocz(sizeof(SPS));
329  if (!sps)
330  return AVERROR(ENOMEM);
331 
332  sps->sps_id = sps_id;
333  sps->time_offset_length = 24;
334  sps->profile_idc = profile_idc;
335  sps->constraint_set_flags = constraint_set_flags;
336  sps->level_idc = level_idc;
337  sps->full_range = -1;
338 
339  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
340  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
341  sps->scaling_matrix_present = 0;
342  sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
343 
344  if (sps->profile_idc == 100 || // High profile
345  sps->profile_idc == 110 || // High10 profile
346  sps->profile_idc == 122 || // High422 profile
347  sps->profile_idc == 244 || // High444 Predictive profile
348  sps->profile_idc == 44 || // Cavlc444 profile
349  sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
350  sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
351  sps->profile_idc == 118 || // Stereo High profile (MVC)
352  sps->profile_idc == 128 || // Multiview High profile (MVC)
353  sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
354  sps->profile_idc == 144) { // old High444 profile
355  sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
356  if (sps->chroma_format_idc > 3U) {
357  avpriv_request_sample(h->avctx, "chroma_format_idc %u",
358  sps->chroma_format_idc);
359  goto fail;
360  } else if (sps->chroma_format_idc == 3) {
361  sps->residual_color_transform_flag = get_bits1(&h->gb);
362  if (sps->residual_color_transform_flag) {
363  av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
364  goto fail;
365  }
366  }
367  sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
368  sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
369  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
370  avpriv_request_sample(h->avctx,
371  "Different chroma and luma bit depth");
372  goto fail;
373  }
374  if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
375  av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
376  sps->bit_depth_luma, sps->bit_depth_chroma);
377  goto fail;
378  }
379  sps->transform_bypass = get_bits1(&h->gb);
380  decode_scaling_matrices(h, sps, NULL, 1,
381  sps->scaling_matrix4, sps->scaling_matrix8);
382  } else {
383  sps->chroma_format_idc = 1;
384  sps->bit_depth_luma = 8;
385  sps->bit_depth_chroma = 8;
386  }
387 
388  log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
389  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
390  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
391  av_log(h->avctx, AV_LOG_ERROR,
392  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
393  log2_max_frame_num_minus4);
394  goto fail;
395  }
396  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
397 
398  sps->poc_type = get_ue_golomb_31(&h->gb);
399 
400  if (sps->poc_type == 0) { // FIXME #define
401  unsigned t = get_ue_golomb(&h->gb);
402  if (t>12) {
403  av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
404  goto fail;
405  }
406  sps->log2_max_poc_lsb = t + 4;
407  } else if (sps->poc_type == 1) { // FIXME #define
408  sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
409  sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
410  sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
411  sps->poc_cycle_length = get_ue_golomb(&h->gb);
412 
413  if ((unsigned)sps->poc_cycle_length >=
414  FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
415  av_log(h->avctx, AV_LOG_ERROR,
416  "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
417  goto fail;
418  }
419 
420  for (i = 0; i < sps->poc_cycle_length; i++)
421  sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
422  } else if (sps->poc_type != 2) {
423  av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
424  goto fail;
425  }
426 
427  sps->ref_frame_count = get_ue_golomb_31(&h->gb);
428  if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
429  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
430  if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
431  sps->ref_frame_count > 16U) {
432  av_log(h->avctx, AV_LOG_ERROR,
433  "too many reference frames %d\n", sps->ref_frame_count);
434  goto fail;
435  }
436  sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
437  sps->mb_width = get_ue_golomb(&h->gb) + 1;
438  sps->mb_height = get_ue_golomb(&h->gb) + 1;
439  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
440  (unsigned)sps->mb_height >= INT_MAX / 16 ||
441  av_image_check_size(16 * sps->mb_width,
442  16 * sps->mb_height, 0, h->avctx)) {
443  av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
444  goto fail;
445  }
446 
447  sps->frame_mbs_only_flag = get_bits1(&h->gb);
448  if (!sps->frame_mbs_only_flag)
449  sps->mb_aff = get_bits1(&h->gb);
450  else
451  sps->mb_aff = 0;
452 
453  sps->direct_8x8_inference_flag = get_bits1(&h->gb);
454 
455 #ifndef ALLOW_INTERLACE
456  if (sps->mb_aff)
457  av_log(h->avctx, AV_LOG_ERROR,
458  "MBAFF support not included; enable it at compile-time.\n");
459 #endif
460  sps->crop = get_bits1(&h->gb);
461  if (sps->crop) {
462  int crop_left = get_ue_golomb(&h->gb);
463  int crop_right = get_ue_golomb(&h->gb);
464  int crop_top = get_ue_golomb(&h->gb);
465  int crop_bottom = get_ue_golomb(&h->gb);
466  int width = 16 * sps->mb_width;
467  int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
468 
469  if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
470  av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
471  "values are l:%d r:%d t:%d b:%d\n",
472  crop_left, crop_right, crop_top, crop_bottom);
473 
474  sps->crop_left =
475  sps->crop_right =
476  sps->crop_top =
477  sps->crop_bottom = 0;
478  } else {
479  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
480  int hsub = (sps->chroma_format_idc == 1 ||
481  sps->chroma_format_idc == 2) ? 1 : 0;
482  int step_x = 1 << hsub;
483  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
484 
485  if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
486  !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
487  crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
488  av_log(h->avctx, AV_LOG_WARNING,
489  "Reducing left cropping to %d "
490  "chroma samples to preserve alignment.\n",
491  crop_left);
492  }
493 
494  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
495  crop_right > (unsigned)INT_MAX / 4 / step_x ||
496  crop_top > (unsigned)INT_MAX / 4 / step_y ||
497  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
498  (crop_left + crop_right ) * step_x >= width ||
499  (crop_top + crop_bottom) * step_y >= height
500  ) {
501  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);
502  goto fail;
503  }
504 
505  sps->crop_left = crop_left * step_x;
506  sps->crop_right = crop_right * step_x;
507  sps->crop_top = crop_top * step_y;
508  sps->crop_bottom = crop_bottom * step_y;
509  }
510  } else {
511  sps->crop_left =
512  sps->crop_right =
513  sps->crop_top =
514  sps->crop_bottom =
515  sps->crop = 0;
516  }
517 
518  sps->vui_parameters_present_flag = get_bits1(&h->gb);
519  if (sps->vui_parameters_present_flag) {
520  int ret = decode_vui_parameters(h, sps);
521  if (ret < 0)
522  goto fail;
523  }
524 
525  if (!sps->sar.den)
526  sps->sar.den = 1;
527 
528  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
529  static const char csp[4][5] = { "Gray", "420", "422", "444" };
530  av_log(h->avctx, AV_LOG_DEBUG,
531  "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",
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  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 
555 fail:
556  av_free(sps);
557  return -1;
558 }
559 
560 static void 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] =
566  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
567 }
568 
569 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
570 {
571  const SPS *sps = h->sps_buffers[pps->sps_id];
572  int profile_idc = sps->profile_idc;
573 
574  if ((profile_idc == 66 || profile_idc == 77 ||
575  profile_idc == 88) && (sps->constraint_set_flags & 7)) {
576  av_log(h->avctx, AV_LOG_VERBOSE,
577  "Current profile doesn't provide more RBSP data in PPS, skipping\n");
578  return 0;
579  }
580 
581  return 1;
582 }
583 
584 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
585 {
586  unsigned int pps_id = get_ue_golomb(&h->gb);
587  PPS *pps;
588  SPS *sps;
589  int qp_bd_offset;
590  int bits_left;
591 
592  if (pps_id >= MAX_PPS_COUNT) {
593  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
594  return AVERROR_INVALIDDATA;
595  }
596 
597  pps = av_mallocz(sizeof(PPS));
598  if (!pps)
599  return AVERROR(ENOMEM);
600  pps->sps_id = get_ue_golomb_31(&h->gb);
601  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
602  !h->sps_buffers[pps->sps_id]) {
603  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
604  goto fail;
605  }
606  sps = h->sps_buffers[pps->sps_id];
607  qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
608  if (sps->bit_depth_luma > 14) {
609  av_log(h->avctx, AV_LOG_ERROR,
610  "Invalid luma bit depth=%d\n",
611  sps->bit_depth_luma);
612  goto fail;
613  } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
614  av_log(h->avctx, AV_LOG_ERROR,
615  "Unimplemented luma bit depth=%d\n",
616  sps->bit_depth_luma);
617  goto fail;
618  }
619 
620  pps->cabac = get_bits1(&h->gb);
621  pps->pic_order_present = get_bits1(&h->gb);
622  pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
623  if (pps->slice_group_count > 1) {
624  pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
625  av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
626  switch (pps->mb_slice_group_map_type) {
627  case 0:
628 #if 0
629  | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
630  | run_length[i] |1 |ue(v) |
631 #endif
632  break;
633  case 2:
634 #if 0
635  | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
636  | top_left_mb[i] |1 |ue(v) |
637  | bottom_right_mb[i] |1 |ue(v) |
638  | } | | |
639 #endif
640  break;
641  case 3:
642  case 4:
643  case 5:
644 #if 0
645  | slice_group_change_direction_flag |1 |u(1) |
646  | slice_group_change_rate_minus1 |1 |ue(v) |
647 #endif
648  break;
649  case 6:
650 #if 0
651  | slice_group_id_cnt_minus1 |1 |ue(v) |
652  | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
653  | slice_group_id[i] |1 |u(v) |
654 #endif
655  break;
656  }
657  }
658  pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
659  pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
660  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
661  av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
662  goto fail;
663  }
664 
665  pps->weighted_pred = get_bits1(&h->gb);
666  pps->weighted_bipred_idc = get_bits(&h->gb, 2);
667  pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
668  pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
669  pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
670  pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
671  pps->constrained_intra_pred = get_bits1(&h->gb);
672  pps->redundant_pic_cnt_present = get_bits1(&h->gb);
673 
674  pps->transform_8x8_mode = 0;
675  // contents of sps/pps can change even if id doesn't, so reinit
676  h->dequant_coeff_pps = -1;
677  memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
678  sizeof(pps->scaling_matrix4));
679  memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
680  sizeof(pps->scaling_matrix8));
681 
682  bits_left = bit_length - get_bits_count(&h->gb);
683  if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
684  pps->transform_8x8_mode = get_bits1(&h->gb);
685  decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
686  pps->scaling_matrix4, pps->scaling_matrix8);
687  // second_chroma_qp_index_offset
688  pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
689  } else {
690  pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
691  }
692 
693  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
694  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
695  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
696  pps->chroma_qp_diff = 1;
697 
698  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
699  av_log(h->avctx, AV_LOG_DEBUG,
700  "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
701  pps_id, pps->sps_id,
702  pps->cabac ? "CABAC" : "CAVLC",
703  pps->slice_group_count,
704  pps->ref_count[0], pps->ref_count[1],
705  pps->weighted_pred ? "weighted" : "",
706  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
707  pps->deblocking_filter_parameters_present ? "LPAR" : "",
708  pps->constrained_intra_pred ? "CONSTR" : "",
709  pps->redundant_pic_cnt_present ? "REDU" : "",
710  pps->transform_8x8_mode ? "8x8DCT" : "");
711  }
712 
713  av_free(h->pps_buffers[pps_id]);
714  h->pps_buffers[pps_id] = pps;
715  return 0;
716 
717 fail:
718  av_free(pps);
719  return -1;
720 }
Generated on Fri Dec 5 2014 04:41:55 for FFmpeg by   doxygen 1.8.2