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 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
41 #define MIN_LOG2_MAX_FRAME_NUM 4
43 static const AVRational pixel_aspect[17]={
63 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
65 #define CHROMA_QP_TABLE_END(d) \
66 QP(0,d), QP(1,d), QP(2,d), QP(3,d), QP(4,d), QP(5,d),\
67 QP(6,d), QP(7,d), QP(8,d), QP(9,d), QP(10,d), QP(11,d),\
68 QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
69 QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
70 QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
71 QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
72 QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
73 QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
74 QP(39,d), QP(39,d), QP(39,d), QP(39,d)
76 const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM+1] = {
78 CHROMA_QP_TABLE_END(8)
82 CHROMA_QP_TABLE_END(9)
87 CHROMA_QP_TABLE_END(10)
91 static const uint8_t default_scaling4[2][16]={
103 static const uint8_t default_scaling8[2][64]={
104 { 6,10,13,16,18,23,25,27,
105 10,11,16,18,23,25,27,29,
106 13,16,18,23,25,27,29,31,
107 16,18,23,25,27,29,31,33,
108 18,23,25,27,29,31,33,36,
109 23,25,27,29,31,33,36,38,
110 25,27,29,31,33,36,38,40,
111 27,29,31,33,36,38,40,42
113 9,13,15,17,19,21,22,24,
114 13,13,17,19,21,22,24,25,
115 15,17,19,21,22,24,25,27,
116 17,19,21,22,24,25,27,28,
117 19,21,22,24,25,27,28,30,
118 21,22,24,25,27,28,30,32,
119 22,24,25,27,28,30,32,33,
120 24,25,27,28,30,32,33,35
123 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
124 MpegEncContext * const s = &h->s;
126 cpb_count = get_ue_golomb_31(&s->gb) + 1;
129 av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
133 get_bits(&s->gb, 4); /* bit_rate_scale */
134 get_bits(&s->gb, 4); /* cpb_size_scale */
135 for(i=0; i<cpb_count; i++){
136 get_ue_golomb_long(&s->gb); /* bit_rate_value_minus1 */
137 get_ue_golomb_long(&s->gb); /* cpb_size_value_minus1 */
138 get_bits1(&s->gb); /* cbr_flag */
140 sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
141 sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
142 sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
143 sps->time_offset_length = get_bits(&s->gb, 5);
144 sps->cpb_cnt = cpb_count;
148 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
149 MpegEncContext * const s = &h->s;
150 int aspect_ratio_info_present_flag;
151 unsigned int aspect_ratio_idc;
153 aspect_ratio_info_present_flag= get_bits1(&s->gb);
155 if( aspect_ratio_info_present_flag ) {
156 aspect_ratio_idc= get_bits(&s->gb, 8);
157 if( aspect_ratio_idc == EXTENDED_SAR ) {
158 sps->sar.num= get_bits(&s->gb, 16);
159 sps->sar.den= get_bits(&s->gb, 16);
160 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
161 sps->sar= pixel_aspect[aspect_ratio_idc];
163 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
170 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
172 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
173 get_bits1(&s->gb); /* overscan_appropriate_flag */
176 sps->video_signal_type_present_flag = get_bits1(&s->gb);
177 if(sps->video_signal_type_present_flag){
178 get_bits(&s->gb, 3); /* video_format */
179 sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
181 sps->colour_description_present_flag = get_bits1(&s->gb);
182 if(sps->colour_description_present_flag){
183 sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
184 sps->color_trc = get_bits(&s->gb, 8); /* transfer_characteristics */
185 sps->colorspace = get_bits(&s->gb, 8); /* matrix_coefficients */
186 if (sps->color_primaries >= AVCOL_PRI_NB)
187 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
188 if (sps->color_trc >= AVCOL_TRC_NB)
189 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
190 if (sps->colorspace >= AVCOL_SPC_NB)
191 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
195 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
196 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1; /* chroma_sample_location_type_top_field */
197 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
200 sps->timing_info_present_flag = get_bits1(&s->gb);
201 if(sps->timing_info_present_flag){
202 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
203 sps->time_scale = get_bits_long(&s->gb, 32);
204 if(!sps->num_units_in_tick || !sps->time_scale){
205 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);
208 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
211 sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
212 if(sps->nal_hrd_parameters_present_flag)
213 if(decode_hrd_parameters(h, sps) < 0)
215 sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
216 if(sps->vcl_hrd_parameters_present_flag)
217 if(decode_hrd_parameters(h, sps) < 0)
219 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
220 get_bits1(&s->gb); /* low_delay_hrd_flag */
221 sps->pic_struct_present_flag = get_bits1(&s->gb);
223 sps->bitstream_restriction_flag = get_bits1(&s->gb);
224 if(sps->bitstream_restriction_flag){
225 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
226 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
227 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
228 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
229 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
230 sps->num_reorder_frames= get_ue_golomb(&s->gb);
231 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
233 if (get_bits_left(&s->gb) < 0) {
234 sps->num_reorder_frames=0;
235 sps->bitstream_restriction_flag= 0;
238 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
239 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
243 if (get_bits_left(&s->gb) < 0) {
244 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
245 return AVERROR_INVALIDDATA;
251 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
252 const uint8_t *jvt_list, const uint8_t *fallback_list){
253 MpegEncContext * const s = &h->s;
254 int i, last = 8, next = 8;
255 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
256 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
257 memcpy(factors, fallback_list, size*sizeof(uint8_t));
261 next = (last + get_se_golomb(&s->gb)) & 0xff;
262 if(!i && !next){ /* matrix not written, we use the preset one */
263 memcpy(factors, jvt_list, size*sizeof(uint8_t));
266 last = factors[scan[i]] = next ? next : last;
270 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
271 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
272 MpegEncContext * const s = &h->s;
273 int fallback_sps = !is_sps && sps->scaling_matrix_present;
274 const uint8_t *fallback[4] = {
275 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
276 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
277 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
278 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
280 if(get_bits1(&s->gb)){
281 sps->scaling_matrix_present |= is_sps;
282 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
283 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
284 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
285 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
286 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
287 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
288 if(is_sps || pps->transform_8x8_mode){
289 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
290 if(sps->chroma_format_idc == 3){
291 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
292 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
294 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
295 if(sps->chroma_format_idc == 3){
296 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
297 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
303 int ff_h264_decode_seq_parameter_set(H264Context *h){
304 MpegEncContext * const s = &h->s;
305 int profile_idc, level_idc, constraint_set_flags = 0;
307 int i, log2_max_frame_num_minus4;
310 profile_idc= get_bits(&s->gb, 8);
311 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
312 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
313 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
314 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
315 get_bits(&s->gb, 4); // reserved
316 level_idc= get_bits(&s->gb, 8);
317 sps_id= get_ue_golomb_31(&s->gb);
319 if(sps_id >= MAX_SPS_COUNT) {
320 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
323 sps= av_mallocz(sizeof(SPS));
327 sps->time_offset_length = 24;
328 sps->profile_idc= profile_idc;
329 sps->constraint_set_flags = constraint_set_flags;
330 sps->level_idc= level_idc;
332 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
333 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
334 sps->scaling_matrix_present = 0;
336 if(sps->profile_idc >= 100){ //high profile
337 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
338 if(sps->chroma_format_idc > 3) {
339 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
341 } else if(sps->chroma_format_idc == 3) {
342 sps->residual_color_transform_flag = get_bits1(&s->gb);
344 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
345 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
346 sps->transform_bypass = get_bits1(&s->gb);
347 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
349 sps->chroma_format_idc= 1;
350 sps->bit_depth_luma = 8;
351 sps->bit_depth_chroma = 8;
354 log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
355 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
356 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
357 av_log(h->s.avctx, AV_LOG_ERROR,
358 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
359 log2_max_frame_num_minus4);
362 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
364 sps->poc_type= get_ue_golomb_31(&s->gb);
366 if(sps->poc_type == 0){ //FIXME #define
367 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
368 } else if(sps->poc_type == 1){//FIXME #define
369 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
370 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
371 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
372 sps->poc_cycle_length = get_ue_golomb(&s->gb);
374 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
375 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
379 for(i=0; i<sps->poc_cycle_length; i++)
380 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
381 }else if(sps->poc_type != 2){
382 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
386 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
387 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
388 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
391 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
392 sps->mb_width = get_ue_golomb(&s->gb) + 1;
393 sps->mb_height= get_ue_golomb(&s->gb) + 1;
394 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
395 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
396 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
400 sps->frame_mbs_only_flag= get_bits1(&s->gb);
401 if(!sps->frame_mbs_only_flag)
402 sps->mb_aff= get_bits1(&s->gb);
406 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
407 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
408 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
412 #ifndef ALLOW_INTERLACE
414 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
416 sps->crop= get_bits1(&s->gb);
418 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
419 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
420 sps->crop_left = get_ue_golomb(&s->gb);
421 sps->crop_right = get_ue_golomb(&s->gb);
422 sps->crop_top = get_ue_golomb(&s->gb);
423 sps->crop_bottom= get_ue_golomb(&s->gb);
424 if(sps->crop_left || sps->crop_top){
425 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
427 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
428 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
437 sps->vui_parameters_present_flag= get_bits1(&s->gb);
438 if( sps->vui_parameters_present_flag )
439 if (decode_vui_parameters(h, sps) < 0)
445 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
446 static const char csp[4][5] = { "Gray", "420", "422", "444" };
447 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",
448 sps_id, sps->profile_idc, sps->level_idc,
450 sps->ref_frame_count,
451 sps->mb_width, sps->mb_height,
452 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
453 sps->direct_8x8_inference_flag ? "8B8" : "",
454 sps->crop_left, sps->crop_right,
455 sps->crop_top, sps->crop_bottom,
456 sps->vui_parameters_present_flag ? "VUI" : "",
457 csp[sps->chroma_format_idc],
458 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
459 sps->timing_info_present_flag ? sps->time_scale : 0
464 av_free(h->sps_buffers[sps_id]);
465 h->sps_buffers[sps_id] = sps;
467 h->current_sps_id = sps_id;
476 build_qp_table(PPS *pps, int t, int index, const int depth)
479 const int max_qp = 51 + 6*(depth-8);
480 for(i = 0; i < max_qp+1; i++)
481 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
484 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
485 MpegEncContext * const s = &h->s;
486 unsigned int pps_id= get_ue_golomb(&s->gb);
488 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
491 if(pps_id >= MAX_PPS_COUNT) {
492 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
494 } else if (h->sps.bit_depth_luma > 10) {
495 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
496 return AVERROR_PATCHWELCOME;
499 pps= av_mallocz(sizeof(PPS));
502 pps->sps_id= get_ue_golomb_31(&s->gb);
503 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
504 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
508 pps->cabac= get_bits1(&s->gb);
509 pps->pic_order_present= get_bits1(&s->gb);
510 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
511 if(pps->slice_group_count > 1 ){
512 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
513 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
514 switch(pps->mb_slice_group_map_type){
517 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
518 | run_length[ i ] |1 |ue(v) |
523 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
525 | top_left_mb[ i ] |1 |ue(v) |
526 | bottom_right_mb[ i ] |1 |ue(v) |
534 | slice_group_change_direction_flag |1 |u(1) |
535 | slice_group_change_rate_minus1 |1 |ue(v) |
540 | slice_group_id_cnt_minus1 |1 |ue(v) |
541 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
543 | slice_group_id[ i ] |1 |u(v) |
548 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
549 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
550 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
551 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
555 pps->weighted_pred= get_bits1(&s->gb);
556 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
557 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
558 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
559 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
560 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
561 pps->constrained_intra_pred= get_bits1(&s->gb);
562 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
564 pps->transform_8x8_mode= 0;
565 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
566 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
567 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
569 bits_left = bit_length - get_bits_count(&s->gb);
570 if (bits_left && (bits_left > 8 ||
571 show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
572 pps->transform_8x8_mode= get_bits1(&s->gb);
573 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
574 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
576 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
579 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
580 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
581 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
582 pps->chroma_qp_diff= 1;
584 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
585 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",
587 pps->cabac ? "CABAC" : "CAVLC",
588 pps->slice_group_count,
589 pps->ref_count[0], pps->ref_count[1],
590 pps->weighted_pred ? "weighted" : "",
591 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
592 pps->deblocking_filter_parameters_present ? "LPAR" : "",
593 pps->constrained_intra_pred ? "CONSTR" : "",
594 pps->redundant_pic_cnt_present ? "REDU" : "",
595 pps->transform_8x8_mode ? "8x8DCT" : ""
599 av_free(h->pps_buffers[pps_id]);
600 h->pps_buffers[pps_id]= pps;