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 sps->num_reorder_frames=0;
232 sps->bitstream_restriction_flag= 0;
235 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
236 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
240 if(s->gb.size_in_bits < get_bits_count(&s->gb)){
241 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
248 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
249 const uint8_t *jvt_list, const uint8_t *fallback_list){
250 MpegEncContext * const s = &h->s;
251 int i, last = 8, next = 8;
252 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
253 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
254 memcpy(factors, fallback_list, size*sizeof(uint8_t));
258 next = (last + get_se_golomb(&s->gb)) & 0xff;
259 if(!i && !next){ /* matrix not written, we use the preset one */
260 memcpy(factors, jvt_list, size*sizeof(uint8_t));
263 last = factors[scan[i]] = next ? next : last;
267 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
268 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
269 MpegEncContext * const s = &h->s;
270 int fallback_sps = !is_sps && sps->scaling_matrix_present;
271 const uint8_t *fallback[4] = {
272 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
273 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
274 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
275 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
277 if(get_bits1(&s->gb)){
278 sps->scaling_matrix_present |= is_sps;
279 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
280 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
281 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
282 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
283 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
284 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
285 if(is_sps || pps->transform_8x8_mode){
286 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
287 if(sps->chroma_format_idc == 3){
288 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
289 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
291 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
292 if(sps->chroma_format_idc == 3){
293 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
294 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
300 int ff_h264_decode_seq_parameter_set(H264Context *h){
301 MpegEncContext * const s = &h->s;
302 int profile_idc, level_idc, constraint_set_flags = 0;
307 profile_idc= get_bits(&s->gb, 8);
308 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
309 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
310 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
311 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
312 get_bits(&s->gb, 4); // reserved
313 level_idc= get_bits(&s->gb, 8);
314 sps_id= get_ue_golomb_31(&s->gb);
316 if(sps_id >= MAX_SPS_COUNT) {
317 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
320 sps= av_mallocz(sizeof(SPS));
324 sps->time_offset_length = 24;
325 sps->profile_idc= profile_idc;
326 sps->constraint_set_flags = constraint_set_flags;
327 sps->level_idc= level_idc;
329 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
330 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
331 sps->scaling_matrix_present = 0;
333 if(sps->profile_idc >= 100){ //high profile
334 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
335 if(sps->chroma_format_idc == 3)
336 sps->residual_color_transform_flag = get_bits1(&s->gb);
337 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
338 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
339 sps->transform_bypass = get_bits1(&s->gb);
340 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
342 sps->chroma_format_idc= 1;
343 sps->bit_depth_luma = 8;
344 sps->bit_depth_chroma = 8;
347 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
348 sps->poc_type= get_ue_golomb_31(&s->gb);
350 if(sps->poc_type == 0){ //FIXME #define
351 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
352 } else if(sps->poc_type == 1){//FIXME #define
353 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
354 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
355 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
356 sps->poc_cycle_length = get_ue_golomb(&s->gb);
358 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
359 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
363 for(i=0; i<sps->poc_cycle_length; i++)
364 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
365 }else if(sps->poc_type != 2){
366 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
370 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
371 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
372 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
375 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
376 sps->mb_width = get_ue_golomb(&s->gb) + 1;
377 sps->mb_height= get_ue_golomb(&s->gb) + 1;
378 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
379 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
380 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
384 sps->frame_mbs_only_flag= get_bits1(&s->gb);
385 if(!sps->frame_mbs_only_flag)
386 sps->mb_aff= get_bits1(&s->gb);
390 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
391 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
392 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
396 #ifndef ALLOW_INTERLACE
398 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
400 sps->crop= get_bits1(&s->gb);
402 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
403 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
404 sps->crop_left = get_ue_golomb(&s->gb);
405 sps->crop_right = get_ue_golomb(&s->gb);
406 sps->crop_top = get_ue_golomb(&s->gb);
407 sps->crop_bottom= get_ue_golomb(&s->gb);
408 if(sps->crop_left || sps->crop_top){
409 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);
411 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
412 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);
413 /* It is very unlikely that partial cropping will make anybody happy.
414 * Not cropping at all fixes for example playback of Sisvel 3D streams
415 * in applications supporting Sisvel 3D. */
428 sps->vui_parameters_present_flag= get_bits1(&s->gb);
429 if( sps->vui_parameters_present_flag )
430 if (decode_vui_parameters(h, sps) < 0)
436 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
437 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",
438 sps_id, sps->profile_idc, sps->level_idc,
440 sps->ref_frame_count,
441 sps->mb_width, sps->mb_height,
442 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
443 sps->direct_8x8_inference_flag ? "8B8" : "",
444 sps->crop_left, sps->crop_right,
445 sps->crop_top, sps->crop_bottom,
446 sps->vui_parameters_present_flag ? "VUI" : "",
447 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
448 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
449 sps->timing_info_present_flag ? sps->time_scale : 0,
454 av_free(h->sps_buffers[sps_id]);
455 h->sps_buffers[sps_id]= sps;
464 build_qp_table(PPS *pps, int t, int index, const int depth)
467 const int max_qp = 51 + 6*(depth-8);
468 for(i = 0; i < max_qp+1; i++)
469 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
472 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
473 MpegEncContext * const s = &h->s;
474 unsigned int pps_id= get_ue_golomb(&s->gb);
476 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
478 if(pps_id >= MAX_PPS_COUNT) {
479 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
483 pps= av_mallocz(sizeof(PPS));
486 pps->sps_id= get_ue_golomb_31(&s->gb);
487 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
488 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
492 pps->cabac= get_bits1(&s->gb);
493 pps->pic_order_present= get_bits1(&s->gb);
494 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
495 if(pps->slice_group_count > 1 ){
496 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
497 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
498 switch(pps->mb_slice_group_map_type){
501 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
502 | run_length[ i ] |1 |ue(v) |
507 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
509 | top_left_mb[ i ] |1 |ue(v) |
510 | bottom_right_mb[ i ] |1 |ue(v) |
518 | slice_group_change_direction_flag |1 |u(1) |
519 | slice_group_change_rate_minus1 |1 |ue(v) |
524 | slice_group_id_cnt_minus1 |1 |ue(v) |
525 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
527 | slice_group_id[ i ] |1 |u(v) |
532 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
533 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
534 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
535 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
539 pps->weighted_pred= get_bits1(&s->gb);
540 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
541 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
542 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
543 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
544 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
545 pps->constrained_intra_pred= get_bits1(&s->gb);
546 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
548 pps->transform_8x8_mode= 0;
549 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
550 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
551 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
553 if(get_bits_count(&s->gb) < bit_length){
554 pps->transform_8x8_mode= get_bits1(&s->gb);
555 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
556 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
558 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
561 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
562 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
563 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
564 pps->chroma_qp_diff= 1;
566 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
567 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",
569 pps->cabac ? "CABAC" : "CAVLC",
570 pps->slice_group_count,
571 pps->ref_count[0], pps->ref_count[1],
572 pps->weighted_pred ? "weighted" : "",
573 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
574 pps->deblocking_filter_parameters_present ? "LPAR" : "",
575 pps->constrained_intra_pred ? "CONSTR" : "",
576 pps->redundant_pic_cnt_present ? "REDU" : "",
577 pps->transform_8x8_mode ? "8x8DCT" : ""
581 av_free(h->pps_buffers[pps_id]);
582 h->pps_buffers[pps_id]= pps;