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 || sps->profile_idc == 110 ||
337 sps->profile_idc == 122 || sps->profile_idc == 244 ||
338 sps->profile_idc == 44 || sps->profile_idc == 83 ||
339 sps->profile_idc == 86 || sps->profile_idc == 118 ||
340 sps->profile_idc == 128 || sps->profile_idc == 144) {
341 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
342 if(sps->chroma_format_idc > 3) {
343 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
345 } else if(sps->chroma_format_idc == 3) {
346 sps->residual_color_transform_flag = get_bits1(&s->gb);
348 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
349 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
350 sps->transform_bypass = get_bits1(&s->gb);
351 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
353 sps->chroma_format_idc= 1;
354 sps->bit_depth_luma = 8;
355 sps->bit_depth_chroma = 8;
358 log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
359 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
360 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
361 av_log(h->s.avctx, AV_LOG_ERROR,
362 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
363 log2_max_frame_num_minus4);
366 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 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 >= 32U){
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 ...\n");
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, this could look slightly wrong ...\n");
441 sps->vui_parameters_present_flag= get_bits1(&s->gb);
442 if( sps->vui_parameters_present_flag )
443 if (decode_vui_parameters(h, sps) < 0)
449 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
450 static const char csp[4][5] = { "Gray", "420", "422", "444" };
451 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",
452 sps_id, sps->profile_idc, sps->level_idc,
454 sps->ref_frame_count,
455 sps->mb_width, sps->mb_height,
456 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
457 sps->direct_8x8_inference_flag ? "8B8" : "",
458 sps->crop_left, sps->crop_right,
459 sps->crop_top, sps->crop_bottom,
460 sps->vui_parameters_present_flag ? "VUI" : "",
461 csp[sps->chroma_format_idc],
462 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
463 sps->timing_info_present_flag ? sps->time_scale : 0
468 av_free(h->sps_buffers[sps_id]);
469 h->sps_buffers[sps_id] = sps;
471 h->current_sps_id = sps_id;
480 build_qp_table(PPS *pps, int t, int index, const int depth)
483 const int max_qp = 51 + 6*(depth-8);
484 for(i = 0; i < max_qp+1; i++)
485 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
488 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
489 MpegEncContext * const s = &h->s;
490 unsigned int pps_id= get_ue_golomb(&s->gb);
492 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
495 if(pps_id >= MAX_PPS_COUNT) {
496 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
498 } else if (h->sps.bit_depth_luma > 10) {
499 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
500 return AVERROR_PATCHWELCOME;
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 bits_left = bit_length - get_bits_count(&s->gb);
574 if (bits_left && (bits_left > 8 ||
575 show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
576 pps->transform_8x8_mode= get_bits1(&s->gb);
577 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
578 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
580 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
583 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
584 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
585 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
586 pps->chroma_qp_diff= 1;
588 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
589 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",
591 pps->cabac ? "CABAC" : "CAVLC",
592 pps->slice_group_count,
593 pps->ref_count[0], pps->ref_count[1],
594 pps->weighted_pred ? "weighted" : "",
595 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
596 pps->deblocking_filter_parameters_present ? "LPAR" : "",
597 pps->constrained_intra_pred ? "CONSTR" : "",
598 pps->redundant_pic_cnt_present ? "REDU" : "",
599 pps->transform_8x8_mode ? "8x8DCT" : ""
603 av_free(h->pps_buffers[pps_id]);
604 h->pps_buffers[pps_id]= pps;