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[5][QP_MAX_NUM+1] = {
75 CHROMA_QP_TABLE_END(8)
79 CHROMA_QP_TABLE_END(9)
84 CHROMA_QP_TABLE_END(10)
90 CHROMA_QP_TABLE_END(11)
97 CHROMA_QP_TABLE_END(12)
101 static const uint8_t default_scaling4[2][16]={
113 static const uint8_t default_scaling8[2][64]={
114 { 6,10,13,16,18,23,25,27,
115 10,11,16,18,23,25,27,29,
116 13,16,18,23,25,27,29,31,
117 16,18,23,25,27,29,31,33,
118 18,23,25,27,29,31,33,36,
119 23,25,27,29,31,33,36,38,
120 25,27,29,31,33,36,38,40,
121 27,29,31,33,36,38,40,42
123 9,13,15,17,19,21,22,24,
124 13,13,17,19,21,22,24,25,
125 15,17,19,21,22,24,25,27,
126 17,19,21,22,24,25,27,28,
127 19,21,22,24,25,27,28,30,
128 21,22,24,25,27,28,30,32,
129 22,24,25,27,28,30,32,33,
130 24,25,27,28,30,32,33,35
133 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
134 MpegEncContext * const s = &h->s;
136 cpb_count = get_ue_golomb_31(&s->gb) + 1;
139 av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
143 get_bits(&s->gb, 4); /* bit_rate_scale */
144 get_bits(&s->gb, 4); /* cpb_size_scale */
145 for(i=0; i<cpb_count; i++){
146 get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
147 get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
148 get_bits1(&s->gb); /* cbr_flag */
150 sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
151 sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
152 sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
153 sps->time_offset_length = get_bits(&s->gb, 5);
154 sps->cpb_cnt = cpb_count;
158 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
159 MpegEncContext * const s = &h->s;
160 int aspect_ratio_info_present_flag;
161 unsigned int aspect_ratio_idc;
163 aspect_ratio_info_present_flag= get_bits1(&s->gb);
165 if( aspect_ratio_info_present_flag ) {
166 aspect_ratio_idc= get_bits(&s->gb, 8);
167 if( aspect_ratio_idc == EXTENDED_SAR ) {
168 sps->sar.num= get_bits(&s->gb, 16);
169 sps->sar.den= get_bits(&s->gb, 16);
170 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
171 sps->sar= pixel_aspect[aspect_ratio_idc];
173 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
180 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
182 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
183 get_bits1(&s->gb); /* overscan_appropriate_flag */
186 sps->video_signal_type_present_flag = get_bits1(&s->gb);
187 if(sps->video_signal_type_present_flag){
188 get_bits(&s->gb, 3); /* video_format */
189 sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
191 sps->colour_description_present_flag = get_bits1(&s->gb);
192 if(sps->colour_description_present_flag){
193 sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
194 sps->color_trc = get_bits(&s->gb, 8); /* transfer_characteristics */
195 sps->colorspace = get_bits(&s->gb, 8); /* matrix_coefficients */
196 if (sps->color_primaries >= AVCOL_PRI_NB)
197 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
198 if (sps->color_trc >= AVCOL_TRC_NB)
199 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
200 if (sps->colorspace >= AVCOL_SPC_NB)
201 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
205 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
206 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1; /* chroma_sample_location_type_top_field */
207 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
210 sps->timing_info_present_flag = get_bits1(&s->gb);
211 if(sps->timing_info_present_flag){
212 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
213 sps->time_scale = get_bits_long(&s->gb, 32);
214 if(!sps->num_units_in_tick || !sps->time_scale){
215 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);
218 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
221 sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
222 if(sps->nal_hrd_parameters_present_flag)
223 if(decode_hrd_parameters(h, sps) < 0)
225 sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
226 if(sps->vcl_hrd_parameters_present_flag)
227 if(decode_hrd_parameters(h, sps) < 0)
229 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
230 get_bits1(&s->gb); /* low_delay_hrd_flag */
231 sps->pic_struct_present_flag = get_bits1(&s->gb);
233 sps->bitstream_restriction_flag = get_bits1(&s->gb);
234 if(sps->bitstream_restriction_flag){
235 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
236 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
237 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
238 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
239 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
240 sps->num_reorder_frames= get_ue_golomb(&s->gb);
241 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
243 if(s->gb.size_in_bits < get_bits_count(&s->gb)){
244 sps->num_reorder_frames=0;
245 sps->bitstream_restriction_flag= 0;
248 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
249 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
253 if(s->gb.size_in_bits < get_bits_count(&s->gb)){
254 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
261 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
262 const uint8_t *jvt_list, const uint8_t *fallback_list){
263 MpegEncContext * const s = &h->s;
264 int i, last = 8, next = 8;
265 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
266 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
267 memcpy(factors, fallback_list, size*sizeof(uint8_t));
271 next = (last + get_se_golomb(&s->gb)) & 0xff;
272 if(!i && !next){ /* matrix not written, we use the preset one */
273 memcpy(factors, jvt_list, size*sizeof(uint8_t));
276 last = factors[scan[i]] = next ? next : last;
280 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
281 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
282 MpegEncContext * const s = &h->s;
283 int fallback_sps = !is_sps && sps->scaling_matrix_present;
284 const uint8_t *fallback[4] = {
285 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
286 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
287 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
288 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
290 if(get_bits1(&s->gb)){
291 sps->scaling_matrix_present |= is_sps;
292 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
293 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
294 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
295 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
296 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
297 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
298 if(is_sps || pps->transform_8x8_mode){
299 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
300 if(sps->chroma_format_idc == 3){
301 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
302 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
304 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
305 if(sps->chroma_format_idc == 3){
306 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
307 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
313 int ff_h264_decode_seq_parameter_set(H264Context *h){
314 MpegEncContext * const s = &h->s;
315 int profile_idc, level_idc, constraint_set_flags = 0;
320 profile_idc= get_bits(&s->gb, 8);
321 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
322 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
323 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
324 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
325 get_bits(&s->gb, 4); // reserved
326 level_idc= get_bits(&s->gb, 8);
327 sps_id= get_ue_golomb_31(&s->gb);
329 if(sps_id >= MAX_SPS_COUNT) {
330 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
333 sps= av_mallocz(sizeof(SPS));
337 sps->time_offset_length = 24;
338 sps->profile_idc= profile_idc;
339 sps->constraint_set_flags = constraint_set_flags;
340 sps->level_idc= level_idc;
341 sps->full_range = -1;
343 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
344 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
345 sps->scaling_matrix_present = 0;
346 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
348 if(sps->profile_idc >= 100){ //high profile
349 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
350 if(sps->chroma_format_idc == 3)
351 sps->residual_color_transform_flag = get_bits1(&s->gb);
352 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
353 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
354 if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {
355 av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
356 sps->bit_depth_luma, sps->bit_depth_chroma);
359 sps->transform_bypass = get_bits1(&s->gb);
360 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
362 sps->chroma_format_idc= 1;
363 sps->bit_depth_luma = 8;
364 sps->bit_depth_chroma = 8;
367 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
368 sps->poc_type= get_ue_golomb_31(&s->gb);
370 if(sps->poc_type == 0){ //FIXME #define
371 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
372 } else if(sps->poc_type == 1){//FIXME #define
373 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
374 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
375 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
376 sps->poc_cycle_length = get_ue_golomb(&s->gb);
378 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
379 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
383 for(i=0; i<sps->poc_cycle_length; i++)
384 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
385 }else if(sps->poc_type != 2){
386 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
390 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
391 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
392 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
395 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
396 sps->mb_width = get_ue_golomb(&s->gb) + 1;
397 sps->mb_height= get_ue_golomb(&s->gb) + 1;
398 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
399 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
400 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
404 sps->frame_mbs_only_flag= get_bits1(&s->gb);
405 if(!sps->frame_mbs_only_flag)
406 sps->mb_aff= get_bits1(&s->gb);
410 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
411 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
412 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
416 #ifndef ALLOW_INTERLACE
418 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
420 sps->crop= get_bits1(&s->gb);
422 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
423 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
424 sps->crop_left = get_ue_golomb(&s->gb);
425 sps->crop_right = get_ue_golomb(&s->gb);
426 sps->crop_top = get_ue_golomb(&s->gb);
427 sps->crop_bottom= get_ue_golomb(&s->gb);
428 if(sps->crop_left || sps->crop_top){
429 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);
431 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
432 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);
433 /* It is very unlikely that partial cropping will make anybody happy.
434 * Not cropping at all fixes for example playback of Sisvel 3D streams
435 * in applications supporting Sisvel 3D. */
448 sps->vui_parameters_present_flag= get_bits1(&s->gb);
449 if( sps->vui_parameters_present_flag )
450 if (decode_vui_parameters(h, sps) < 0)
456 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
457 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",
458 sps_id, sps->profile_idc, sps->level_idc,
460 sps->ref_frame_count,
461 sps->mb_width, sps->mb_height,
462 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
463 sps->direct_8x8_inference_flag ? "8B8" : "",
464 sps->crop_left, sps->crop_right,
465 sps->crop_top, sps->crop_bottom,
466 sps->vui_parameters_present_flag ? "VUI" : "",
467 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
468 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
469 sps->timing_info_present_flag ? sps->time_scale : 0,
474 av_free(h->sps_buffers[sps_id]);
475 h->sps_buffers[sps_id]= sps;
484 build_qp_table(PPS *pps, int t, int index, const int depth)
487 const int max_qp = 51 + 6*(depth-8);
488 for(i = 0; i < max_qp+1; i++)
489 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
492 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
493 MpegEncContext * const s = &h->s;
494 unsigned int pps_id= get_ue_golomb(&s->gb);
496 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
498 if(pps_id >= MAX_PPS_COUNT) {
499 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
503 pps= av_mallocz(sizeof(PPS));
506 pps->sps_id= get_ue_golomb_31(&s->gb);
507 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
508 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
512 pps->cabac= get_bits1(&s->gb);
513 pps->pic_order_present= get_bits1(&s->gb);
514 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
515 if(pps->slice_group_count > 1 ){
516 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
517 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
518 switch(pps->mb_slice_group_map_type){
521 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
522 | run_length[ i ] |1 |ue(v) |
527 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
529 | top_left_mb[ i ] |1 |ue(v) |
530 | bottom_right_mb[ i ] |1 |ue(v) |
538 | slice_group_change_direction_flag |1 |u(1) |
539 | slice_group_change_rate_minus1 |1 |ue(v) |
544 | slice_group_id_cnt_minus1 |1 |ue(v) |
545 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
547 | slice_group_id[ i ] |1 |u(v) |
552 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
553 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
554 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
555 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
559 pps->weighted_pred= get_bits1(&s->gb);
560 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
561 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
562 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
563 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
564 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
565 pps->constrained_intra_pred= get_bits1(&s->gb);
566 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
568 pps->transform_8x8_mode= 0;
569 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
570 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
571 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
573 if(get_bits_count(&s->gb) < bit_length){
574 pps->transform_8x8_mode= get_bits1(&s->gb);
575 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
576 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
578 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
581 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
582 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
583 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
584 pps->chroma_qp_diff= 1;
586 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
587 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",
589 pps->cabac ? "CABAC" : "CAVLC",
590 pps->slice_group_count,
591 pps->ref_count[0], pps->ref_count[1],
592 pps->weighted_pred ? "weighted" : "",
593 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
594 pps->deblocking_filter_parameters_present ? "LPAR" : "",
595 pps->constrained_intra_pred ? "CONSTR" : "",
596 pps->redundant_pic_cnt_present ? "REDU" : "",
597 pps->transform_8x8_mode ? "8x8DCT" : ""
601 av_free(h->pps_buffers[pps_id]);
602 h->pps_buffers[pps_id]= pps;