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 Libav.
7 * Libav 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 * Libav 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 Libav; 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"
33 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
40 static const AVRational pixel_aspect[17]={
60 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
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)
73 const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM+1] = {
75 CHROMA_QP_TABLE_END(8)
79 CHROMA_QP_TABLE_END(9)
84 CHROMA_QP_TABLE_END(10)
88 static const uint8_t default_scaling4[2][16]={
100 static const uint8_t default_scaling8[2][64]={
101 { 6,10,13,16,18,23,25,27,
102 10,11,16,18,23,25,27,29,
103 13,16,18,23,25,27,29,31,
104 16,18,23,25,27,29,31,33,
105 18,23,25,27,29,31,33,36,
106 23,25,27,29,31,33,36,38,
107 25,27,29,31,33,36,38,40,
108 27,29,31,33,36,38,40,42
110 9,13,15,17,19,21,22,24,
111 13,13,17,19,21,22,24,25,
112 15,17,19,21,22,24,25,27,
113 17,19,21,22,24,25,27,28,
114 19,21,22,24,25,27,28,30,
115 21,22,24,25,27,28,30,32,
116 22,24,25,27,28,30,32,33,
117 24,25,27,28,30,32,33,35
120 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
121 MpegEncContext * const s = &h->s;
123 cpb_count = get_ue_golomb_31(&s->gb) + 1;
126 av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
130 get_bits(&s->gb, 4); /* bit_rate_scale */
131 get_bits(&s->gb, 4); /* cpb_size_scale */
132 for(i=0; i<cpb_count; i++){
133 get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
134 get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
135 get_bits1(&s->gb); /* cbr_flag */
137 sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
138 sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
139 sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
140 sps->time_offset_length = get_bits(&s->gb, 5);
141 sps->cpb_cnt = cpb_count;
145 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
146 MpegEncContext * const s = &h->s;
147 int aspect_ratio_info_present_flag;
148 unsigned int aspect_ratio_idc;
150 aspect_ratio_info_present_flag= get_bits1(&s->gb);
152 if( aspect_ratio_info_present_flag ) {
153 aspect_ratio_idc= get_bits(&s->gb, 8);
154 if( aspect_ratio_idc == EXTENDED_SAR ) {
155 sps->sar.num= get_bits(&s->gb, 16);
156 sps->sar.den= get_bits(&s->gb, 16);
157 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
158 sps->sar= pixel_aspect[aspect_ratio_idc];
160 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
167 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
169 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
170 get_bits1(&s->gb); /* overscan_appropriate_flag */
173 sps->video_signal_type_present_flag = get_bits1(&s->gb);
174 if(sps->video_signal_type_present_flag){
175 get_bits(&s->gb, 3); /* video_format */
176 sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
178 sps->colour_description_present_flag = get_bits1(&s->gb);
179 if(sps->colour_description_present_flag){
180 sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
181 sps->color_trc = get_bits(&s->gb, 8); /* transfer_characteristics */
182 sps->colorspace = get_bits(&s->gb, 8); /* matrix_coefficients */
183 if (sps->color_primaries >= AVCOL_PRI_NB)
184 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
185 if (sps->color_trc >= AVCOL_TRC_NB)
186 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
187 if (sps->colorspace >= AVCOL_SPC_NB)
188 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
192 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
193 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1; /* chroma_sample_location_type_top_field */
194 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
197 sps->timing_info_present_flag = get_bits1(&s->gb);
198 if(sps->timing_info_present_flag){
199 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
200 sps->time_scale = get_bits_long(&s->gb, 32);
201 if(!sps->num_units_in_tick || !sps->time_scale){
202 av_log(h->s.avctx, AV_LOG_ERROR, "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n", sps->time_scale, sps->num_units_in_tick);
205 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
208 sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
209 if(sps->nal_hrd_parameters_present_flag)
210 if(decode_hrd_parameters(h, sps) < 0)
212 sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
213 if(sps->vcl_hrd_parameters_present_flag)
214 if(decode_hrd_parameters(h, sps) < 0)
216 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
217 get_bits1(&s->gb); /* low_delay_hrd_flag */
218 sps->pic_struct_present_flag = get_bits1(&s->gb);
220 sps->bitstream_restriction_flag = get_bits1(&s->gb);
221 if(sps->bitstream_restriction_flag){
222 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
223 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
224 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
225 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
226 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
227 sps->num_reorder_frames= get_ue_golomb(&s->gb);
228 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
230 if(s->gb.size_in_bits < get_bits_count(&s->gb)){
231 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
232 sps->num_reorder_frames=0;
233 sps->bitstream_restriction_flag= 0;
236 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
237 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
245 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
246 const uint8_t *jvt_list, const uint8_t *fallback_list){
247 MpegEncContext * const s = &h->s;
248 int i, last = 8, next = 8;
249 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
250 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
251 memcpy(factors, fallback_list, size*sizeof(uint8_t));
255 next = (last + get_se_golomb(&s->gb)) & 0xff;
256 if(!i && !next){ /* matrix not written, we use the preset one */
257 memcpy(factors, jvt_list, size*sizeof(uint8_t));
260 last = factors[scan[i]] = next ? next : last;
264 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
265 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
266 MpegEncContext * const s = &h->s;
267 int fallback_sps = !is_sps && sps->scaling_matrix_present;
268 const uint8_t *fallback[4] = {
269 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
270 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
271 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
272 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
274 if(get_bits1(&s->gb)){
275 sps->scaling_matrix_present |= is_sps;
276 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
277 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
278 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
279 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
280 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
281 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
282 if(is_sps || pps->transform_8x8_mode){
283 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
284 if(sps->chroma_format_idc == 3){
285 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
286 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
288 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
289 if(sps->chroma_format_idc == 3){
290 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
291 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
297 int ff_h264_decode_seq_parameter_set(H264Context *h){
298 MpegEncContext * const s = &h->s;
299 int profile_idc, level_idc, constraint_set_flags = 0;
304 profile_idc= get_bits(&s->gb, 8);
305 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
306 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
307 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
308 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
309 get_bits(&s->gb, 4); // reserved
310 level_idc= get_bits(&s->gb, 8);
311 sps_id= get_ue_golomb_31(&s->gb);
313 if(sps_id >= MAX_SPS_COUNT) {
314 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
317 sps= av_mallocz(sizeof(SPS));
321 sps->time_offset_length = 24;
322 sps->profile_idc= profile_idc;
323 sps->constraint_set_flags = constraint_set_flags;
324 sps->level_idc= level_idc;
326 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
327 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
328 sps->scaling_matrix_present = 0;
330 if(sps->profile_idc >= 100){ //high profile
331 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
332 if(sps->chroma_format_idc == 3)
333 sps->residual_color_transform_flag = get_bits1(&s->gb);
334 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
335 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
336 sps->transform_bypass = get_bits1(&s->gb);
337 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
339 sps->chroma_format_idc= 1;
340 sps->bit_depth_luma = 8;
341 sps->bit_depth_chroma = 8;
344 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
345 sps->poc_type= get_ue_golomb_31(&s->gb);
347 if(sps->poc_type == 0){ //FIXME #define
348 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
349 } else if(sps->poc_type == 1){//FIXME #define
350 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
351 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
352 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
353 sps->poc_cycle_length = get_ue_golomb(&s->gb);
355 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
356 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
360 for(i=0; i<sps->poc_cycle_length; i++)
361 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
362 }else if(sps->poc_type != 2){
363 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
367 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
368 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
369 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
372 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
373 sps->mb_width = get_ue_golomb(&s->gb) + 1;
374 sps->mb_height= get_ue_golomb(&s->gb) + 1;
375 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
376 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
377 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
381 sps->frame_mbs_only_flag= get_bits1(&s->gb);
382 if(!sps->frame_mbs_only_flag)
383 sps->mb_aff= get_bits1(&s->gb);
387 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
388 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
389 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
393 #ifndef ALLOW_INTERLACE
395 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
397 sps->crop= get_bits1(&s->gb);
399 int crop_limit = sps->chroma_format_idc == 3 ? 16 : 8;
400 sps->crop_left = get_ue_golomb(&s->gb);
401 sps->crop_right = get_ue_golomb(&s->gb);
402 sps->crop_top = get_ue_golomb(&s->gb);
403 sps->crop_bottom= get_ue_golomb(&s->gb);
404 if(sps->crop_left || sps->crop_top){
405 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
407 if(sps->crop_right >= crop_limit || sps->crop_bottom >= crop_limit){
408 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
417 sps->vui_parameters_present_flag= get_bits1(&s->gb);
418 if( sps->vui_parameters_present_flag )
419 if (decode_vui_parameters(h, sps) < 0)
425 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
426 av_log(h->s.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\n",
427 sps_id, sps->profile_idc, sps->level_idc,
429 sps->ref_frame_count,
430 sps->mb_width, sps->mb_height,
431 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
432 sps->direct_8x8_inference_flag ? "8B8" : "",
433 sps->crop_left, sps->crop_right,
434 sps->crop_top, sps->crop_bottom,
435 sps->vui_parameters_present_flag ? "VUI" : "",
436 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
437 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
438 sps->timing_info_present_flag ? sps->time_scale : 0
442 av_free(h->sps_buffers[sps_id]);
443 h->sps_buffers[sps_id]= sps;
452 build_qp_table(PPS *pps, int t, int index, const int depth)
455 const int max_qp = 51 + 6*(depth-8);
456 for(i = 0; i < max_qp+1; i++)
457 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
460 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
461 MpegEncContext * const s = &h->s;
462 unsigned int pps_id= get_ue_golomb(&s->gb);
464 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
466 if(pps_id >= MAX_PPS_COUNT) {
467 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
471 pps= av_mallocz(sizeof(PPS));
474 pps->sps_id= get_ue_golomb_31(&s->gb);
475 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
476 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
480 pps->cabac= get_bits1(&s->gb);
481 pps->pic_order_present= get_bits1(&s->gb);
482 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
483 if(pps->slice_group_count > 1 ){
484 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
485 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
486 switch(pps->mb_slice_group_map_type){
489 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
490 | run_length[ i ] |1 |ue(v) |
495 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
497 | top_left_mb[ i ] |1 |ue(v) |
498 | bottom_right_mb[ i ] |1 |ue(v) |
506 | slice_group_change_direction_flag |1 |u(1) |
507 | slice_group_change_rate_minus1 |1 |ue(v) |
512 | slice_group_id_cnt_minus1 |1 |ue(v) |
513 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
515 | slice_group_id[ i ] |1 |u(v) |
520 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
521 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
522 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
523 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
527 pps->weighted_pred= get_bits1(&s->gb);
528 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
529 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
530 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
531 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
532 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
533 pps->constrained_intra_pred= get_bits1(&s->gb);
534 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
536 pps->transform_8x8_mode= 0;
537 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
538 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
539 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
541 if(get_bits_count(&s->gb) < bit_length){
542 pps->transform_8x8_mode= get_bits1(&s->gb);
543 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
544 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
546 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
549 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
550 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
551 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
552 pps->chroma_qp_diff= 1;
554 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
555 av_log(h->s.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",
557 pps->cabac ? "CABAC" : "CAVLC",
558 pps->slice_group_count,
559 pps->ref_count[0], pps->ref_count[1],
560 pps->weighted_pred ? "weighted" : "",
561 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
562 pps->deblocking_filter_parameters_present ? "LPAR" : "",
563 pps->constrained_intra_pred ? "CONSTR" : "",
564 pps->redundant_pic_cnt_present ? "REDU" : "",
565 pps->transform_8x8_mode ? "8x8DCT" : ""
569 av_free(h->pps_buffers[pps_id]);
570 h->pps_buffers[pps_id]= pps;