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_left = get_ue_golomb(&h->gb);
463 int crop_right = get_ue_golomb(&h->gb);
464 int crop_top = get_ue_golomb(&h->gb);
465 int crop_bottom = get_ue_golomb(&h->gb);
466 int width = 16 * sps->mb_width;
467 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
469 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
470 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
471 "values are l:%u r:%u t:%u b:%u\n", crop_left, crop_right,
472 crop_top, crop_bottom);
477 sps->crop_bottom = 0;
479 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
480 int hsub = (sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2) ? 1 : 0;
481 int step_x = 1 << hsub;
482 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
484 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
485 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
486 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
487 av_log(h->avctx, AV_LOG_WARNING, "Reducing left cropping to %d "
488 "chroma samples to preserve alignment.\n",
492 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
493 crop_right > (unsigned)INT_MAX / 4 / step_x ||
494 crop_top > (unsigned)INT_MAX / 4 / step_y ||
495 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
496 (crop_left + crop_right ) * step_x >= width ||
497 (crop_top + crop_bottom) * step_y >= height
499 av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
503 sps->crop_left = crop_left * step_x;
504 sps->crop_right = crop_right * step_x;
505 sps->crop_top = crop_top * step_y;
506 sps->crop_bottom = crop_bottom * step_y;
516 sps->vui_parameters_present_flag= get_bits1(&h->gb);
517 if( sps->vui_parameters_present_flag )
518 if (decode_vui_parameters(h, sps) < 0)
524 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
525 static const char csp[4][5] = { "Gray", "420", "422", "444" };
526 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",
527 sps_id, sps->profile_idc, sps->level_idc,
529 sps->ref_frame_count,
530 sps->mb_width, sps->mb_height,
531 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
532 sps->direct_8x8_inference_flag ? "8B8" : "",
533 sps->crop_left, sps->crop_right,
534 sps->crop_top, sps->crop_bottom,
535 sps->vui_parameters_present_flag ? "VUI" : "",
536 csp[sps->chroma_format_idc],
537 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
538 sps->timing_info_present_flag ? sps->time_scale : 0,
540 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
545 av_free(h->sps_buffers[sps_id]);
546 h->sps_buffers[sps_id] = sps;
555 build_qp_table(PPS *pps, int t, int index, const int depth)
558 const int max_qp = 51 + 6*(depth-8);
559 for(i = 0; i < max_qp+1; i++)
560 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
563 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
565 const SPS *sps = h->sps_buffers[pps->sps_id];
566 int profile_idc = sps->profile_idc;
568 if ((profile_idc == 66 || profile_idc == 77 ||
569 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
570 av_log(h->avctx, AV_LOG_VERBOSE,
571 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
578 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
579 unsigned int pps_id= get_ue_golomb(&h->gb);
585 if(pps_id >= MAX_PPS_COUNT) {
586 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
587 return AVERROR_INVALIDDATA;
590 pps= av_mallocz(sizeof(PPS));
593 pps->sps_id= get_ue_golomb_31(&h->gb);
594 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
595 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
598 sps = h->sps_buffers[pps->sps_id];
599 qp_bd_offset = 6*(sps->bit_depth_luma-8);
600 if (sps->bit_depth_luma > 14) {
601 av_log(h->avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", sps->bit_depth_luma);
602 return AVERROR_INVALIDDATA;
603 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
604 av_log(h->avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", sps->bit_depth_luma);
605 return AVERROR_PATCHWELCOME;
608 pps->cabac= get_bits1(&h->gb);
609 pps->pic_order_present= get_bits1(&h->gb);
610 pps->slice_group_count= get_ue_golomb(&h->gb) + 1;
611 if(pps->slice_group_count > 1 ){
612 pps->mb_slice_group_map_type= get_ue_golomb(&h->gb);
613 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
614 switch(pps->mb_slice_group_map_type){
617 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
618 | run_length[ i ] |1 |ue(v) |
623 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
625 | top_left_mb[ i ] |1 |ue(v) |
626 | bottom_right_mb[ i ] |1 |ue(v) |
634 | slice_group_change_direction_flag |1 |u(1) |
635 | slice_group_change_rate_minus1 |1 |ue(v) |
640 | slice_group_id_cnt_minus1 |1 |ue(v) |
641 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
643 | slice_group_id[ i ] |1 |u(v) |
648 pps->ref_count[0]= get_ue_golomb(&h->gb) + 1;
649 pps->ref_count[1]= get_ue_golomb(&h->gb) + 1;
650 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
651 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
655 pps->weighted_pred= get_bits1(&h->gb);
656 pps->weighted_bipred_idc= get_bits(&h->gb, 2);
657 pps->init_qp= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
658 pps->init_qs= get_se_golomb(&h->gb) + 26 + qp_bd_offset;
659 pps->chroma_qp_index_offset[0]= get_se_golomb(&h->gb);
660 pps->deblocking_filter_parameters_present= get_bits1(&h->gb);
661 pps->constrained_intra_pred= get_bits1(&h->gb);
662 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
664 pps->transform_8x8_mode= 0;
665 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
666 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
667 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
669 bits_left = bit_length - get_bits_count(&h->gb);
670 if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
671 pps->transform_8x8_mode= get_bits1(&h->gb);
672 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
673 pps->chroma_qp_index_offset[1]= get_se_golomb(&h->gb); //second_chroma_qp_index_offset
675 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
678 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
679 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
680 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
681 pps->chroma_qp_diff= 1;
683 if(h->avctx->debug&FF_DEBUG_PICT_INFO){
684 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",
686 pps->cabac ? "CABAC" : "CAVLC",
687 pps->slice_group_count,
688 pps->ref_count[0], pps->ref_count[1],
689 pps->weighted_pred ? "weighted" : "",
690 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
691 pps->deblocking_filter_parameters_present ? "LPAR" : "",
692 pps->constrained_intra_pred ? "CONSTR" : "",
693 pps->redundant_pic_cnt_present ? "REDU" : "",
694 pps->transform_8x8_mode ? "8x8DCT" : ""
698 av_free(h->pps_buffers[pps_id]);
699 h->pps_buffers[pps_id]= pps;