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_long(&s->gb); /* bit_rate_value_minus1 */
134 get_ue_golomb_long(&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 (get_bits_left(&s->gb) < 0) {
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 (get_bits_left(&s->gb) < 0) {
241 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
242 return AVERROR_INVALIDDATA;
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 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
338 } else if(sps->chroma_format_idc == 3) {
339 sps->residual_color_transform_flag = get_bits1(&s->gb);
341 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
342 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
343 sps->transform_bypass = get_bits1(&s->gb);
344 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
346 sps->chroma_format_idc= 1;
347 sps->bit_depth_luma = 8;
348 sps->bit_depth_chroma = 8;
351 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
352 sps->poc_type= get_ue_golomb_31(&s->gb);
354 if(sps->poc_type == 0){ //FIXME #define
355 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
356 } else if(sps->poc_type == 1){//FIXME #define
357 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
358 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
359 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
360 sps->poc_cycle_length = get_ue_golomb(&s->gb);
362 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
363 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
367 for(i=0; i<sps->poc_cycle_length; i++)
368 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
369 }else if(sps->poc_type != 2){
370 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
374 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
375 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
376 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
379 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
380 sps->mb_width = get_ue_golomb(&s->gb) + 1;
381 sps->mb_height= get_ue_golomb(&s->gb) + 1;
382 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
383 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
384 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
388 sps->frame_mbs_only_flag= get_bits1(&s->gb);
389 if(!sps->frame_mbs_only_flag)
390 sps->mb_aff= get_bits1(&s->gb);
394 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
395 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
396 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
400 #ifndef ALLOW_INTERLACE
402 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
404 sps->crop= get_bits1(&s->gb);
406 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
407 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
408 sps->crop_left = get_ue_golomb(&s->gb);
409 sps->crop_right = get_ue_golomb(&s->gb);
410 sps->crop_top = get_ue_golomb(&s->gb);
411 sps->crop_bottom= get_ue_golomb(&s->gb);
412 if(sps->crop_left || sps->crop_top){
413 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
415 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
416 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
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 static const char csp[4][5] = { "Gray", "420", "422", "444" };
435 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",
436 sps_id, sps->profile_idc, sps->level_idc,
438 sps->ref_frame_count,
439 sps->mb_width, sps->mb_height,
440 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
441 sps->direct_8x8_inference_flag ? "8B8" : "",
442 sps->crop_left, sps->crop_right,
443 sps->crop_top, sps->crop_bottom,
444 sps->vui_parameters_present_flag ? "VUI" : "",
445 csp[sps->chroma_format_idc],
446 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
447 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);
476 if(pps_id >= MAX_PPS_COUNT) {
477 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
479 } else if (h->sps.bit_depth_luma > 10) {
480 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
481 return AVERROR_PATCHWELCOME;
484 pps= av_mallocz(sizeof(PPS));
487 pps->sps_id= get_ue_golomb_31(&s->gb);
488 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
489 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
493 pps->cabac= get_bits1(&s->gb);
494 pps->pic_order_present= get_bits1(&s->gb);
495 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
496 if(pps->slice_group_count > 1 ){
497 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
498 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
499 switch(pps->mb_slice_group_map_type){
502 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
503 | run_length[ i ] |1 |ue(v) |
508 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
510 | top_left_mb[ i ] |1 |ue(v) |
511 | bottom_right_mb[ i ] |1 |ue(v) |
519 | slice_group_change_direction_flag |1 |u(1) |
520 | slice_group_change_rate_minus1 |1 |ue(v) |
525 | slice_group_id_cnt_minus1 |1 |ue(v) |
526 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
528 | slice_group_id[ i ] |1 |u(v) |
533 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
534 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
535 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
536 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
540 pps->weighted_pred= get_bits1(&s->gb);
541 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
542 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
543 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
544 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
545 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
546 pps->constrained_intra_pred= get_bits1(&s->gb);
547 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
549 pps->transform_8x8_mode= 0;
550 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
551 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
552 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
554 bits_left = bit_length - get_bits_count(&s->gb);
555 if (bits_left && (bits_left > 8 ||
556 show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
557 pps->transform_8x8_mode= get_bits1(&s->gb);
558 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
559 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
561 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
564 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
565 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
566 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
567 pps->chroma_qp_diff= 1;
569 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
570 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",
572 pps->cabac ? "CABAC" : "CAVLC",
573 pps->slice_group_count,
574 pps->ref_count[0], pps->ref_count[1],
575 pps->weighted_pred ? "weighted" : "",
576 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
577 pps->deblocking_filter_parameters_present ? "LPAR" : "",
578 pps->constrained_intra_pred ? "CONSTR" : "",
579 pps->redundant_pic_cnt_present ? "REDU" : "",
580 pps->transform_8x8_mode ? "8x8DCT" : ""
584 av_free(h->pps_buffers[pps_id]);
585 h->pps_buffers[pps_id]= pps;