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