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);
255 if (get_bits_left(&s->gb) < 0) {
256 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
257 return AVERROR_INVALIDDATA;
263 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
264 const uint8_t *jvt_list, const uint8_t *fallback_list){
265 MpegEncContext * const s = &h->s;
266 int i, last = 8, next = 8;
267 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
268 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
269 memcpy(factors, fallback_list, size*sizeof(uint8_t));
273 next = (last + get_se_golomb(&s->gb)) & 0xff;
274 if(!i && !next){ /* matrix not written, we use the preset one */
275 memcpy(factors, jvt_list, size*sizeof(uint8_t));
278 last = factors[scan[i]] = next ? next : last;
282 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
283 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
284 MpegEncContext * const s = &h->s;
285 int fallback_sps = !is_sps && sps->scaling_matrix_present;
286 const uint8_t *fallback[4] = {
287 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
288 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
289 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
290 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
292 if(get_bits1(&s->gb)){
293 sps->scaling_matrix_present |= is_sps;
294 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
295 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
296 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
297 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
298 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
299 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
300 if(is_sps || pps->transform_8x8_mode){
301 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
302 if(sps->chroma_format_idc == 3){
303 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
304 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
306 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
307 if(sps->chroma_format_idc == 3){
308 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
309 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
315 int ff_h264_decode_seq_parameter_set(H264Context *h){
316 MpegEncContext * const s = &h->s;
317 int profile_idc, level_idc, constraint_set_flags = 0;
322 profile_idc= get_bits(&s->gb, 8);
323 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
324 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
325 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
326 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
327 constraint_set_flags |= get_bits1(&s->gb) << 4; //constraint_set4_flag
328 constraint_set_flags |= get_bits1(&s->gb) << 5; //constraint_set5_flag
329 get_bits(&s->gb, 2); // reserved
330 level_idc= get_bits(&s->gb, 8);
331 sps_id= get_ue_golomb_31(&s->gb);
333 if(sps_id >= MAX_SPS_COUNT) {
334 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
337 sps= av_mallocz(sizeof(SPS));
341 sps->time_offset_length = 24;
342 sps->profile_idc= profile_idc;
343 sps->constraint_set_flags = constraint_set_flags;
344 sps->level_idc= level_idc;
345 sps->full_range = -1;
347 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
348 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
349 sps->scaling_matrix_present = 0;
350 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
352 if(sps->profile_idc == 100 || sps->profile_idc == 110 ||
353 sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc == 44 ||
354 sps->profile_idc == 83 || sps->profile_idc == 86 || sps->profile_idc == 118 ||
355 sps->profile_idc == 128 ) {
356 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
357 if (sps->chroma_format_idc > 3U) {
358 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
360 } else if(sps->chroma_format_idc == 3) {
361 sps->residual_color_transform_flag = get_bits1(&s->gb);
362 if(sps->residual_color_transform_flag) {
363 av_log(h->s.avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
367 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
368 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
369 if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {
370 av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
371 sps->bit_depth_luma, sps->bit_depth_chroma);
374 sps->transform_bypass = get_bits1(&s->gb);
375 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
377 sps->chroma_format_idc= 1;
378 sps->bit_depth_luma = 8;
379 sps->bit_depth_chroma = 8;
382 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
383 if (sps->log2_max_frame_num < 4 || sps->log2_max_frame_num > 16) {
384 av_log(h->s.avctx, AV_LOG_ERROR, "illegal log2_max_frame_num %d\n",
385 sps->log2_max_frame_num);
389 sps->poc_type= get_ue_golomb_31(&s->gb);
391 if(sps->poc_type == 0){ //FIXME #define
392 unsigned t = get_ue_golomb(&s->gb);
394 av_log(h->s.avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
397 sps->log2_max_poc_lsb= t + 4;
398 } else if(sps->poc_type == 1){//FIXME #define
399 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
400 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
401 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
402 sps->poc_cycle_length = get_ue_golomb(&s->gb);
404 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
405 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
409 for(i=0; i<sps->poc_cycle_length; i++)
410 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
411 }else if(sps->poc_type != 2){
412 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
416 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
417 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
418 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
421 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
422 sps->mb_width = get_ue_golomb(&s->gb) + 1;
423 sps->mb_height= get_ue_golomb(&s->gb) + 1;
424 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
425 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
426 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
430 sps->frame_mbs_only_flag= get_bits1(&s->gb);
431 if(!sps->frame_mbs_only_flag)
432 sps->mb_aff= get_bits1(&s->gb);
436 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
438 #ifndef ALLOW_INTERLACE
440 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
442 sps->crop= get_bits1(&s->gb);
444 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
445 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
446 sps->crop_left = get_ue_golomb(&s->gb);
447 sps->crop_right = get_ue_golomb(&s->gb);
448 sps->crop_top = get_ue_golomb(&s->gb);
449 sps->crop_bottom= get_ue_golomb(&s->gb);
450 if(sps->crop_left || sps->crop_top){
451 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);
453 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
454 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);
455 /* It is very unlikely that partial cropping will make anybody happy.
456 * Not cropping at all fixes for example playback of Sisvel 3D streams
457 * in applications supporting Sisvel 3D. */
470 sps->vui_parameters_present_flag= get_bits1(&s->gb);
471 if( sps->vui_parameters_present_flag )
472 if (decode_vui_parameters(h, sps) < 0)
478 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
479 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",
480 sps_id, sps->profile_idc, sps->level_idc,
482 sps->ref_frame_count,
483 sps->mb_width, sps->mb_height,
484 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
485 sps->direct_8x8_inference_flag ? "8B8" : "",
486 sps->crop_left, sps->crop_right,
487 sps->crop_top, sps->crop_bottom,
488 sps->vui_parameters_present_flag ? "VUI" : "",
489 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
490 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
491 sps->timing_info_present_flag ? sps->time_scale : 0,
496 av_free(h->sps_buffers[sps_id]);
497 h->sps_buffers[sps_id]= sps;
506 build_qp_table(PPS *pps, int t, int index, const int depth)
509 const int max_qp = 51 + 6*(depth-8);
510 for(i = 0; i < max_qp+1; i++)
511 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
514 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
516 const SPS *sps = h->sps_buffers[pps->sps_id];
517 int profile_idc = sps->profile_idc;
519 if ((profile_idc == 66 || profile_idc == 77 ||
520 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
521 av_log(h->s.avctx, AV_LOG_VERBOSE,
522 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
529 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
530 MpegEncContext * const s = &h->s;
531 unsigned int pps_id= get_ue_golomb(&s->gb);
533 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
536 if(pps_id >= MAX_PPS_COUNT) {
537 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
539 } else if (h->sps.bit_depth_luma > 10) {
540 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
541 return AVERROR_PATCHWELCOME;
544 pps= av_mallocz(sizeof(PPS));
547 pps->sps_id= get_ue_golomb_31(&s->gb);
548 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
549 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
553 pps->cabac= get_bits1(&s->gb);
554 pps->pic_order_present= get_bits1(&s->gb);
555 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
556 if(pps->slice_group_count > 1 ){
557 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
558 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
559 switch(pps->mb_slice_group_map_type){
562 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
563 | run_length[ i ] |1 |ue(v) |
568 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
570 | top_left_mb[ i ] |1 |ue(v) |
571 | bottom_right_mb[ i ] |1 |ue(v) |
579 | slice_group_change_direction_flag |1 |u(1) |
580 | slice_group_change_rate_minus1 |1 |ue(v) |
585 | slice_group_id_cnt_minus1 |1 |ue(v) |
586 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
588 | slice_group_id[ i ] |1 |u(v) |
593 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
594 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
595 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
596 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
600 pps->weighted_pred= get_bits1(&s->gb);
601 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
602 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
603 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
604 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
605 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
606 pps->constrained_intra_pred= get_bits1(&s->gb);
607 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
609 pps->transform_8x8_mode= 0;
610 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
611 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
612 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
614 bits_left = bit_length - get_bits_count(&s->gb);
615 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
616 pps->transform_8x8_mode= get_bits1(&s->gb);
617 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
618 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
620 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
623 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
624 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
625 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
626 pps->chroma_qp_diff= 1;
628 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
629 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",
631 pps->cabac ? "CABAC" : "CAVLC",
632 pps->slice_group_count,
633 pps->ref_count[0], pps->ref_count[1],
634 pps->weighted_pred ? "weighted" : "",
635 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
636 pps->deblocking_filter_parameters_present ? "LPAR" : "",
637 pps->constrained_intra_pred ? "CONSTR" : "",
638 pps->redundant_pic_cnt_present ? "REDU" : "",
639 pps->transform_8x8_mode ? "8x8DCT" : ""
643 av_free(h->pps_buffers[pps_id]);
644 h->pps_buffers[pps_id]= pps;