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_long(&s->gb); /* bit_rate_value_minus1 */
147 get_ue_golomb_long(&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);
232 if(!get_bits_left(&s->gb))
234 sps->bitstream_restriction_flag = get_bits1(&s->gb);
235 if(sps->bitstream_restriction_flag){
236 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
237 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
238 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
239 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
240 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
241 sps->num_reorder_frames= get_ue_golomb(&s->gb);
242 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
244 if(get_bits_left(&s->gb) < 0){
245 sps->num_reorder_frames=0;
246 sps->bitstream_restriction_flag= 0;
249 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
250 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
254 if(get_bits_left(&s->gb) < 0){
255 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
262 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
263 const uint8_t *jvt_list, const uint8_t *fallback_list){
264 MpegEncContext * const s = &h->s;
265 int i, last = 8, next = 8;
266 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
267 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
268 memcpy(factors, fallback_list, size*sizeof(uint8_t));
272 next = (last + get_se_golomb(&s->gb)) & 0xff;
273 if(!i && !next){ /* matrix not written, we use the preset one */
274 memcpy(factors, jvt_list, size*sizeof(uint8_t));
277 last = factors[scan[i]] = next ? next : last;
281 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
282 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
283 MpegEncContext * const s = &h->s;
284 int fallback_sps = !is_sps && sps->scaling_matrix_present;
285 const uint8_t *fallback[4] = {
286 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
287 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
288 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
289 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
291 if(get_bits1(&s->gb)){
292 sps->scaling_matrix_present |= is_sps;
293 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
294 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
295 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
296 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
297 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
298 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
299 if(is_sps || pps->transform_8x8_mode){
300 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
301 if(sps->chroma_format_idc == 3){
302 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
303 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
305 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
306 if(sps->chroma_format_idc == 3){
307 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
308 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
314 int ff_h264_decode_seq_parameter_set(H264Context *h){
315 MpegEncContext * const s = &h->s;
316 int profile_idc, level_idc, constraint_set_flags = 0;
321 profile_idc= get_bits(&s->gb, 8);
322 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
323 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
324 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
325 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
326 get_bits(&s->gb, 4); // reserved
327 level_idc= get_bits(&s->gb, 8);
328 sps_id= get_ue_golomb_31(&s->gb);
330 if(sps_id >= MAX_SPS_COUNT) {
331 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
334 sps= av_mallocz(sizeof(SPS));
338 sps->time_offset_length = 24;
339 sps->profile_idc= profile_idc;
340 sps->constraint_set_flags = constraint_set_flags;
341 sps->level_idc= level_idc;
342 sps->full_range = -1;
344 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
345 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
346 sps->scaling_matrix_present = 0;
347 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
349 if(sps->profile_idc >= 100){ //high profile
350 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
351 if (sps->chroma_format_idc > 3U) {
352 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
355 if(sps->chroma_format_idc == 3)
356 sps->residual_color_transform_flag = get_bits1(&s->gb);
357 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
358 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
359 if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {
360 av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
361 sps->bit_depth_luma, sps->bit_depth_chroma);
364 sps->transform_bypass = get_bits1(&s->gb);
365 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
367 sps->chroma_format_idc= 1;
368 sps->bit_depth_luma = 8;
369 sps->bit_depth_chroma = 8;
372 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
373 sps->poc_type= get_ue_golomb_31(&s->gb);
375 if(sps->poc_type == 0){ //FIXME #define
376 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
377 } else if(sps->poc_type == 1){//FIXME #define
378 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
379 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
380 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
381 sps->poc_cycle_length = get_ue_golomb(&s->gb);
383 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
384 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
388 for(i=0; i<sps->poc_cycle_length; i++)
389 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
390 }else if(sps->poc_type != 2){
391 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
395 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
396 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
397 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
400 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
401 sps->mb_width = get_ue_golomb(&s->gb) + 1;
402 sps->mb_height= get_ue_golomb(&s->gb) + 1;
403 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
404 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
405 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
409 sps->frame_mbs_only_flag= get_bits1(&s->gb);
410 if(!sps->frame_mbs_only_flag)
411 sps->mb_aff= get_bits1(&s->gb);
415 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
417 #ifndef ALLOW_INTERLACE
419 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
421 sps->crop= get_bits1(&s->gb);
423 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
424 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
425 sps->crop_left = get_ue_golomb(&s->gb);
426 sps->crop_right = get_ue_golomb(&s->gb);
427 sps->crop_top = get_ue_golomb(&s->gb);
428 sps->crop_bottom= get_ue_golomb(&s->gb);
429 if(sps->crop_left || sps->crop_top){
430 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);
432 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
433 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);
434 /* It is very unlikely that partial cropping will make anybody happy.
435 * Not cropping at all fixes for example playback of Sisvel 3D streams
436 * in applications supporting Sisvel 3D. */
449 sps->vui_parameters_present_flag= get_bits1(&s->gb);
450 if( sps->vui_parameters_present_flag )
451 if (decode_vui_parameters(h, sps) < 0)
457 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
458 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",
459 sps_id, sps->profile_idc, sps->level_idc,
461 sps->ref_frame_count,
462 sps->mb_width, sps->mb_height,
463 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
464 sps->direct_8x8_inference_flag ? "8B8" : "",
465 sps->crop_left, sps->crop_right,
466 sps->crop_top, sps->crop_bottom,
467 sps->vui_parameters_present_flag ? "VUI" : "",
468 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
469 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
470 sps->timing_info_present_flag ? sps->time_scale : 0,
475 av_free(h->sps_buffers[sps_id]);
476 h->sps_buffers[sps_id]= sps;
485 build_qp_table(PPS *pps, int t, int index, const int depth)
488 const int max_qp = 51 + 6*(depth-8);
489 for(i = 0; i < max_qp+1; i++)
490 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
493 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
495 const SPS *sps = h->sps_buffers[pps->sps_id];
496 int profile_idc = sps->profile_idc;
498 if ((profile_idc == 66 || profile_idc == 77 ||
499 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
500 av_log(h->s.avctx, AV_LOG_VERBOSE,
501 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
508 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
509 MpegEncContext * const s = &h->s;
510 unsigned int pps_id= get_ue_golomb(&s->gb);
512 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
515 if(pps_id >= MAX_PPS_COUNT) {
516 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
520 pps= av_mallocz(sizeof(PPS));
523 pps->sps_id= get_ue_golomb_31(&s->gb);
524 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
525 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
529 pps->cabac= get_bits1(&s->gb);
530 pps->pic_order_present= get_bits1(&s->gb);
531 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
532 if(pps->slice_group_count > 1 ){
533 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
534 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
535 switch(pps->mb_slice_group_map_type){
538 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
539 | run_length[ i ] |1 |ue(v) |
544 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
546 | top_left_mb[ i ] |1 |ue(v) |
547 | bottom_right_mb[ i ] |1 |ue(v) |
555 | slice_group_change_direction_flag |1 |u(1) |
556 | slice_group_change_rate_minus1 |1 |ue(v) |
561 | slice_group_id_cnt_minus1 |1 |ue(v) |
562 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
564 | slice_group_id[ i ] |1 |u(v) |
569 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
570 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
571 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
572 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
576 pps->weighted_pred= get_bits1(&s->gb);
577 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
578 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
579 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
580 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
581 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
582 pps->constrained_intra_pred= get_bits1(&s->gb);
583 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
585 pps->transform_8x8_mode= 0;
586 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
587 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
588 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
590 bits_left = bit_length - get_bits_count(&s->gb);
591 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
592 pps->transform_8x8_mode= get_bits1(&s->gb);
593 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
594 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
596 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
599 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
600 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
601 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
602 pps->chroma_qp_diff= 1;
604 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
605 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",
607 pps->cabac ? "CABAC" : "CAVLC",
608 pps->slice_group_count,
609 pps->ref_count[0], pps->ref_count[1],
610 pps->weighted_pred ? "weighted" : "",
611 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
612 pps->deblocking_filter_parameters_present ? "LPAR" : "",
613 pps->constrained_intra_pred ? "CONSTR" : "",
614 pps->redundant_pic_cnt_present ? "REDU" : "",
615 pps->transform_8x8_mode ? "8x8DCT" : ""
619 av_free(h->pps_buffers[pps_id]);
620 h->pps_buffers[pps_id]= pps;