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"
32 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
39 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
40 #define MIN_LOG2_MAX_FRAME_NUM 4
42 static const AVRational pixel_aspect[17]={
62 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
64 #define CHROMA_QP_TABLE_END(d) \
65 QP(0,d), QP(1,d), QP(2,d), QP(3,d), QP(4,d), QP(5,d),\
66 QP(6,d), QP(7,d), QP(8,d), QP(9,d), QP(10,d), QP(11,d),\
67 QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
68 QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
69 QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
70 QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
71 QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
72 QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
73 QP(39,d), QP(39,d), QP(39,d), QP(39,d)
75 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
77 CHROMA_QP_TABLE_END(8)
81 CHROMA_QP_TABLE_END(9)
86 CHROMA_QP_TABLE_END(10)
92 CHROMA_QP_TABLE_END(11)
99 CHROMA_QP_TABLE_END(12)
107 CHROMA_QP_TABLE_END(13)
116 CHROMA_QP_TABLE_END(14)
120 static const uint8_t default_scaling4[2][16]={
132 static const uint8_t default_scaling8[2][64]={
133 { 6,10,13,16,18,23,25,27,
134 10,11,16,18,23,25,27,29,
135 13,16,18,23,25,27,29,31,
136 16,18,23,25,27,29,31,33,
137 18,23,25,27,29,31,33,36,
138 23,25,27,29,31,33,36,38,
139 25,27,29,31,33,36,38,40,
140 27,29,31,33,36,38,40,42
142 9,13,15,17,19,21,22,24,
143 13,13,17,19,21,22,24,25,
144 15,17,19,21,22,24,25,27,
145 17,19,21,22,24,25,27,28,
146 19,21,22,24,25,27,28,30,
147 21,22,24,25,27,28,30,32,
148 22,24,25,27,28,30,32,33,
149 24,25,27,28,30,32,33,35
152 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
154 cpb_count = get_ue_golomb_31(&h->gb) + 1;
157 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
161 get_bits(&h->gb, 4); /* bit_rate_scale */
162 get_bits(&h->gb, 4); /* cpb_size_scale */
163 for(i=0; i<cpb_count; i++){
164 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
165 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
166 get_bits1(&h->gb); /* cbr_flag */
168 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
169 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
170 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
171 sps->time_offset_length = get_bits(&h->gb, 5);
172 sps->cpb_cnt = cpb_count;
176 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
177 int aspect_ratio_info_present_flag;
178 unsigned int aspect_ratio_idc;
180 aspect_ratio_info_present_flag= get_bits1(&h->gb);
182 if( aspect_ratio_info_present_flag ) {
183 aspect_ratio_idc= get_bits(&h->gb, 8);
184 if( aspect_ratio_idc == EXTENDED_SAR ) {
185 sps->sar.num= get_bits(&h->gb, 16);
186 sps->sar.den= get_bits(&h->gb, 16);
187 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
188 sps->sar= pixel_aspect[aspect_ratio_idc];
190 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
197 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
199 if(get_bits1(&h->gb)){ /* overscan_info_present_flag */
200 get_bits1(&h->gb); /* overscan_appropriate_flag */
203 sps->video_signal_type_present_flag = get_bits1(&h->gb);
204 if(sps->video_signal_type_present_flag){
205 get_bits(&h->gb, 3); /* video_format */
206 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
208 sps->colour_description_present_flag = get_bits1(&h->gb);
209 if(sps->colour_description_present_flag){
210 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
211 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
212 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
213 if (sps->color_primaries >= AVCOL_PRI_NB)
214 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
215 if (sps->color_trc >= AVCOL_TRC_NB)
216 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
217 if (sps->colorspace >= AVCOL_SPC_NB)
218 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
222 if(get_bits1(&h->gb)){ /* chroma_location_info_present_flag */
223 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb)+1; /* chroma_sample_location_type_top_field */
224 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
227 sps->timing_info_present_flag = get_bits1(&h->gb);
228 if(sps->timing_info_present_flag){
229 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
230 sps->time_scale = get_bits_long(&h->gb, 32);
231 if(!sps->num_units_in_tick || !sps->time_scale){
232 av_log(h->avctx, AV_LOG_ERROR, "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n", sps->time_scale, sps->num_units_in_tick);
235 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
238 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
239 if(sps->nal_hrd_parameters_present_flag)
240 if(decode_hrd_parameters(h, sps) < 0)
242 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
243 if(sps->vcl_hrd_parameters_present_flag)
244 if(decode_hrd_parameters(h, sps) < 0)
246 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
247 get_bits1(&h->gb); /* low_delay_hrd_flag */
248 sps->pic_struct_present_flag = get_bits1(&h->gb);
249 if(!get_bits_left(&h->gb))
251 sps->bitstream_restriction_flag = get_bits1(&h->gb);
252 if(sps->bitstream_restriction_flag){
253 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
254 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
255 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
256 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
257 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
258 sps->num_reorder_frames= get_ue_golomb(&h->gb);
259 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
261 if (get_bits_left(&h->gb) < 0) {
262 sps->num_reorder_frames=0;
263 sps->bitstream_restriction_flag= 0;
266 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
267 av_log(h->avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
272 if (get_bits_left(&h->gb) < 0) {
273 av_log(h->avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
274 return AVERROR_INVALIDDATA;
280 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
281 const uint8_t *jvt_list, const uint8_t *fallback_list){
282 int i, last = 8, next = 8;
283 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
284 if(!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
285 memcpy(factors, fallback_list, size*sizeof(uint8_t));
289 next = (last + get_se_golomb(&h->gb)) & 0xff;
290 if(!i && !next){ /* matrix not written, we use the preset one */
291 memcpy(factors, jvt_list, size*sizeof(uint8_t));
294 last = factors[scan[i]] = next ? next : last;
298 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
299 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
300 int fallback_sps = !is_sps && sps->scaling_matrix_present;
301 const uint8_t *fallback[4] = {
302 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
303 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
304 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
305 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
307 if(get_bits1(&h->gb)){
308 sps->scaling_matrix_present |= is_sps;
309 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
310 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
311 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
312 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
313 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
314 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
315 if(is_sps || pps->transform_8x8_mode){
316 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
317 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
318 if(sps->chroma_format_idc == 3){
319 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
320 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
321 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
322 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
328 int ff_h264_decode_seq_parameter_set(H264Context *h){
329 int profile_idc, level_idc, constraint_set_flags = 0;
331 int i, log2_max_frame_num_minus4;
334 profile_idc= get_bits(&h->gb, 8);
335 constraint_set_flags |= get_bits1(&h->gb) << 0; //constraint_set0_flag
336 constraint_set_flags |= get_bits1(&h->gb) << 1; //constraint_set1_flag
337 constraint_set_flags |= get_bits1(&h->gb) << 2; //constraint_set2_flag
338 constraint_set_flags |= get_bits1(&h->gb) << 3; //constraint_set3_flag
339 constraint_set_flags |= get_bits1(&h->gb) << 4; //constraint_set4_flag
340 constraint_set_flags |= get_bits1(&h->gb) << 5; //constraint_set5_flag
341 get_bits(&h->gb, 2); // reserved
342 level_idc= get_bits(&h->gb, 8);
343 sps_id= get_ue_golomb_31(&h->gb);
345 if(sps_id >= MAX_SPS_COUNT) {
346 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
349 sps= av_mallocz(sizeof(SPS));
353 sps->time_offset_length = 24;
354 sps->profile_idc= profile_idc;
355 sps->constraint_set_flags = constraint_set_flags;
356 sps->level_idc= level_idc;
357 sps->full_range = -1;
359 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
360 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
361 sps->scaling_matrix_present = 0;
362 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
364 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
365 sps->profile_idc == 122 || sps->profile_idc == 244 ||
366 sps->profile_idc == 44 || sps->profile_idc == 83 ||
367 sps->profile_idc == 86 || sps->profile_idc == 118 ||
368 sps->profile_idc == 128 || sps->profile_idc == 144) {
369 sps->chroma_format_idc= get_ue_golomb_31(&h->gb);
370 if (sps->chroma_format_idc > 3U) {
371 av_log(h->avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
373 } else if(sps->chroma_format_idc == 3) {
374 sps->residual_color_transform_flag = get_bits1(&h->gb);
375 if(sps->residual_color_transform_flag) {
376 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
380 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
381 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
382 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
383 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
384 sps->bit_depth_luma, sps->bit_depth_chroma);
387 sps->transform_bypass = get_bits1(&h->gb);
388 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
390 sps->chroma_format_idc= 1;
391 sps->bit_depth_luma = 8;
392 sps->bit_depth_chroma = 8;
395 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
396 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
397 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
398 av_log(h->avctx, AV_LOG_ERROR,
399 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
400 log2_max_frame_num_minus4);
403 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
405 sps->poc_type= get_ue_golomb_31(&h->gb);
407 if(sps->poc_type == 0){ //FIXME #define
408 unsigned t = get_ue_golomb(&h->gb);
410 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
413 sps->log2_max_poc_lsb= t + 4;
414 } else if(sps->poc_type == 1){//FIXME #define
415 sps->delta_pic_order_always_zero_flag= get_bits1(&h->gb);
416 sps->offset_for_non_ref_pic= get_se_golomb(&h->gb);
417 sps->offset_for_top_to_bottom_field= get_se_golomb(&h->gb);
418 sps->poc_cycle_length = get_ue_golomb(&h->gb);
420 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
421 av_log(h->avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
425 for(i=0; i<sps->poc_cycle_length; i++)
426 sps->offset_for_ref_frame[i]= get_se_golomb(&h->gb);
427 }else if(sps->poc_type != 2){
428 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
432 sps->ref_frame_count= get_ue_golomb_31(&h->gb);
433 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
434 sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
435 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
436 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
439 sps->gaps_in_frame_num_allowed_flag= get_bits1(&h->gb);
440 sps->mb_width = get_ue_golomb(&h->gb) + 1;
441 sps->mb_height= get_ue_golomb(&h->gb) + 1;
442 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
443 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->avctx)){
444 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
448 sps->frame_mbs_only_flag= get_bits1(&h->gb);
449 if(!sps->frame_mbs_only_flag)
450 sps->mb_aff= get_bits1(&h->gb);
454 sps->direct_8x8_inference_flag= get_bits1(&h->gb);
456 #ifndef ALLOW_INTERLACE
458 av_log(h->avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
460 sps->crop= get_bits1(&h->gb);
462 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
463 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
464 sps->crop_left = get_ue_golomb(&h->gb);
465 sps->crop_right = get_ue_golomb(&h->gb);
466 sps->crop_top = get_ue_golomb(&h->gb);
467 sps->crop_bottom= get_ue_golomb(&h->gb);
468 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
469 av_log(h->avctx, AV_LOG_DEBUG,
470 "discarding sps cropping, "
471 "original values are l:%u r:%u t:%u b:%u\n",
480 sps->crop_bottom = 0;
482 if(sps->crop_left || sps->crop_top){
483 av_log(h->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);
485 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
486 av_log(h->avctx, AV_LOG_ERROR, "brainfart cropping not supported, cropping disabled (right: %d, bottom: %d)\n", sps->crop_right, sps->crop_bottom);
487 /* It is very unlikely that partial cropping will make anybody happy.
488 * Not cropping at all fixes for example playback of Sisvel 3D streams
489 * in applications supporting Sisvel 3D. */
502 sps->vui_parameters_present_flag= get_bits1(&h->gb);
503 if( sps->vui_parameters_present_flag )
504 if (decode_vui_parameters(h, sps) < 0)
510 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
511 static const char csp[4][5] = { "Gray", "420", "422", "444" };
512 av_log(h->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 reo:%d\n",
513 sps_id, sps->profile_idc, sps->level_idc,
515 sps->ref_frame_count,
516 sps->mb_width, sps->mb_height,
517 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
518 sps->direct_8x8_inference_flag ? "8B8" : "",
519 sps->crop_left, sps->crop_right,
520 sps->crop_top, sps->crop_bottom,
521 sps->vui_parameters_present_flag ? "VUI" : "",
522 csp[sps->chroma_format_idc],
523 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
524 sps->timing_info_present_flag ? sps->time_scale : 0,
526 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
531 av_free(h->sps_buffers[sps_id]);
532 h->sps_buffers[sps_id] = sps;
534 h->current_sps_id = sps_id;
543 build_qp_table(PPS *pps, int t, int index, const int depth)
546 const int max_qp = 51 + 6*(depth-8);
547 for(i = 0; i < max_qp+1; i++)
548 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
551 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
553 const SPS *sps = h->sps_buffers[pps->sps_id];
554 int profile_idc = sps->profile_idc;
556 if ((profile_idc == 66 || profile_idc == 77 ||
557 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
558 av_log(h->avctx, AV_LOG_VERBOSE,
559 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
566 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
567 unsigned int pps_id= get_ue_golomb(&h->gb);
569 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
572 if(pps_id >= MAX_PPS_COUNT) {
573 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
575 } else if (h->sps.bit_depth_luma > 14) {
576 av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
577 return AVERROR_INVALIDDATA;
578 } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
579 av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
580 return AVERROR_PATCHWELCOME;
583 pps= av_mallocz(sizeof(PPS));
586 pps->sps_id= get_ue_golomb_31(&h->gb);
587 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
588 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
592 pps->cabac= get_bits1(&h->gb);
593 pps->pic_order_present= get_bits1(&h->gb);
594 pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
595 if(pps->slice_group_count > 1 ){
596 pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
597 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
598 switch(pps->mb_slice_group_map_type){
601 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
602 | run_length[ i ] |1 |ue(v) |
607 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
609 | top_left_mb[ i ] |1 |ue(v) |
610 | bottom_right_mb[ i ] |1 |ue(v) |
618 | slice_group_change_direction_flag |1 |u(1) |
619 | slice_group_change_rate_minus1 |1 |ue(v) |
624 | slice_group_id_cnt_minus1 |1 |ue(v) |
625 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
627 | slice_group_id[ i ] |1 |u(v) |
632 pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
633 pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
634 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
635 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
639 pps->weighted_pred= get_bits1(&h->gb);
640 pps->weighted_bipred_idc= get_bits(&h->gb, 2);
641 pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
642 pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
643 pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
644 pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
645 pps->constrained_intra_pred= get_bits1(&h->gb);
646 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
648 pps->transform_8x8_mode= 0;
649 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
650 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
651 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
653 bits_left = bit_length - get_bits_count(&h->gb);
654 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
655 pps->transform_8x8_mode= get_bits1(&h->gb);
656 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
657 pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
659 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
662 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
663 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
664 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
665 pps->chroma_qp_diff= 1;
667 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
668 av_log(h->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",
670 pps->cabac ? "CABAC" : "CAVLC",
671 pps->slice_group_count,
672 pps->ref_count[0], pps->ref_count[1],
673 pps->weighted_pred ? "weighted" : "",
674 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
675 pps->deblocking_filter_parameters_present ? "LPAR" : "",
676 pps->constrained_intra_pred ? "CONSTR" : "",
677 pps->redundant_pic_cnt_present ? "REDU" : "",
678 pps->transform_8x8_mode ? "8x8DCT" : ""
682 av_free(h->pps_buffers[pps_id]);
683 h->pps_buffers[pps_id]= pps;