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