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 ||
372 sps->profile_idc == 44 || sps->profile_idc == 83 ||
373 sps->profile_idc == 86 || sps->profile_idc == 118 ||
374 sps->profile_idc == 128 || sps->profile_idc == 144) {
375 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
376 if (sps->chroma_format_idc > 3U) {
377 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
379 } else if(sps->chroma_format_idc == 3) {
380 sps->residual_color_transform_flag = get_bits1(&s->gb);
381 if(sps->residual_color_transform_flag) {
382 av_log(h->s.avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
386 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
387 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
388 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
389 av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
390 sps->bit_depth_luma, sps->bit_depth_chroma);
393 sps->transform_bypass = get_bits1(&s->gb);
394 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
396 sps->chroma_format_idc= 1;
397 sps->bit_depth_luma = 8;
398 sps->bit_depth_chroma = 8;
401 log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
402 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
403 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
404 av_log(h->s.avctx, AV_LOG_ERROR,
405 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
406 log2_max_frame_num_minus4);
409 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
411 sps->poc_type= get_ue_golomb_31(&s->gb);
413 if(sps->poc_type == 0){ //FIXME #define
414 unsigned t = get_ue_golomb(&s->gb);
416 av_log(h->s.avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
419 sps->log2_max_poc_lsb= t + 4;
420 } else if(sps->poc_type == 1){//FIXME #define
421 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
422 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
423 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
424 sps->poc_cycle_length = get_ue_golomb(&s->gb);
426 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
427 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
431 for(i=0; i<sps->poc_cycle_length; i++)
432 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
433 }else if(sps->poc_type != 2){
434 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
438 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
439 if (h->s.avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
440 sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
441 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
442 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
445 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
446 sps->mb_width = get_ue_golomb(&s->gb) + 1;
447 sps->mb_height= get_ue_golomb(&s->gb) + 1;
448 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
449 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
450 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
454 sps->frame_mbs_only_flag= get_bits1(&s->gb);
455 if(!sps->frame_mbs_only_flag)
456 sps->mb_aff= get_bits1(&s->gb);
460 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
462 #ifndef ALLOW_INTERLACE
464 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
466 sps->crop= get_bits1(&s->gb);
468 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
469 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
470 sps->crop_left = get_ue_golomb(&s->gb);
471 sps->crop_right = get_ue_golomb(&s->gb);
472 sps->crop_top = get_ue_golomb(&s->gb);
473 sps->crop_bottom= get_ue_golomb(&s->gb);
474 if(sps->crop_left || sps->crop_top){
475 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);
477 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
478 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);
479 /* It is very unlikely that partial cropping will make anybody happy.
480 * Not cropping at all fixes for example playback of Sisvel 3D streams
481 * in applications supporting Sisvel 3D. */
494 sps->vui_parameters_present_flag= get_bits1(&s->gb);
495 if( sps->vui_parameters_present_flag )
496 if (decode_vui_parameters(h, sps) < 0)
502 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
503 static const char csp[4][5] = { "Gray", "420", "422", "444" };
504 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",
505 sps_id, sps->profile_idc, sps->level_idc,
507 sps->ref_frame_count,
508 sps->mb_width, sps->mb_height,
509 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
510 sps->direct_8x8_inference_flag ? "8B8" : "",
511 sps->crop_left, sps->crop_right,
512 sps->crop_top, sps->crop_bottom,
513 sps->vui_parameters_present_flag ? "VUI" : "",
514 csp[sps->chroma_format_idc],
515 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
516 sps->timing_info_present_flag ? sps->time_scale : 0,
518 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
523 av_free(h->sps_buffers[sps_id]);
524 h->sps_buffers[sps_id] = sps;
526 h->current_sps_id = sps_id;
535 build_qp_table(PPS *pps, int t, int index, const int depth)
538 const int max_qp = 51 + 6*(depth-8);
539 for(i = 0; i < max_qp+1; i++)
540 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
543 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
545 const SPS *sps = h->sps_buffers[pps->sps_id];
546 int profile_idc = sps->profile_idc;
548 if ((profile_idc == 66 || profile_idc == 77 ||
549 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
550 av_log(h->s.avctx, AV_LOG_VERBOSE,
551 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
558 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
559 MpegEncContext * const s = &h->s;
560 unsigned int pps_id= get_ue_golomb(&s->gb);
562 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
565 if(pps_id >= MAX_PPS_COUNT) {
566 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
568 } else if (h->sps.bit_depth_luma > 14) {
569 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
570 return AVERROR_INVALIDDATA;
571 } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
572 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
573 return AVERROR_PATCHWELCOME;
576 pps= av_mallocz(sizeof(PPS));
579 pps->sps_id= get_ue_golomb_31(&s->gb);
580 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
581 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
585 pps->cabac= get_bits1(&s->gb);
586 pps->pic_order_present= get_bits1(&s->gb);
587 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
588 if(pps->slice_group_count > 1 ){
589 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
590 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
591 switch(pps->mb_slice_group_map_type){
594 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
595 | run_length[ i ] |1 |ue(v) |
600 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
602 | top_left_mb[ i ] |1 |ue(v) |
603 | bottom_right_mb[ i ] |1 |ue(v) |
611 | slice_group_change_direction_flag |1 |u(1) |
612 | slice_group_change_rate_minus1 |1 |ue(v) |
617 | slice_group_id_cnt_minus1 |1 |ue(v) |
618 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
620 | slice_group_id[ i ] |1 |u(v) |
625 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
626 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
627 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
628 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
632 pps->weighted_pred= get_bits1(&s->gb);
633 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
634 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
635 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
636 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
637 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
638 pps->constrained_intra_pred= get_bits1(&s->gb);
639 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
641 pps->transform_8x8_mode= 0;
642 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
643 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
644 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
646 bits_left = bit_length - get_bits_count(&s->gb);
647 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
648 pps->transform_8x8_mode= get_bits1(&s->gb);
649 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
650 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
652 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
655 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
656 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
657 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
658 pps->chroma_qp_diff= 1;
660 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
661 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",
663 pps->cabac ? "CABAC" : "CAVLC",
664 pps->slice_group_count,
665 pps->ref_count[0], pps->ref_count[1],
666 pps->weighted_pred ? "weighted" : "",
667 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
668 pps->deblocking_filter_parameters_present ? "LPAR" : "",
669 pps->constrained_intra_pred ? "CONSTR" : "",
670 pps->redundant_pic_cnt_present ? "REDU" : "",
671 pps->transform_8x8_mode ? "8x8DCT" : ""
675 av_free(h->pps_buffers[pps_id]);
676 h->pps_buffers[pps_id]= pps;