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 sps->timing_info_present_flag = get_bits1(&h->gb);
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);
235 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
238 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
239 if(sps->nal_hrd_parameters_present_flag)
240 if(decode_hrd_parameters(h, sps) < 0)
242 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
243 if(sps->vcl_hrd_parameters_present_flag)
244 if(decode_hrd_parameters(h, sps) < 0)
246 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
247 get_bits1(&h->gb); /* low_delay_hrd_flag */
248 sps->pic_struct_present_flag = get_bits1(&h->gb);
249 if(!get_bits_left(&h->gb))
251 sps->bitstream_restriction_flag = get_bits1(&h->gb);
252 if(sps->bitstream_restriction_flag){
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 */
258 sps->num_reorder_frames= get_ue_golomb(&h->gb);
259 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
261 if (get_bits_left(&h->gb) < 0) {
262 sps->num_reorder_frames=0;
263 sps->bitstream_restriction_flag= 0;
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);
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;
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));
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));
294 last = factors[scan[i]] = next ? next : last;
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]
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
328 int ff_h264_decode_seq_parameter_set(H264Context *h){
329 int profile_idc, level_idc, constraint_set_flags = 0;
331 int i, log2_max_frame_num_minus4;
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);
345 if(sps_id >= MAX_SPS_COUNT) {
346 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
349 sps= av_mallocz(sizeof(SPS));
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;
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
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) {
369 sps->chroma_format_idc= get_ue_golomb_31(&h->gb);
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);
373 } else if(sps->chroma_format_idc == 3) {
374 sps->residual_color_transform_flag = get_bits1(&h->gb);
375 if(sps->residual_color_transform_flag) {
376 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
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 > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
383 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
384 sps->bit_depth_luma, sps->bit_depth_chroma);
387 sps->transform_bypass = get_bits1(&h->gb);
388 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
390 sps->chroma_format_idc= 1;
391 sps->bit_depth_luma = 8;
392 sps->bit_depth_chroma = 8;
395 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
396 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
397 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
398 av_log(h->avctx, AV_LOG_ERROR,
399 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
400 log2_max_frame_num_minus4);
403 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
405 sps->poc_type= get_ue_golomb_31(&h->gb);
407 if(sps->poc_type == 0){ //FIXME #define
408 unsigned t = get_ue_golomb(&h->gb);
410 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
413 sps->log2_max_poc_lsb= t + 4;
414 } else if(sps->poc_type == 1){//FIXME #define
415 sps->delta_pic_order_always_zero_flag= get_bits1(&h->gb);
416 sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
417 sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
418 sps->poc_cycle_length = get_ue_golomb(&h->gb);
420 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
421 av_log(h->avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
425 for(i=0; i<sps->poc_cycle_length; i++)
426 sps->offset_for_ref_frame[i]= get_se_golomb(&h->gb);
427 }else if(sps->poc_type != 2){
428 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
432 sps->ref_frame_count= get_ue_golomb_31(&h->gb);
433 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
434 sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
435 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
436 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
439 sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
440 sps->mb_width = get_ue_golomb(&h->gb) + 1;
441 sps->mb_height= get_ue_golomb(&h->gb) + 1;
442 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
443 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->avctx)){
444 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
448 sps->frame_mbs_only_flag= get_bits1(&h->gb);
449 if(!sps->frame_mbs_only_flag)
450 sps->mb_aff= get_bits1(&h->gb);
454 sps->direct_8x8_inference_flag= get_bits1(&h->gb);
456 #ifndef ALLOW_INTERLACE
458 av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
460 sps->crop= get_bits1(&h->gb);
462 int crop_left = get_ue_golomb(&h->gb);
463 int crop_right = get_ue_golomb(&h->gb);
464 int crop_top = get_ue_golomb(&h->gb);
465 int crop_bottom = get_ue_golomb(&h->gb);
467 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
468 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
469 "values are l:%u r:%u t:%u b:%u\n", crop_left, crop_right,
470 crop_top, crop_bottom);
475 sps->crop_bottom = 0;
477 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
478 int hsub = (sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2) ? 1 : 0;
479 int step_x = 1 << hsub;
480 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
482 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
483 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
484 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
485 av_log(h->avctx, AV_LOG_WARNING, "Reducing left cropping to %d "
486 "chroma samples to preserve alignment.\n",
490 sps->crop_left = crop_left * step_x;
491 sps->crop_right = crop_right * step_x;
492 sps->crop_top = crop_top * step_y;
493 sps->crop_bottom = crop_bottom * step_y;
503 sps->vui_parameters_present_flag= get_bits1(&h->gb);
504 if( sps->vui_parameters_present_flag )
505 if (decode_vui_parameters(h, sps) < 0)
511 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
512 static const char csp[4][5] = { "Gray", "420", "422", "444" };
513 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",
514 sps_id, sps->profile_idc, sps->level_idc,
516 sps->ref_frame_count,
517 sps->mb_width, sps->mb_height,
518 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
519 sps->direct_8x8_inference_flag ? "8B8" : "",
520 sps->crop_left, sps->crop_right,
521 sps->crop_top, sps->crop_bottom,
522 sps->vui_parameters_present_flag ? "VUI" : "",
523 csp[sps->chroma_format_idc],
524 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
525 sps->timing_info_present_flag ? sps->time_scale : 0,
527 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
532 av_free(h->sps_buffers[sps_id]);
533 h->sps_buffers[sps_id] = sps;
535 h->current_sps_id = sps_id;
544 build_qp_table(PPS *pps, int t, int index, const int depth)
547 const int max_qp = 51 + 6*(depth-8);
548 for(i = 0; i < max_qp+1; i++)
549 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
552 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
554 const SPS *sps = h->sps_buffers[pps->sps_id];
555 int profile_idc = sps->profile_idc;
557 if ((profile_idc == 66 || profile_idc == 77 ||
558 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
559 av_log(h->avctx, AV_LOG_VERBOSE,
560 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
567 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
568 unsigned int pps_id= get_ue_golomb(&h->gb);
570 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
573 if(pps_id >= MAX_PPS_COUNT) {
574 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
576 } else if (h->sps.bit_depth_luma > 14) {
577 av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
578 return AVERROR_INVALIDDATA;
579 } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
580 av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
581 return AVERROR_PATCHWELCOME;
584 pps= av_mallocz(sizeof(PPS));
587 pps->sps_id= get_ue_golomb_31(&h->gb);
588 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
589 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
593 pps->cabac= get_bits1(&h->gb);
594 pps->pic_order_present= get_bits1(&h->gb);
595 pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
596 if(pps->slice_group_count > 1 ){
597 pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
598 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
599 switch(pps->mb_slice_group_map_type){
602 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
603 | run_length[ i ] |1 |ue(v) |
608 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
610 | top_left_mb[ i ] |1 |ue(v) |
611 | bottom_right_mb[ i ] |1 |ue(v) |
619 | slice_group_change_direction_flag |1 |u(1) |
620 | slice_group_change_rate_minus1 |1 |ue(v) |
625 | slice_group_id_cnt_minus1 |1 |ue(v) |
626 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
628 | slice_group_id[ i ] |1 |u(v) |
633 pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
634 pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
635 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
636 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
640 pps->weighted_pred= get_bits1(&h->gb);
641 pps->weighted_bipred_idc= get_bits(&h->gb, 2);
642 pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
643 pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
644 pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
645 pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
646 pps->constrained_intra_pred= get_bits1(&h->gb);
647 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
649 pps->transform_8x8_mode= 0;
650 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
651 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
652 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
654 bits_left = bit_length - get_bits_count(&h->gb);
655 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
656 pps->transform_8x8_mode= get_bits1(&h->gb);
657 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
658 pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
660 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
663 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
664 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
665 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
666 pps->chroma_qp_diff= 1;
668 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
669 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->cabac ? "CABAC" : "CAVLC",
672 pps->slice_group_count,
673 pps->ref_count[0], pps->ref_count[1],
674 pps->weighted_pred ? "weighted" : "",
675 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
676 pps->deblocking_filter_parameters_present ? "LPAR" : "",
677 pps->constrained_intra_pred ? "CONSTR" : "",
678 pps->redundant_pic_cnt_present ? "REDU" : "",
679 pps->transform_8x8_mode ? "8x8DCT" : ""
683 av_free(h->pps_buffers[pps_id]);
684 h->pps_buffers[pps_id]= pps;