2 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
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.
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.
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
24 * H.264 / AVC / MPEG4 part10 parameter set decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
28 #include "libavutil/imgutils.h"
32 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
39 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
40 #define MIN_LOG2_MAX_FRAME_NUM 4
42 static const AVRational pixel_aspect[17]={
62 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
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)
75 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
77 CHROMA_QP_TABLE_END(8)
81 CHROMA_QP_TABLE_END(9)
86 CHROMA_QP_TABLE_END(10)
92 CHROMA_QP_TABLE_END(11)
99 CHROMA_QP_TABLE_END(12)
107 CHROMA_QP_TABLE_END(13)
116 CHROMA_QP_TABLE_END(14)
120 static const uint8_t default_scaling4[2][16]={
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
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
152 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
154 cpb_count = get_ue_golomb_31(&h->gb) + 1;
157 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
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 */
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;
176 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
177 int aspect_ratio_info_present_flag;
178 unsigned int aspect_ratio_idc;
180 aspect_ratio_info_present_flag= get_bits1(&h->gb);
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];
190 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
197 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
199 if(get_bits1(&h->gb)){ /* overscan_info_present_flag */
200 get_bits1(&h->gb); /* overscan_appropriate_flag */
203 sps->video_signal_type_present_flag = get_bits1(&h->gb);
204 if(sps->video_signal_type_present_flag){
205 get_bits(&h->gb, 3); /* video_format */
206 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
208 sps->colour_description_present_flag = get_bits1(&h->gb);
209 if(sps->colour_description_present_flag){
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)
214 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
215 if (sps->color_trc >= AVCOL_TRC_NB)
216 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
217 if (sps->colorspace >= AVCOL_SPC_NB)
218 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
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 */
227 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
228 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
232 sps->timing_info_present_flag = get_bits1(&h->gb);
233 if(sps->timing_info_present_flag){
234 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
235 sps->time_scale = get_bits_long(&h->gb, 32);
236 if(!sps->num_units_in_tick || !sps->time_scale){
237 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);
240 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
243 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
244 if(sps->nal_hrd_parameters_present_flag)
245 if(decode_hrd_parameters(h, sps) < 0)
247 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
248 if(sps->vcl_hrd_parameters_present_flag)
249 if(decode_hrd_parameters(h, sps) < 0)
251 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
252 get_bits1(&h->gb); /* low_delay_hrd_flag */
253 sps->pic_struct_present_flag = get_bits1(&h->gb);
254 if(!get_bits_left(&h->gb))
256 sps->bitstream_restriction_flag = get_bits1(&h->gb);
257 if(sps->bitstream_restriction_flag){
258 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
259 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
260 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
261 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
262 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
263 sps->num_reorder_frames= get_ue_golomb(&h->gb);
264 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
266 if (get_bits_left(&h->gb) < 0) {
267 sps->num_reorder_frames=0;
268 sps->bitstream_restriction_flag= 0;
271 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
272 av_log(h->avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
277 if (get_bits_left(&h->gb) < 0) {
278 av_log(h->avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
279 return AVERROR_INVALIDDATA;
285 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
286 const uint8_t *jvt_list, const uint8_t *fallback_list){
287 int i, last = 8, next = 8;
288 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
289 if(!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
290 memcpy(factors, fallback_list, size*sizeof(uint8_t));
294 next = (last + get_se_golomb(&h->gb)) & 0xff;
295 if(!i && !next){ /* matrix not written, we use the preset one */
296 memcpy(factors, jvt_list, size*sizeof(uint8_t));
299 last = factors[scan[i]] = next ? next : last;
303 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
304 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
305 int fallback_sps = !is_sps && sps->scaling_matrix_present;
306 const uint8_t *fallback[4] = {
307 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
308 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
309 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
310 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
312 if(get_bits1(&h->gb)){
313 sps->scaling_matrix_present |= is_sps;
314 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
315 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
316 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
317 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
318 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
319 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
320 if(is_sps || pps->transform_8x8_mode){
321 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
322 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
323 if(sps->chroma_format_idc == 3){
324 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
325 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
326 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
327 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
333 int ff_h264_decode_seq_parameter_set(H264Context *h){
334 int profile_idc, level_idc, constraint_set_flags = 0;
336 int i, log2_max_frame_num_minus4;
339 profile_idc= get_bits(&h->gb, 8);
340 constraint_set_flags |= get_bits1(&h->gb) << 0; //constraint_set0_flag
341 constraint_set_flags |= get_bits1(&h->gb) << 1; //constraint_set1_flag
342 constraint_set_flags |= get_bits1(&h->gb) << 2; //constraint_set2_flag
343 constraint_set_flags |= get_bits1(&h->gb) << 3; //constraint_set3_flag
344 constraint_set_flags |= get_bits1(&h->gb) << 4; //constraint_set4_flag
345 constraint_set_flags |= get_bits1(&h->gb) << 5; //constraint_set5_flag
346 get_bits(&h->gb, 2); // reserved
347 level_idc= get_bits(&h->gb, 8);
348 sps_id= get_ue_golomb_31(&h->gb);
350 if(sps_id >= MAX_SPS_COUNT) {
351 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
354 sps= av_mallocz(sizeof(SPS));
358 sps->time_offset_length = 24;
359 sps->profile_idc= profile_idc;
360 sps->constraint_set_flags = constraint_set_flags;
361 sps->level_idc= level_idc;
362 sps->full_range = -1;
364 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
365 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
366 sps->scaling_matrix_present = 0;
367 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
369 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
370 sps->profile_idc == 122 || sps->profile_idc == 244 ||
371 sps->profile_idc == 44 || sps->profile_idc == 83 ||
372 sps->profile_idc == 86 || sps->profile_idc == 118 ||
373 sps->profile_idc == 128 || sps->profile_idc == 144) {
374 sps->chroma_format_idc= get_ue_golomb_31(&h->gb);
375 if (sps->chroma_format_idc > 3U) {
376 av_log(h->avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
378 } else if(sps->chroma_format_idc == 3) {
379 sps->residual_color_transform_flag = get_bits1(&h->gb);
380 if(sps->residual_color_transform_flag) {
381 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
385 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
386 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
387 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
388 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
389 sps->bit_depth_luma, sps->bit_depth_chroma);
392 sps->transform_bypass = get_bits1(&h->gb);
393 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
395 sps->chroma_format_idc= 1;
396 sps->bit_depth_luma = 8;
397 sps->bit_depth_chroma = 8;
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);
408 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
410 sps->poc_type= get_ue_golomb_31(&h->gb);
412 if(sps->poc_type == 0){ //FIXME #define
413 unsigned t = get_ue_golomb(&h->gb);
415 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
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);
425 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
426 av_log(h->avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
430 for(i=0; i<sps->poc_cycle_length; i++)
431 sps->offset_for_ref_frame[i]= get_se_golomb(&h->gb);
432 }else if(sps->poc_type != 2){
433 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
437 sps->ref_frame_count= get_ue_golomb_31(&h->gb);
438 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
439 sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
440 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
441 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
444 sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
445 sps->mb_width = get_ue_golomb(&h->gb) + 1;
446 sps->mb_height= get_ue_golomb(&h->gb) + 1;
447 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
448 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->avctx)){
449 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
453 sps->frame_mbs_only_flag= get_bits1(&h->gb);
454 if(!sps->frame_mbs_only_flag)
455 sps->mb_aff= get_bits1(&h->gb);
459 sps->direct_8x8_inference_flag= get_bits1(&h->gb);
461 #ifndef ALLOW_INTERLACE
463 av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
465 sps->crop= get_bits1(&h->gb);
467 int crop_left = get_ue_golomb(&h->gb);
468 int crop_right = get_ue_golomb(&h->gb);
469 int crop_top = get_ue_golomb(&h->gb);
470 int crop_bottom = get_ue_golomb(&h->gb);
471 int width = 16 * sps->mb_width;
472 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
474 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
475 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
476 "values are l:%u r:%u t:%u b:%u\n", crop_left, crop_right,
477 crop_top, crop_bottom);
482 sps->crop_bottom = 0;
484 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
485 int hsub = (sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2) ? 1 : 0;
486 int step_x = 1 << hsub;
487 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
489 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
490 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
491 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
492 av_log(h->avctx, AV_LOG_WARNING, "Reducing left cropping to %d "
493 "chroma samples to preserve alignment.\n",
497 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
498 crop_right > (unsigned)INT_MAX / 4 / step_x ||
499 crop_top > (unsigned)INT_MAX / 4 / step_y ||
500 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
501 (crop_left + crop_right ) * step_x >= width ||
502 (crop_top + crop_bottom) * step_y >= height
504 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);
508 sps->crop_left = crop_left * step_x;
509 sps->crop_right = crop_right * step_x;
510 sps->crop_top = crop_top * step_y;
511 sps->crop_bottom = crop_bottom * step_y;
521 sps->vui_parameters_present_flag= get_bits1(&h->gb);
522 if( sps->vui_parameters_present_flag )
523 if (decode_vui_parameters(h, sps) < 0)
529 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
530 static const char csp[4][5] = { "Gray", "420", "422", "444" };
531 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",
532 sps_id, sps->profile_idc, sps->level_idc,
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,
545 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
550 av_free(h->sps_buffers[sps_id]);
551 h->sps_buffers[sps_id] = sps;
560 build_qp_table(PPS *pps, int t, int index, const int depth)
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] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
568 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
570 const SPS *sps = h->sps_buffers[pps->sps_id];
571 int profile_idc = sps->profile_idc;
573 if ((profile_idc == 66 || profile_idc == 77 ||
574 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
575 av_log(h->avctx, AV_LOG_VERBOSE,
576 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
583 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
584 unsigned int pps_id= get_ue_golomb(&h->gb);
590 if(pps_id >= MAX_PPS_COUNT) {
591 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
592 return AVERROR_INVALIDDATA;
595 pps= av_mallocz(sizeof(PPS));
598 pps->sps_id= get_ue_golomb_31(&h->gb);
599 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
600 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
603 sps = h->sps_buffers[pps->sps_id];
604 qp_bd_offset = 6*(sps->bit_depth_luma-8);
605 if (sps->bit_depth_luma > 14) {
606 av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", sps->bit_depth_luma);
608 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
609 av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", sps->bit_depth_luma);
613 pps->cabac= get_bits1(&h->gb);
614 pps->pic_order_present= get_bits1(&h->gb);
615 pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
616 if(pps->slice_group_count > 1 ){
617 pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
618 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
619 switch(pps->mb_slice_group_map_type){
622 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
623 | run_length[ i ] |1 |ue(v) |
628 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
630 | top_left_mb[ i ] |1 |ue(v) |
631 | bottom_right_mb[ i ] |1 |ue(v) |
639 | slice_group_change_direction_flag |1 |u(1) |
640 | slice_group_change_rate_minus1 |1 |ue(v) |
645 | slice_group_id_cnt_minus1 |1 |ue(v) |
646 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
648 | slice_group_id[ i ] |1 |u(v) |
653 pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
654 pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
655 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
656 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
660 pps->weighted_pred= get_bits1(&h->gb);
661 pps->weighted_bipred_idc= get_bits(&h->gb, 2);
662 pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
663 pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
664 pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
665 pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
666 pps->constrained_intra_pred= get_bits1(&h->gb);
667 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
669 pps->transform_8x8_mode= 0;
670 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
671 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
672 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
674 bits_left = bit_length - get_bits_count(&h->gb);
675 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
676 pps->transform_8x8_mode= get_bits1(&h->gb);
677 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
678 pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
680 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
683 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
684 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
685 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
686 pps->chroma_qp_diff= 1;
688 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
689 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",
691 pps->cabac ? "CABAC" : "CAVLC",
692 pps->slice_group_count,
693 pps->ref_count[0], pps->ref_count[1],
694 pps->weighted_pred ? "weighted" : "",
695 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
696 pps->deblocking_filter_parameters_present ? "LPAR" : "",
697 pps->constrained_intra_pred ? "CONSTR" : "",
698 pps->redundant_pic_cnt_present ? "REDU" : "",
699 pps->transform_8x8_mode ? "8x8DCT" : ""
703 av_free(h->pps_buffers[pps_id]);
704 h->pps_buffers[pps_id]= pps;