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