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[3][QP_MAX_MAX+1] = {
75 CHROMA_QP_TABLE_END(8)
79 CHROMA_QP_TABLE_END(9)
84 CHROMA_QP_TABLE_END(10)
88 static const uint8_t default_scaling4[2][16]={
100 static const uint8_t default_scaling8[2][64]={
101 { 6,10,13,16,18,23,25,27,
102 10,11,16,18,23,25,27,29,
103 13,16,18,23,25,27,29,31,
104 16,18,23,25,27,29,31,33,
105 18,23,25,27,29,31,33,36,
106 23,25,27,29,31,33,36,38,
107 25,27,29,31,33,36,38,40,
108 27,29,31,33,36,38,40,42
110 9,13,15,17,19,21,22,24,
111 13,13,17,19,21,22,24,25,
112 15,17,19,21,22,24,25,27,
113 17,19,21,22,24,25,27,28,
114 19,21,22,24,25,27,28,30,
115 21,22,24,25,27,28,30,32,
116 22,24,25,27,28,30,32,33,
117 24,25,27,28,30,32,33,35
120 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
121 MpegEncContext * const s = &h->s;
123 cpb_count = get_ue_golomb_31(&s->gb) + 1;
126 av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
130 get_bits(&s->gb, 4); /* bit_rate_scale */
131 get_bits(&s->gb, 4); /* cpb_size_scale */
132 for(i=0; i<cpb_count; i++){
133 get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
134 get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
135 get_bits1(&s->gb); /* cbr_flag */
137 sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
138 sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
139 sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
140 sps->time_offset_length = get_bits(&s->gb, 5);
141 sps->cpb_cnt = cpb_count;
145 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
146 MpegEncContext * const s = &h->s;
147 int aspect_ratio_info_present_flag;
148 unsigned int aspect_ratio_idc;
150 aspect_ratio_info_present_flag= get_bits1(&s->gb);
152 if( aspect_ratio_info_present_flag ) {
153 aspect_ratio_idc= get_bits(&s->gb, 8);
154 if( aspect_ratio_idc == EXTENDED_SAR ) {
155 sps->sar.num= get_bits(&s->gb, 16);
156 sps->sar.den= get_bits(&s->gb, 16);
157 }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
158 sps->sar= pixel_aspect[aspect_ratio_idc];
160 av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
167 // s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
169 if(get_bits1(&s->gb)){ /* overscan_info_present_flag */
170 get_bits1(&s->gb); /* overscan_appropriate_flag */
173 sps->video_signal_type_present_flag = get_bits1(&s->gb);
174 if(sps->video_signal_type_present_flag){
175 get_bits(&s->gb, 3); /* video_format */
176 sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
178 sps->colour_description_present_flag = get_bits1(&s->gb);
179 if(sps->colour_description_present_flag){
180 sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
181 sps->color_trc = get_bits(&s->gb, 8); /* transfer_characteristics */
182 sps->colorspace = get_bits(&s->gb, 8); /* matrix_coefficients */
183 if (sps->color_primaries >= AVCOL_PRI_NB)
184 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
185 if (sps->color_trc >= AVCOL_TRC_NB)
186 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
187 if (sps->colorspace >= AVCOL_SPC_NB)
188 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
192 if(get_bits1(&s->gb)){ /* chroma_location_info_present_flag */
193 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1; /* chroma_sample_location_type_top_field */
194 get_ue_golomb(&s->gb); /* chroma_sample_location_type_bottom_field */
197 sps->timing_info_present_flag = get_bits1(&s->gb);
198 if(sps->timing_info_present_flag){
199 sps->num_units_in_tick = get_bits_long(&s->gb, 32);
200 sps->time_scale = get_bits_long(&s->gb, 32);
201 if(!sps->num_units_in_tick || !sps->time_scale){
202 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);
205 sps->fixed_frame_rate_flag = get_bits1(&s->gb);
208 sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
209 if(sps->nal_hrd_parameters_present_flag)
210 if(decode_hrd_parameters(h, sps) < 0)
212 sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
213 if(sps->vcl_hrd_parameters_present_flag)
214 if(decode_hrd_parameters(h, sps) < 0)
216 if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
217 get_bits1(&s->gb); /* low_delay_hrd_flag */
218 sps->pic_struct_present_flag = get_bits1(&s->gb);
220 sps->bitstream_restriction_flag = get_bits1(&s->gb);
221 if(sps->bitstream_restriction_flag){
222 get_bits1(&s->gb); /* motion_vectors_over_pic_boundaries_flag */
223 get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
224 get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
225 get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
226 get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
227 sps->num_reorder_frames= get_ue_golomb(&s->gb);
228 get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
230 if(s->gb.size_in_bits < get_bits_count(&s->gb)){
231 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
232 sps->num_reorder_frames=0;
233 sps->bitstream_restriction_flag= 0;
236 if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
237 av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
245 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
246 const uint8_t *jvt_list, const uint8_t *fallback_list){
247 MpegEncContext * const s = &h->s;
248 int i, last = 8, next = 8;
249 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
250 if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
251 memcpy(factors, fallback_list, size*sizeof(uint8_t));
255 next = (last + get_se_golomb(&s->gb)) & 0xff;
256 if(!i && !next){ /* matrix not written, we use the preset one */
257 memcpy(factors, jvt_list, size*sizeof(uint8_t));
260 last = factors[scan[i]] = next ? next : last;
264 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
265 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
266 MpegEncContext * const s = &h->s;
267 int fallback_sps = !is_sps && sps->scaling_matrix_present;
268 const uint8_t *fallback[4] = {
269 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
270 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
271 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
272 fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]
274 if(get_bits1(&s->gb)){
275 sps->scaling_matrix_present |= is_sps;
276 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
277 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
278 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
279 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
280 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
281 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
282 if(is_sps || pps->transform_8x8_mode){
283 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]); // Intra, Y
284 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]); // Inter, Y
289 int ff_h264_decode_seq_parameter_set(H264Context *h){
290 MpegEncContext * const s = &h->s;
291 int profile_idc, level_idc, constraint_set_flags = 0;
296 profile_idc= get_bits(&s->gb, 8);
297 constraint_set_flags |= get_bits1(&s->gb) << 0; //constraint_set0_flag
298 constraint_set_flags |= get_bits1(&s->gb) << 1; //constraint_set1_flag
299 constraint_set_flags |= get_bits1(&s->gb) << 2; //constraint_set2_flag
300 constraint_set_flags |= get_bits1(&s->gb) << 3; //constraint_set3_flag
301 get_bits(&s->gb, 4); // reserved
302 level_idc= get_bits(&s->gb, 8);
303 sps_id= get_ue_golomb_31(&s->gb);
305 if(sps_id >= MAX_SPS_COUNT) {
306 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
309 sps= av_mallocz(sizeof(SPS));
313 sps->time_offset_length = 24;
314 sps->profile_idc= profile_idc;
315 sps->constraint_set_flags = constraint_set_flags;
316 sps->level_idc= level_idc;
318 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
319 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
320 sps->scaling_matrix_present = 0;
322 if(sps->profile_idc >= 100){ //high profile
323 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
324 if(sps->chroma_format_idc == 3)
325 sps->residual_color_transform_flag = get_bits1(&s->gb);
326 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
327 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
328 sps->transform_bypass = get_bits1(&s->gb);
329 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
331 sps->chroma_format_idc= 1;
332 sps->bit_depth_luma = 8;
333 sps->bit_depth_chroma = 8;
336 sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
337 sps->poc_type= get_ue_golomb_31(&s->gb);
339 if(sps->poc_type == 0){ //FIXME #define
340 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
341 } else if(sps->poc_type == 1){//FIXME #define
342 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
343 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
344 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
345 sps->poc_cycle_length = get_ue_golomb(&s->gb);
347 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
348 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
352 for(i=0; i<sps->poc_cycle_length; i++)
353 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
354 }else if(sps->poc_type != 2){
355 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
359 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
360 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
361 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
364 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
365 sps->mb_width = get_ue_golomb(&s->gb) + 1;
366 sps->mb_height= get_ue_golomb(&s->gb) + 1;
367 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
368 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
369 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
373 sps->frame_mbs_only_flag= get_bits1(&s->gb);
374 if(!sps->frame_mbs_only_flag)
375 sps->mb_aff= get_bits1(&s->gb);
379 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
380 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
381 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
385 #ifndef ALLOW_INTERLACE
387 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
389 sps->crop= get_bits1(&s->gb);
391 sps->crop_left = get_ue_golomb(&s->gb);
392 sps->crop_right = get_ue_golomb(&s->gb);
393 sps->crop_top = get_ue_golomb(&s->gb);
394 sps->crop_bottom= get_ue_golomb(&s->gb);
395 if(sps->crop_left || sps->crop_top){
396 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
398 if(sps->crop_right >= 8 || sps->crop_bottom >= 8){
399 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
408 sps->vui_parameters_present_flag= get_bits1(&s->gb);
409 if( sps->vui_parameters_present_flag )
410 if (decode_vui_parameters(h, sps) < 0)
416 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
417 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",
418 sps_id, sps->profile_idc, sps->level_idc,
420 sps->ref_frame_count,
421 sps->mb_width, sps->mb_height,
422 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
423 sps->direct_8x8_inference_flag ? "8B8" : "",
424 sps->crop_left, sps->crop_right,
425 sps->crop_top, sps->crop_bottom,
426 sps->vui_parameters_present_flag ? "VUI" : "",
427 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
428 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
429 sps->timing_info_present_flag ? sps->time_scale : 0,
434 av_free(h->sps_buffers[sps_id]);
435 h->sps_buffers[sps_id]= sps;
444 build_qp_table(PPS *pps, int t, int index, const int depth)
447 const int max_qp = 51 + 6*(depth-8);
448 for(i = 0; i < max_qp+1; i++)
449 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
452 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
453 MpegEncContext * const s = &h->s;
454 unsigned int pps_id= get_ue_golomb(&s->gb);
456 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
458 if(pps_id >= MAX_PPS_COUNT) {
459 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
463 pps= av_mallocz(sizeof(PPS));
466 pps->sps_id= get_ue_golomb_31(&s->gb);
467 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
468 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
472 pps->cabac= get_bits1(&s->gb);
473 pps->pic_order_present= get_bits1(&s->gb);
474 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
475 if(pps->slice_group_count > 1 ){
476 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
477 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
478 switch(pps->mb_slice_group_map_type){
481 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
482 | run_length[ i ] |1 |ue(v) |
487 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
489 | top_left_mb[ i ] |1 |ue(v) |
490 | bottom_right_mb[ i ] |1 |ue(v) |
498 | slice_group_change_direction_flag |1 |u(1) |
499 | slice_group_change_rate_minus1 |1 |ue(v) |
504 | slice_group_id_cnt_minus1 |1 |ue(v) |
505 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
507 | slice_group_id[ i ] |1 |u(v) |
512 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
513 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
514 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
515 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
519 pps->weighted_pred= get_bits1(&s->gb);
520 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
521 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
522 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
523 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
524 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
525 pps->constrained_intra_pred= get_bits1(&s->gb);
526 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
528 pps->transform_8x8_mode= 0;
529 h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
530 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
531 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
533 if(get_bits_count(&s->gb) < bit_length){
534 pps->transform_8x8_mode= get_bits1(&s->gb);
535 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
536 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
538 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
541 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
542 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
543 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
544 pps->chroma_qp_diff= 1;
546 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
547 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",
549 pps->cabac ? "CABAC" : "CAVLC",
550 pps->slice_group_count,
551 pps->ref_count[0], pps->ref_count[1],
552 pps->weighted_pred ? "weighted" : "",
553 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
554 pps->deblocking_filter_parameters_present ? "LPAR" : "",
555 pps->constrained_intra_pred ? "CONSTR" : "",
556 pps->redundant_pic_cnt_present ? "REDU" : "",
557 pps->transform_8x8_mode ? "8x8DCT" : ""
561 av_free(h->pps_buffers[pps_id]);
562 h->pps_buffers[pps_id]= pps;