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"
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_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
400 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
401 sps->crop_left = get_ue_golomb(&s->gb);
402 sps->crop_right = get_ue_golomb(&s->gb);
403 sps->crop_top = get_ue_golomb(&s->gb);
404 sps->crop_bottom= get_ue_golomb(&s->gb);
405 if(sps->crop_left || sps->crop_top){
406 av_log(h->s.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);
408 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
409 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, cropping disabled (right: %d, bottom: %d)\n", sps->crop_right, sps->crop_bottom);
410 /* It is very unlikely that partial cropping will make anybody happy.
411 * Not cropping at all fixes for example playback of Sisvel 3D streams
412 * in applications supporting Sisvel 3D. */
425 sps->vui_parameters_present_flag= get_bits1(&s->gb);
426 if( sps->vui_parameters_present_flag )
427 if (decode_vui_parameters(h, sps) < 0)
433 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
434 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 b%d\n",
435 sps_id, sps->profile_idc, sps->level_idc,
437 sps->ref_frame_count,
438 sps->mb_width, sps->mb_height,
439 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
440 sps->direct_8x8_inference_flag ? "8B8" : "",
441 sps->crop_left, sps->crop_right,
442 sps->crop_top, sps->crop_bottom,
443 sps->vui_parameters_present_flag ? "VUI" : "",
444 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
445 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
446 sps->timing_info_present_flag ? sps->time_scale : 0,
451 av_free(h->sps_buffers[sps_id]);
452 h->sps_buffers[sps_id]= sps;
461 build_qp_table(PPS *pps, int t, int index, const int depth)
464 const int max_qp = 51 + 6*(depth-8);
465 for(i = 0; i < max_qp+1; i++)
466 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
469 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
470 MpegEncContext * const s = &h->s;
471 unsigned int pps_id= get_ue_golomb(&s->gb);
473 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
475 if(pps_id >= MAX_PPS_COUNT) {
476 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
480 pps= av_mallocz(sizeof(PPS));
483 pps->sps_id= get_ue_golomb_31(&s->gb);
484 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
485 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
489 pps->cabac= get_bits1(&s->gb);
490 pps->pic_order_present= get_bits1(&s->gb);
491 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
492 if(pps->slice_group_count > 1 ){
493 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
494 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
495 switch(pps->mb_slice_group_map_type){
498 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
499 | run_length[ i ] |1 |ue(v) |
504 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
506 | top_left_mb[ i ] |1 |ue(v) |
507 | bottom_right_mb[ i ] |1 |ue(v) |
515 | slice_group_change_direction_flag |1 |u(1) |
516 | slice_group_change_rate_minus1 |1 |ue(v) |
521 | slice_group_id_cnt_minus1 |1 |ue(v) |
522 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
524 | slice_group_id[ i ] |1 |u(v) |
529 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
530 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
531 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
532 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
536 pps->weighted_pred= get_bits1(&s->gb);
537 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
538 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
539 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
540 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
541 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
542 pps->constrained_intra_pred= get_bits1(&s->gb);
543 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
545 pps->transform_8x8_mode= 0;
546 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
547 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
548 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
550 if(get_bits_count(&s->gb) < bit_length){
551 pps->transform_8x8_mode= get_bits1(&s->gb);
552 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
553 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
555 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
558 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
559 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
560 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
561 pps->chroma_qp_diff= 1;
563 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
564 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",
566 pps->cabac ? "CABAC" : "CAVLC",
567 pps->slice_group_count,
568 pps->ref_count[0], pps->ref_count[1],
569 pps->weighted_pred ? "weighted" : "",
570 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
571 pps->deblocking_filter_parameters_present ? "LPAR" : "",
572 pps->constrained_intra_pred ? "CONSTR" : "",
573 pps->redundant_pic_cnt_present ? "REDU" : "",
574 pps->transform_8x8_mode ? "8x8DCT" : ""
578 av_free(h->pps_buffers[pps_id]);
579 h->pps_buffers[pps_id]= pps;