1/* 2 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder 3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> 4 * 5 * This file is part of FFmpeg. 6 * 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. 11 * 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. 16 * 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 20 */ 21 22/** 23 * @file libavcodec/h264.h 24 * H.264 / AVC / MPEG4 part10 codec. 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#ifndef AVCODEC_H264_H 29#define AVCODEC_H264_H 30 31#include "dsputil.h" 32#include "cabac.h" 33#include "mpegvideo.h" 34#include "h264pred.h" 35 36#define interlaced_dct interlaced_dct_is_a_bad_name 37#define mb_intra mb_intra_is_not_initialized_see_mb_type 38 39#define LUMA_DC_BLOCK_INDEX 25 40#define CHROMA_DC_BLOCK_INDEX 26 41 42#define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8 43#define COEFF_TOKEN_VLC_BITS 8 44#define TOTAL_ZEROS_VLC_BITS 9 45#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3 46#define RUN_VLC_BITS 3 47#define RUN7_VLC_BITS 6 48 49#define MAX_SPS_COUNT 32 50#define MAX_PPS_COUNT 256 51 52#define MAX_MMCO_COUNT 66 53 54#define MAX_DELAYED_PIC_COUNT 16 55 56/* Compiling in interlaced support reduces the speed 57 * of progressive decoding by about 2%. */ 58#define ALLOW_INTERLACE 59 60#define ALLOW_NOCHROMA 61 62/** 63 * The maximum number of slices supported by the decoder. 64 * must be a power of 2 65 */ 66#define MAX_SLICES 16 67 68#ifdef ALLOW_INTERLACE 69#define MB_MBAFF h->mb_mbaff 70#define MB_FIELD h->mb_field_decoding_flag 71#define FRAME_MBAFF h->mb_aff_frame 72#define FIELD_PICTURE (s->picture_structure != PICT_FRAME) 73#else 74#define MB_MBAFF 0 75#define MB_FIELD 0 76#define FRAME_MBAFF 0 77#define FIELD_PICTURE 0 78#undef IS_INTERLACED 79#define IS_INTERLACED(mb_type) 0 80#endif 81#define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE) 82 83#ifdef ALLOW_NOCHROMA 84#define CHROMA h->sps.chroma_format_idc 85#else 86#define CHROMA 1 87#endif 88 89#define EXTENDED_SAR 255 90 91#define MB_TYPE_REF0 MB_TYPE_ACPRED //dirty but it fits in 16 bit 92#define MB_TYPE_8x8DCT 0x01000000 93#define IS_REF0(a) ((a) & MB_TYPE_REF0) 94#define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT) 95 96/* NAL unit types */ 97enum { 98 NAL_SLICE=1, 99 NAL_DPA, 100 NAL_DPB, 101 NAL_DPC, 102 NAL_IDR_SLICE, 103 NAL_SEI, 104 NAL_SPS, 105 NAL_PPS, 106 NAL_AUD, 107 NAL_END_SEQUENCE, 108 NAL_END_STREAM, 109 NAL_FILLER_DATA, 110 NAL_SPS_EXT, 111 NAL_AUXILIARY_SLICE=19 112}; 113 114/** 115 * SEI message types 116 */ 117typedef enum { 118 SEI_BUFFERING_PERIOD = 0, ///< buffering period (H.264, D.1.1) 119 SEI_TYPE_PIC_TIMING = 1, ///< picture timing 120 SEI_TYPE_USER_DATA_UNREGISTERED = 5, ///< unregistered user data 121 SEI_TYPE_RECOVERY_POINT = 6 ///< recovery point (frame # to decoder sync) 122} SEI_Type; 123 124/** 125 * pic_struct in picture timing SEI message 126 */ 127typedef enum { 128 SEI_PIC_STRUCT_FRAME = 0, ///< 0: %frame 129 SEI_PIC_STRUCT_TOP_FIELD = 1, ///< 1: top field 130 SEI_PIC_STRUCT_BOTTOM_FIELD = 2, ///< 2: bottom field 131 SEI_PIC_STRUCT_TOP_BOTTOM = 3, ///< 3: top field, bottom field, in that order 132 SEI_PIC_STRUCT_BOTTOM_TOP = 4, ///< 4: bottom field, top field, in that order 133 SEI_PIC_STRUCT_TOP_BOTTOM_TOP = 5, ///< 5: top field, bottom field, top field repeated, in that order 134 SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///< 6: bottom field, top field, bottom field repeated, in that order 135 SEI_PIC_STRUCT_FRAME_DOUBLING = 7, ///< 7: %frame doubling 136 SEI_PIC_STRUCT_FRAME_TRIPLING = 8 ///< 8: %frame tripling 137} SEI_PicStructType; 138 139/** 140 * Sequence parameter set 141 */ 142typedef struct SPS{ 143 144 int profile_idc; 145 int level_idc; 146 int chroma_format_idc; 147 int transform_bypass; ///< qpprime_y_zero_transform_bypass_flag 148 int log2_max_frame_num; ///< log2_max_frame_num_minus4 + 4 149 int poc_type; ///< pic_order_cnt_type 150 int log2_max_poc_lsb; ///< log2_max_pic_order_cnt_lsb_minus4 151 int delta_pic_order_always_zero_flag; 152 int offset_for_non_ref_pic; 153 int offset_for_top_to_bottom_field; 154 int poc_cycle_length; ///< num_ref_frames_in_pic_order_cnt_cycle 155 int ref_frame_count; ///< num_ref_frames 156 int gaps_in_frame_num_allowed_flag; 157 int mb_width; ///< pic_width_in_mbs_minus1 + 1 158 int mb_height; ///< pic_height_in_map_units_minus1 + 1 159 int frame_mbs_only_flag; 160 int mb_aff; ///<mb_adaptive_frame_field_flag 161 int direct_8x8_inference_flag; 162 int crop; ///< frame_cropping_flag 163 unsigned int crop_left; ///< frame_cropping_rect_left_offset 164 unsigned int crop_right; ///< frame_cropping_rect_right_offset 165 unsigned int crop_top; ///< frame_cropping_rect_top_offset 166 unsigned int crop_bottom; ///< frame_cropping_rect_bottom_offset 167 int vui_parameters_present_flag; 168 AVRational sar; 169 int timing_info_present_flag; 170 uint32_t num_units_in_tick; 171 uint32_t time_scale; 172 int fixed_frame_rate_flag; 173 short offset_for_ref_frame[256]; //FIXME dyn aloc? 174 int bitstream_restriction_flag; 175 int num_reorder_frames; 176 int scaling_matrix_present; 177 uint8_t scaling_matrix4[6][16]; 178 uint8_t scaling_matrix8[2][64]; 179 int nal_hrd_parameters_present_flag; 180 int vcl_hrd_parameters_present_flag; 181 int pic_struct_present_flag; 182 int time_offset_length; 183 int cpb_cnt; ///< See H.264 E.1.2 184 int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 +1 185 int cpb_removal_delay_length; ///< cpb_removal_delay_length_minus1 + 1 186 int dpb_output_delay_length; ///< dpb_output_delay_length_minus1 + 1 187 int bit_depth_luma; ///< bit_depth_luma_minus8 + 8 188 int bit_depth_chroma; ///< bit_depth_chroma_minus8 + 8 189 int residual_color_transform_flag; ///< residual_colour_transform_flag 190}SPS; 191 192/** 193 * Picture parameter set 194 */ 195typedef struct PPS{ 196 unsigned int sps_id; 197 int cabac; ///< entropy_coding_mode_flag 198 int pic_order_present; ///< pic_order_present_flag 199 int slice_group_count; ///< num_slice_groups_minus1 + 1 200 int mb_slice_group_map_type; 201 unsigned int ref_count[2]; ///< num_ref_idx_l0/1_active_minus1 + 1 202 int weighted_pred; ///< weighted_pred_flag 203 int weighted_bipred_idc; 204 int init_qp; ///< pic_init_qp_minus26 + 26 205 int init_qs; ///< pic_init_qs_minus26 + 26 206 int chroma_qp_index_offset[2]; 207 int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag 208 int constrained_intra_pred; ///< constrained_intra_pred_flag 209 int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag 210 int transform_8x8_mode; ///< transform_8x8_mode_flag 211 uint8_t scaling_matrix4[6][16]; 212 uint8_t scaling_matrix8[2][64]; 213 uint8_t chroma_qp_table[2][64]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table 214 int chroma_qp_diff; 215}PPS; 216 217/** 218 * Memory management control operation opcode. 219 */ 220typedef enum MMCOOpcode{ 221 MMCO_END=0, 222 MMCO_SHORT2UNUSED, 223 MMCO_LONG2UNUSED, 224 MMCO_SHORT2LONG, 225 MMCO_SET_MAX_LONG, 226 MMCO_RESET, 227 MMCO_LONG, 228} MMCOOpcode; 229 230/** 231 * Memory management control operation. 232 */ 233typedef struct MMCO{ 234 MMCOOpcode opcode; 235 int short_pic_num; ///< pic_num without wrapping (pic_num & max_pic_num) 236 int long_arg; ///< index, pic_num, or num long refs depending on opcode 237} MMCO; 238 239/** 240 * H264Context 241 */ 242typedef struct H264Context{ 243 MpegEncContext s; 244 int nal_ref_idc; 245 int nal_unit_type; 246 uint8_t *rbsp_buffer[2]; 247 unsigned int rbsp_buffer_size[2]; 248 249 /** 250 * Used to parse AVC variant of h264 251 */ 252 int is_avc; ///< this flag is != 0 if codec is avc1 253 int got_avcC; ///< flag used to parse avcC data only once 254 int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4) 255 256 int chroma_qp[2]; //QPc 257 258 int prev_mb_skipped; 259 int next_mb_skipped; 260 261 //prediction stuff 262 int chroma_pred_mode; 263 int intra16x16_pred_mode; 264 265 int top_mb_xy; 266 int left_mb_xy[2]; 267 268 int8_t intra4x4_pred_mode_cache[5*8]; 269 int8_t (*intra4x4_pred_mode)[8]; 270 H264PredContext hpc; 271 unsigned int topleft_samples_available; 272 unsigned int top_samples_available; 273 unsigned int topright_samples_available; 274 unsigned int left_samples_available; 275 uint8_t (*top_borders[2])[16+2*8]; 276 uint8_t left_border[2*(17+2*9)]; 277 278 /** 279 * non zero coeff count cache. 280 * is 64 if not available. 281 */ 282 DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]); 283 uint8_t (*non_zero_count)[16]; 284 285 /** 286 * Motion vector cache. 287 */ 288 DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]); 289 DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]); 290#define LIST_NOT_USED -1 //FIXME rename? 291#define PART_NOT_AVAILABLE -2 292 293 /** 294 * is 1 if the specific list MV&references are set to 0,0,-2. 295 */ 296 int mv_cache_clean[2]; 297 298 /** 299 * number of neighbors (top and/or left) that used 8x8 dct 300 */ 301 int neighbor_transform_size; 302 303 /** 304 * block_offset[ 0..23] for frame macroblocks 305 * block_offset[24..47] for field macroblocks 306 */ 307 int block_offset[2*(16+8)]; 308 309 uint32_t *mb2b_xy; //FIXME are these 4 a good idea? 310 uint32_t *mb2b8_xy; 311 int b_stride; //FIXME use s->b4_stride 312 int b8_stride; 313 314 int mb_linesize; ///< may be equal to s->linesize or s->linesize*2, for mbaff 315 int mb_uvlinesize; 316 317 int emu_edge_width; 318 int emu_edge_height; 319 320 int halfpel_flag; 321 int thirdpel_flag; 322 323 int unknown_svq3_flag; 324 int next_slice_index; 325 326 SPS *sps_buffers[MAX_SPS_COUNT]; 327 SPS sps; ///< current sps 328 329 PPS *pps_buffers[MAX_PPS_COUNT]; 330 /** 331 * current pps 332 */ 333 PPS pps; //FIXME move to Picture perhaps? (->no) do we need that? 334 335 uint32_t dequant4_buffer[6][52][16]; 336 uint32_t dequant8_buffer[2][52][64]; 337 uint32_t (*dequant4_coeff[6])[16]; 338 uint32_t (*dequant8_coeff[2])[64]; 339 int dequant_coeff_pps; ///< reinit tables when pps changes 340 341 int slice_num; 342 uint16_t *slice_table_base; 343 uint16_t *slice_table; ///< slice_table_base + 2*mb_stride + 1 344 int slice_type; 345 int slice_type_nos; ///< S free slice type (SI/SP are remapped to I/P) 346 int slice_type_fixed; 347 348 //interlacing specific flags 349 int mb_aff_frame; 350 int mb_field_decoding_flag; 351 int mb_mbaff; ///< mb_aff_frame && mb_field_decoding_flag 352 353 DECLARE_ALIGNED_8(uint16_t, sub_mb_type[4]); 354 355 //POC stuff 356 int poc_lsb; 357 int poc_msb; 358 int delta_poc_bottom; 359 int delta_poc[2]; 360 int frame_num; 361 int prev_poc_msb; ///< poc_msb of the last reference pic for POC type 0 362 int prev_poc_lsb; ///< poc_lsb of the last reference pic for POC type 0 363 int frame_num_offset; ///< for POC type 2 364 int prev_frame_num_offset; ///< for POC type 2 365 int prev_frame_num; ///< frame_num of the last pic for POC type 1/2 366 367 /** 368 * frame_num for frames or 2*frame_num+1 for field pics. 369 */ 370 int curr_pic_num; 371 372 /** 373 * max_frame_num or 2*max_frame_num for field pics. 374 */ 375 int max_pic_num; 376 377 //Weighted pred stuff 378 int use_weight; 379 int use_weight_chroma; 380 int luma_log2_weight_denom; 381 int chroma_log2_weight_denom; 382 int luma_weight[2][48]; 383 int luma_offset[2][48]; 384 int chroma_weight[2][48][2]; 385 int chroma_offset[2][48][2]; 386 int implicit_weight[48][48]; 387 388 //deblock 389 int deblocking_filter; ///< disable_deblocking_filter_idc with 1<->0 390 int slice_alpha_c0_offset; 391 int slice_beta_offset; 392 393 int redundant_pic_count; 394 395 int direct_spatial_mv_pred; 396 int dist_scale_factor[16]; 397 int dist_scale_factor_field[2][32]; 398 int map_col_to_list0[2][16+32]; 399 int map_col_to_list0_field[2][2][16+32]; 400 401 /** 402 * num_ref_idx_l0/1_active_minus1 + 1 403 */ 404 unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode 405 unsigned int list_count; 406 Picture *short_ref[32]; 407 Picture *long_ref[32]; 408 Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture 409 Picture ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs. 410 Reordered version of default_ref_list 411 according to picture reordering in slice header */ 412 int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 413 Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size? 414 int outputed_poc; 415 416 /** 417 * memory management control operations buffer. 418 */ 419 MMCO mmco[MAX_MMCO_COUNT]; 420 int mmco_index; 421 422 int long_ref_count; ///< number of actual long term references 423 int short_ref_count; ///< number of actual short term references 424 425 //data partitioning 426 GetBitContext intra_gb; 427 GetBitContext inter_gb; 428 GetBitContext *intra_gb_ptr; 429 GetBitContext *inter_gb_ptr; 430 431 DECLARE_ALIGNED_16(DCTELEM, mb[16*24]); 432 DCTELEM mb_padding[256]; ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too large or ensure that there is some unused stuff after mb 433 434 /** 435 * Cabac 436 */ 437 CABACContext cabac; 438 uint8_t cabac_state[460]; 439 int cabac_init_idc; 440 441 /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */ 442 uint16_t *cbp_table; 443 int cbp; 444 int top_cbp; 445 int left_cbp; 446 /* chroma_pred_mode for i4x4 or i16x16, else 0 */ 447 uint8_t *chroma_pred_mode_table; 448 int last_qscale_diff; 449 int16_t (*mvd_table[2])[2]; 450 DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]); 451 uint8_t *direct_table; 452 uint8_t direct_cache[5*8]; 453 454 uint8_t zigzag_scan[16]; 455 uint8_t zigzag_scan8x8[64]; 456 uint8_t zigzag_scan8x8_cavlc[64]; 457 uint8_t field_scan[16]; 458 uint8_t field_scan8x8[64]; 459 uint8_t field_scan8x8_cavlc[64]; 460 const uint8_t *zigzag_scan_q0; 461 const uint8_t *zigzag_scan8x8_q0; 462 const uint8_t *zigzag_scan8x8_cavlc_q0; 463 const uint8_t *field_scan_q0; 464 const uint8_t *field_scan8x8_q0; 465 const uint8_t *field_scan8x8_cavlc_q0; 466 467 int x264_build; 468 469 /** 470 * @defgroup multithreading Members for slice based multithreading 471 * @{ 472 */ 473 struct H264Context *thread_context[MAX_THREADS]; 474 475 /** 476 * current slice number, used to initalize slice_num of each thread/context 477 */ 478 int current_slice; 479 480 /** 481 * Max number of threads / contexts. 482 * This is equal to AVCodecContext.thread_count unless 483 * multithreaded decoding is impossible, in which case it is 484 * reduced to 1. 485 */ 486 int max_contexts; 487 488 /** 489 * 1 if the single thread fallback warning has already been 490 * displayed, 0 otherwise. 491 */ 492 int single_decode_warning; 493 494 int last_slice_type; 495 /** @} */ 496 497 int mb_xy; 498 499 uint32_t svq3_watermark_key; 500 501 /** 502 * pic_struct in picture timing SEI message 503 */ 504 SEI_PicStructType sei_pic_struct; 505 506 /** 507 * dpb_output_delay in picture timing SEI message, see H.264 C.2.2 508 */ 509 int sei_dpb_output_delay; 510 511 /** 512 * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2 513 */ 514 int sei_cpb_removal_delay; 515 516 /** 517 * recovery_frame_cnt from SEI message 518 * 519 * Set to -1 if no recovery point SEI message found or to number of frames 520 * before playback synchronizes. Frames having recovery point are key 521 * frames. 522 */ 523 int sei_recovery_frame_cnt; 524 525 int is_complex; 526 527 int luma_weight_flag[2]; ///< 7.4.3.2 luma_weight_lX_flag 528 int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag 529 530 // Timestamp stuff 531 int sei_buffering_period_present; ///< Buffering period SEI flag 532 int initial_cpb_removal_delay[32]; ///< Initial timestamps for CPBs 533}H264Context; 534 535/** 536 * Decode SEI 537 */ 538int ff_h264_decode_sei(H264Context *h); 539 540/** 541 * Decode SPS 542 */ 543int ff_h264_decode_seq_parameter_set(H264Context *h); 544 545/** 546 * Decode PPS 547 */ 548int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length); 549 550/** 551 * Decodes a network abstraction layer unit. 552 * @param consumed is the number of bytes used as input 553 * @param length is the length of the array 554 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing? 555 * @returns decoded bytes, might be src+1 if no escapes 556 */ 557const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length); 558 559/** 560 * identifies the exact end of the bitstream 561 * @return the length of the trailing, or 0 if damaged 562 */ 563int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src); 564 565#endif /* AVCODEC_H264_H */ 566