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 #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[7][QP_MAX_NUM+1] = {
78 CHROMA_QP_TABLE_END(8)
82 CHROMA_QP_TABLE_END(9)
87 CHROMA_QP_TABLE_END(10)
93 CHROMA_QP_TABLE_END(11)
100 CHROMA_QP_TABLE_END(12)
108 CHROMA_QP_TABLE_END(13)
117 CHROMA_QP_TABLE_END(14)
121 static const uint8_t default_scaling4[2][16]={
133 static const uint8_t default_scaling8[2][64]={
134 { 6,10,13,16,18,23,25,27,
135 10,11,16,18,23,25,27,29,
136 13,16,18,23,25,27,29,31,
137 16,18,23,25,27,29,31,33,
138 18,23,25,27,29,31,33,36,
139 23,25,27,29,31,33,36,38,
140 25,27,29,31,33,36,38,40,
141 27,29,31,33,36,38,40,42
143 9,13,15,17,19,21,22,24,
144 13,13,17,19,21,22,24,25,
145 15,17,19,21,22,24,25,27,
146 17,19,21,22,24,25,27,28,
147 19,21,22,24,25,27,28,30,
148 21,22,24,25,27,28,30,32,
149 22,24,25,27,28,30,32,33,
150 24,25,27,28,30,32,33,35
153 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
154 MpegEncContext * const s = &h->s;
156 cpb_count = get_ue_golomb_31(&s->gb) + 1;
159 av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
163 get_bits(&s->gb, 4); /* bit_rate_scale */
164 get_bits(&s->gb, 4); /* cpb_size_scale */
165 for(i=0; i<cpb_count; i++){
166 get_ue_golomb_long(&s->gb); /* bit_rate_value_minus1 */
167 get_ue_golomb_long(&s->gb); /* cpb_size_value_minus1 */
168 get_bits1(&s->gb); /* cbr_flag */
170 sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
171 sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
172 sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
173 sps->time_offset_length = get_bits(&s->gb, 5);
174 sps->cpb_cnt = cpb_count;
178 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
179 MpegEncContext * const s = &h->s;
180 int aspect_ratio_info_present_flag;
181 unsigned int aspect_ratio_idc;
183 aspect_ratio_info_present_flag= get_bits1(&s->gb);
185 if( aspect_ratio_info_present_flag ) {
186 aspect_ratio_idc= get_bits(&s->gb, 8);
187 if( aspect_ratio_idc == EXTENDED_SAR ) {
188 sps->sar.num= get_bits(&s->gb, 16);
189 sps->sar.den= get_bits(&s->gb, 16);
190 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
191 sps->sar= pixel_aspect[aspect_ratio_idc];
193 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
200 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
202 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
203 get_bits1(&s->gb); /* overscan_appropriate_flag */
206 sps->video_signal_type_present_flag = get_bits1(&s->gb);
207 if(sps->video_signal_type_present_flag){
208 get_bits(&s->gb, 3); /* video_format */
209 sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
211 sps->colour_description_present_flag = get_bits1(&s->gb);
212 if(sps->colour_description_present_flag){
213 sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
214 sps->color_trc = get_bits(&s->gb, 8); /* transfer_characteristics */
215 sps->colorspace = get_bits(&s->gb, 8); /* matrix_coefficients */
216 if (sps->color_primaries >= AVCOL_PRI_NB)
217 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
218 if (sps->color_trc >= AVCOL_TRC_NB)
219 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
220 if (sps->colorspace >= AVCOL_SPC_NB)
221 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
225 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
226 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1; /* chroma_sample_location_type_top_field */
227 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
230 sps->timing_info_present_flag = get_bits1(&s->gb);
231 if(sps->timing_info_present_flag){
232 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
233 sps->time_scale = get_bits_long(&s->gb, 32);
234 if(!sps->num_units_in_tick || !sps->time_scale){
235 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);
238 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
241 sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
242 if(sps->nal_hrd_parameters_present_flag)
243 if(decode_hrd_parameters(h, sps) < 0)
245 sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
246 if(sps->vcl_hrd_parameters_present_flag)
247 if(decode_hrd_parameters(h, sps) < 0)
249 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
250 get_bits1(&s->gb); /* low_delay_hrd_flag */
251 sps->pic_struct_present_flag = get_bits1(&s->gb);
252 if(!get_bits_left(&s->gb))
254 sps->bitstream_restriction_flag = get_bits1(&s->gb);
255 if(sps->bitstream_restriction_flag){
256 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
257 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
258 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
259 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
260 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
261 sps->num_reorder_frames= get_ue_golomb(&s->gb);
262 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
264 if (get_bits_left(&s->gb) < 0) {
265 sps->num_reorder_frames=0;
266 sps->bitstream_restriction_flag= 0;
269 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
270 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
275 if (get_bits_left(&s->gb) < 0) {
276 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
277 return AVERROR_INVALIDDATA;
283 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
284 const uint8_t *jvt_list, const uint8_t *fallback_list){
285 MpegEncContext * const s = &h->s;
286 int i, last = 8, next = 8;
287 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
288 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
289 memcpy(factors, fallback_list, size*sizeof(uint8_t));
293 next = (last + get_se_golomb(&s->gb)) & 0xff;
294 if(!i && !next){ /* matrix not written, we use the preset one */
295 memcpy(factors, jvt_list, size*sizeof(uint8_t));
298 last = factors[scan[i]] = next ? next : last;
302 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
303 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
304 MpegEncContext * const s = &h->s;
305 int fallback_sps = !is_sps && sps->scaling_matrix_present;
306 const uint8_t *fallback[4] = {
307 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
308 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
309 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
310 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
312 if(get_bits1(&s->gb)){
313 sps->scaling_matrix_present |= is_sps;
314 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
315 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
316 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
317 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
318 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
319 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
320 if(is_sps || pps->transform_8x8_mode){
321 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
322 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]); // Inter, Y
323 if(sps->chroma_format_idc == 3){
324 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]); // Intra, Cr
325 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]); // Inter, Cr
326 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]); // Intra, Cb
327 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]); // Inter, Cb
333 int ff_h264_decode_seq_parameter_set(H264Context *h){
334 MpegEncContext * const s = &h->s;
335 int profile_idc, level_idc, constraint_set_flags = 0;
337 int i, log2_max_frame_num_minus4;
340 profile_idc= get_bits(&s->gb, 8);
341 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
342 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
343 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
344 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
345 constraint_set_flags |= get_bits1(&s->gb) << 4; //constraint_set4_flag
346 constraint_set_flags |= get_bits1(&s->gb) << 5; //constraint_set5_flag
347 get_bits(&s->gb, 2); // reserved
348 level_idc= get_bits(&s->gb, 8);
349 sps_id= get_ue_golomb_31(&s->gb);
351 if(sps_id >= MAX_SPS_COUNT) {
352 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
355 sps= av_mallocz(sizeof(SPS));
359 sps->time_offset_length = 24;
360 sps->profile_idc= profile_idc;
361 sps->constraint_set_flags = constraint_set_flags;
362 sps->level_idc= level_idc;
363 sps->full_range = -1;
365 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
366 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
367 sps->scaling_matrix_present = 0;
368 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
370 if(sps->profile_idc == 100 || sps->profile_idc == 110 ||
371 sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc == 44 ||
372 sps->profile_idc == 83 || sps->profile_idc == 86 || sps->profile_idc == 118 ||
373 sps->profile_idc == 128 || sps->profile_idc == 144) {
374 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
375 if (sps->chroma_format_idc > 3U) {
376 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
378 } else if(sps->chroma_format_idc == 3) {
379 sps->residual_color_transform_flag = get_bits1(&s->gb);
380 if(sps->residual_color_transform_flag) {
381 av_log(h->s.avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
385 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
386 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
387 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
388 av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
389 sps->bit_depth_luma, sps->bit_depth_chroma);
392 sps->transform_bypass = get_bits1(&s->gb);
393 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
395 sps->chroma_format_idc= 1;
396 sps->bit_depth_luma = 8;
397 sps->bit_depth_chroma = 8;
400 log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
401 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
402 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
403 av_log(h->s.avctx, AV_LOG_ERROR,
404 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
405 log2_max_frame_num_minus4);
408 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
410 sps->poc_type= get_ue_golomb_31(&s->gb);
412 if(sps->poc_type == 0){ //FIXME #define
413 unsigned t = get_ue_golomb(&s->gb);
415 av_log(h->s.avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
418 sps->log2_max_poc_lsb= t + 4;
419 } else if(sps->poc_type == 1){//FIXME #define
420 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
421 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
422 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
423 sps->poc_cycle_length = get_ue_golomb(&s->gb);
425 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
426 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
430 for(i=0; i<sps->poc_cycle_length; i++)
431 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
432 }else if(sps->poc_type != 2){
433 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
437 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
438 if (h->s.avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
439 sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
440 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
441 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
444 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
445 sps->mb_width = get_ue_golomb(&s->gb) + 1;
446 sps->mb_height= get_ue_golomb(&s->gb) + 1;
447 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
448 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
449 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
453 sps->frame_mbs_only_flag= get_bits1(&s->gb);
454 if(!sps->frame_mbs_only_flag)
455 sps->mb_aff= get_bits1(&s->gb);
459 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
461 #ifndef ALLOW_INTERLACE
463 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
465 sps->crop= get_bits1(&s->gb);
467 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
468 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
469 sps->crop_left = get_ue_golomb(&s->gb);
470 sps->crop_right = get_ue_golomb(&s->gb);
471 sps->crop_top = get_ue_golomb(&s->gb);
472 sps->crop_bottom= get_ue_golomb(&s->gb);
473 if(sps->crop_left || sps->crop_top){
474 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);
476 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
477 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);
478 /* It is very unlikely that partial cropping will make anybody happy.
479 * Not cropping at all fixes for example playback of Sisvel 3D streams
480 * in applications supporting Sisvel 3D. */
493 sps->vui_parameters_present_flag= get_bits1(&s->gb);
494 if( sps->vui_parameters_present_flag )
495 if (decode_vui_parameters(h, sps) < 0)
501 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
502 static const char csp[4][5] = { "Gray", "420", "422", "444" };
503 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 reo:%d\n",
504 sps_id, sps->profile_idc, sps->level_idc,
506 sps->ref_frame_count,
507 sps->mb_width, sps->mb_height,
508 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
509 sps->direct_8x8_inference_flag ? "8B8" : "",
510 sps->crop_left, sps->crop_right,
511 sps->crop_top, sps->crop_bottom,
512 sps->vui_parameters_present_flag ? "VUI" : "",
513 csp[sps->chroma_format_idc],
514 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
515 sps->timing_info_present_flag ? sps->time_scale : 0,
517 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
521 av_free(h->sps_buffers[sps_id]);
522 h->sps_buffers[sps_id]= sps;
531 build_qp_table(PPS *pps, int t, int index, const int depth)
534 const int max_qp = 51 + 6*(depth-8);
535 for(i = 0; i < max_qp+1; i++)
536 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
539 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
541 const SPS *sps = h->sps_buffers[pps->sps_id];
542 int profile_idc = sps->profile_idc;
544 if ((profile_idc == 66 || profile_idc == 77 ||
545 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
546 av_log(h->s.avctx, AV_LOG_VERBOSE,
547 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
554 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
555 MpegEncContext * const s = &h->s;
556 unsigned int pps_id= get_ue_golomb(&s->gb);
558 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
561 if(pps_id >= MAX_PPS_COUNT) {
562 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
564 } else if (h->sps.bit_depth_luma > 14) {
565 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
566 return AVERROR_INVALIDDATA;
567 } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
568 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
569 return AVERROR_PATCHWELCOME;
572 pps= av_mallocz(sizeof(PPS));
575 pps->sps_id= get_ue_golomb_31(&s->gb);
576 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
577 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
581 pps->cabac= get_bits1(&s->gb);
582 pps->pic_order_present= get_bits1(&s->gb);
583 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
584 if(pps->slice_group_count > 1 ){
585 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
586 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
587 switch(pps->mb_slice_group_map_type){
590 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
591 | run_length[ i ] |1 |ue(v) |
596 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
598 | top_left_mb[ i ] |1 |ue(v) |
599 | bottom_right_mb[ i ] |1 |ue(v) |
607 | slice_group_change_direction_flag |1 |u(1) |
608 | slice_group_change_rate_minus1 |1 |ue(v) |
613 | slice_group_id_cnt_minus1 |1 |ue(v) |
614 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
616 | slice_group_id[ i ] |1 |u(v) |
621 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
622 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
623 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
624 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
628 pps->weighted_pred= get_bits1(&s->gb);
629 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
630 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
631 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
632 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
633 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
634 pps->constrained_intra_pred= get_bits1(&s->gb);
635 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
637 pps->transform_8x8_mode= 0;
638 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
639 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
640 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
642 bits_left = bit_length - get_bits_count(&s->gb);
643 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
644 pps->transform_8x8_mode= get_bits1(&s->gb);
645 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
646 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
648 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
651 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
652 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
653 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
654 pps->chroma_qp_diff= 1;
656 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
657 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",
659 pps->cabac ? "CABAC" : "CAVLC",
660 pps->slice_group_count,
661 pps->ref_count[0], pps->ref_count[1],
662 pps->weighted_pred ? "weighted" : "",
663 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
664 pps->deblocking_filter_parameters_present ? "LPAR" : "",
665 pps->constrained_intra_pred ? "CONSTR" : "",
666 pps->redundant_pic_cnt_present ? "REDU" : "",
667 pps->transform_8x8_mode ? "8x8DCT" : ""
671 av_free(h->pps_buffers[pps_id]);
672 h->pps_buffers[pps_id]= pps;