libavcodec/h264.h

   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 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 #ifndef ENABLE_H264_ENCODER
  90 #define ENABLE_H264_ENCODER 0
  91 #endif
  92
  93 #define EXTENDED_SAR          255
  94
  95 #define MB_TYPE_REF0       MB_TYPE_ACPRED //dirty but it fits in 16 bit
  96 #define MB_TYPE_8x8DCT     0x01000000
  97 #define IS_REF0(a)         ((a) & MB_TYPE_REF0)
  98 #define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)
  99
 100 /* NAL unit types */
 101 enum {
 102     NAL_SLICE=1,
 103     NAL_DPA,
 104     NAL_DPB,
 105     NAL_DPC,
 106     NAL_IDR_SLICE,
 107     NAL_SEI,
 108     NAL_SPS,
 109     NAL_PPS,
 110     NAL_AUD,
 111     NAL_END_SEQUENCE,
 112     NAL_END_STREAM,
 113     NAL_FILLER_DATA,
 114     NAL_SPS_EXT,
 115     NAL_AUXILIARY_SLICE=19
 116 };
 117
 118 /**
 119  * pic_struct in picture timing SEI message
 120  */
 121 typedef enum {
 122     SEI_PIC_STRUCT_FRAME             = 0, ///<  0: %frame
 123     SEI_PIC_STRUCT_TOP_FIELD         = 1, ///<  1: top field
 124     SEI_PIC_STRUCT_BOTTOM_FIELD      = 2, ///<  2: bottom field
 125     SEI_PIC_STRUCT_TOP_BOTTOM        = 3, ///<  3: top field, bottom field, in that order
 126     SEI_PIC_STRUCT_BOTTOM_TOP        = 4, ///<  4: bottom field, top field, in that order
 127     SEI_PIC_STRUCT_TOP_BOTTOM_TOP    = 5, ///<  5: top field, bottom field, top field repeated, in that order
 128     SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///<  6: bottom field, top field, bottom field repeated, in that order
 129     SEI_PIC_STRUCT_FRAME_DOUBLING    = 7, ///<  7: %frame doubling
 130     SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
 131 } SEI_PicStructType;
 132
 133 /**
 134  * Sequence parameter set
 135  */
 136 typedef struct SPS{
 137
 138     int profile_idc;
 139     int level_idc;
 140     int chroma_format_idc;
 141     int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag
 142     int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
 143     int poc_type;                      ///< pic_order_cnt_type
 144     int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
 145     int delta_pic_order_always_zero_flag;
 146     int offset_for_non_ref_pic;
 147     int offset_for_top_to_bottom_field;
 148     int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
 149     int ref_frame_count;               ///< num_ref_frames
 150     int gaps_in_frame_num_allowed_flag;
 151     int mb_width;                      ///< pic_width_in_mbs_minus1 + 1
 152     int mb_height;                     ///< pic_height_in_map_units_minus1 + 1
 153     int frame_mbs_only_flag;
 154     int mb_aff;                        ///<mb_adaptive_frame_field_flag
 155     int direct_8x8_inference_flag;
 156     int crop;                   ///< frame_cropping_flag
 157     unsigned int crop_left;            ///< frame_cropping_rect_left_offset
 158     unsigned int crop_right;           ///< frame_cropping_rect_right_offset
 159     unsigned int crop_top;             ///< frame_cropping_rect_top_offset
 160     unsigned int crop_bottom;          ///< frame_cropping_rect_bottom_offset
 161     int vui_parameters_present_flag;
 162     AVRational sar;
 163     int timing_info_present_flag;
 164     uint32_t num_units_in_tick;
 165     uint32_t time_scale;
 166     int fixed_frame_rate_flag;
 167     short offset_for_ref_frame[256]; //FIXME dyn aloc?
 168     int bitstream_restriction_flag;
 169     int num_reorder_frames;
 170     int scaling_matrix_present;
 171     uint8_t scaling_matrix4[6][16];
 172     uint8_t scaling_matrix8[2][64];
 173     int nal_hrd_parameters_present_flag;
 174     int vcl_hrd_parameters_present_flag;
 175     int pic_struct_present_flag;
 176     int time_offset_length;
 177     int cpb_removal_delay_length;      ///< cpb_removal_delay_length_minus1 + 1
 178     int dpb_output_delay_length;       ///< dpb_output_delay_length_minus1 + 1
 179 }SPS;
 180
 181 /**
 182  * Picture parameter set
 183  */
 184 typedef struct PPS{
 185     unsigned int sps_id;
 186     int cabac;                  ///< entropy_coding_mode_flag
 187     int pic_order_present;      ///< pic_order_present_flag
 188     int slice_group_count;      ///< num_slice_groups_minus1 + 1
 189     int mb_slice_group_map_type;
 190     unsigned int ref_count[2];  ///< num_ref_idx_l0/1_active_minus1 + 1
 191     int weighted_pred;          ///< weighted_pred_flag
 192     int weighted_bipred_idc;
 193     int init_qp;                ///< pic_init_qp_minus26 + 26
 194     int init_qs;                ///< pic_init_qs_minus26 + 26
 195     int chroma_qp_index_offset[2];
 196     int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
 197     int constrained_intra_pred; ///< constrained_intra_pred_flag
 198     int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
 199     int transform_8x8_mode;     ///< transform_8x8_mode_flag
 200     uint8_t scaling_matrix4[6][16];
 201     uint8_t scaling_matrix8[2][64];
 202     uint8_t chroma_qp_table[2][64];  ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
 203     int chroma_qp_diff;
 204 }PPS;
 205
 206 /**
 207  * Memory management control operation opcode.
 208  */
 209 typedef enum MMCOOpcode{
 210     MMCO_END=0,
 211     MMCO_SHORT2UNUSED,
 212     MMCO_LONG2UNUSED,
 213     MMCO_SHORT2LONG,
 214     MMCO_SET_MAX_LONG,
 215     MMCO_RESET,
 216     MMCO_LONG,
 217 } MMCOOpcode;
 218
 219 /**
 220  * Memory management control operation.
 221  */
 222 typedef struct MMCO{
 223     MMCOOpcode opcode;
 224     int short_pic_num;  ///< pic_num without wrapping (pic_num & max_pic_num)
 225     int long_arg;       ///< index, pic_num, or num long refs depending on opcode
 226 } MMCO;
 227
 228 /**
 229  * H264Context
 230  */
 231 typedef struct H264Context{
 232     MpegEncContext s;
 233     int nal_ref_idc;
 234     int nal_unit_type;
 235     uint8_t *rbsp_buffer[2];
 236     unsigned int rbsp_buffer_size[2];
 237
 238     /**
 239       * Used to parse AVC variant of h264
 240       */
 241     int is_avc; ///< this flag is != 0 if codec is avc1
 242     int got_avcC; ///< flag used to parse avcC data only once
 243     int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
 244
 245     int chroma_qp[2]; //QPc
 246
 247     int prev_mb_skipped;
 248     int next_mb_skipped;
 249
 250     //prediction stuff
 251     int chroma_pred_mode;
 252     int intra16x16_pred_mode;
 253
 254     int top_mb_xy;
 255     int left_mb_xy[2];
 256
 257     int8_t intra4x4_pred_mode_cache[5*8];
 258     int8_t (*intra4x4_pred_mode)[8];
 259     H264PredContext hpc;
 260     unsigned int topleft_samples_available;
 261     unsigned int top_samples_available;
 262     unsigned int topright_samples_available;
 263     unsigned int left_samples_available;
 264     uint8_t (*top_borders[2])[16+2*8];
 265     uint8_t left_border[2*(17+2*9)];
 266
 267     /**
 268      * non zero coeff count cache.
 269      * is 64 if not available.
 270      */
 271     DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache[6*8]);
 272     uint8_t (*non_zero_count)[16];
 273
 274     /**
 275      * Motion vector cache.
 276      */
 277     DECLARE_ALIGNED_8(int16_t, mv_cache[2][5*8][2]);
 278     DECLARE_ALIGNED_8(int8_t, ref_cache[2][5*8]);
 279 #define LIST_NOT_USED -1 //FIXME rename?
 280 #define PART_NOT_AVAILABLE -2
 281
 282     /**
 283      * is 1 if the specific list MV&references are set to 0,0,-2.
 284      */
 285     int mv_cache_clean[2];
 286
 287     /**
 288      * number of neighbors (top and/or left) that used 8x8 dct
 289      */
 290     int neighbor_transform_size;
 291
 292     /**
 293      * block_offset[ 0..23] for frame macroblocks
 294      * block_offset[24..47] for field macroblocks
 295      */
 296     int block_offset[2*(16+8)];
 297
 298     uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
 299     uint32_t *mb2b8_xy;
 300     int b_stride; //FIXME use s->b4_stride
 301     int b8_stride;
 302
 303     int mb_linesize;   ///< may be equal to s->linesize or s->linesize*2, for mbaff
 304     int mb_uvlinesize;
 305
 306     int emu_edge_width;
 307     int emu_edge_height;
 308
 309     int halfpel_flag;
 310     int thirdpel_flag;
 311
 312     int unknown_svq3_flag;
 313     int next_slice_index;
 314
 315     SPS *sps_buffers[MAX_SPS_COUNT];
 316     SPS sps; ///< current sps
 317
 318     PPS *pps_buffers[MAX_PPS_COUNT];
 319     /**
 320      * current pps
 321      */
 322     PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?
 323
 324     uint32_t dequant4_buffer[6][52][16];
 325     uint32_t dequant8_buffer[2][52][64];
 326     uint32_t (*dequant4_coeff[6])[16];
 327     uint32_t (*dequant8_coeff[2])[64];
 328     int dequant_coeff_pps;     ///< reinit tables when pps changes
 329
 330     int slice_num;
 331     uint16_t *slice_table_base;
 332     uint16_t *slice_table;     ///< slice_table_base + 2*mb_stride + 1
 333     int slice_type;
 334     int slice_type_nos;        ///< S free slice type (SI/SP are remapped to I/P)
 335     int slice_type_fixed;
 336
 337     //interlacing specific flags
 338     int mb_aff_frame;
 339     int mb_field_decoding_flag;
 340     int mb_mbaff;              ///< mb_aff_frame && mb_field_decoding_flag
 341
 342     unsigned int sub_mb_type[4];
 343
 344     //POC stuff
 345     int poc_lsb;
 346     int poc_msb;
 347     int delta_poc_bottom;
 348     int delta_poc[2];
 349     int frame_num;
 350     int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0
 351     int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0
 352     int frame_num_offset;         ///< for POC type 2
 353     int prev_frame_num_offset;    ///< for POC type 2
 354     int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2
 355
 356     /**
 357      * frame_num for frames or 2*frame_num+1 for field pics.
 358      */
 359     int curr_pic_num;
 360
 361     /**
 362      * max_frame_num or 2*max_frame_num for field pics.
 363      */
 364     int max_pic_num;
 365
 366     //Weighted pred stuff
 367     int use_weight;
 368     int use_weight_chroma;
 369     int luma_log2_weight_denom;
 370     int chroma_log2_weight_denom;
 371     int luma_weight[2][48];
 372     int luma_offset[2][48];
 373     int chroma_weight[2][48][2];
 374     int chroma_offset[2][48][2];
 375     int implicit_weight[48][48];
 376
 377     //deblock
 378     int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0
 379     int slice_alpha_c0_offset;
 380     int slice_beta_offset;
 381
 382     int redundant_pic_count;
 383
 384     int direct_spatial_mv_pred;
 385     int dist_scale_factor[16];
 386     int dist_scale_factor_field[2][32];
 387     int map_col_to_list0[2][16+32];
 388     int map_col_to_list0_field[2][2][16+32];
 389
 390     /**
 391      * num_ref_idx_l0/1_active_minus1 + 1
 392      */
 393     unsigned int ref_count[2];   ///< counts frames or fields, depending on current mb mode
 394     unsigned int list_count;
 395     Picture *short_ref[32];
 396     Picture *long_ref[32];
 397     Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture
 398     Picture ref_list[2][48];         /**< 0..15: frame refs, 16..47: mbaff field refs.
 399                                           Reordered version of default_ref_list
 400                                           according to picture reordering in slice header */
 401     int ref2frm[MAX_SLICES][2][64];  ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
 402     Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size?
 403     int outputed_poc;
 404
 405     /**
 406      * memory management control operations buffer.
 407      */
 408     MMCO mmco[MAX_MMCO_COUNT];
 409     int mmco_index;
 410
 411     int long_ref_count;  ///< number of actual long term references
 412     int short_ref_count; ///< number of actual short term references
 413
 414     //data partitioning
 415     GetBitContext intra_gb;
 416     GetBitContext inter_gb;
 417     GetBitContext *intra_gb_ptr;
 418     GetBitContext *inter_gb_ptr;
 419
 420     DECLARE_ALIGNED_16(DCTELEM, mb[16*24]);
 421     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
 422
 423     /**
 424      * Cabac
 425      */
 426     CABACContext cabac;
 427     uint8_t      cabac_state[460];
 428     int          cabac_init_idc;
 429
 430     /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
 431     uint16_t     *cbp_table;
 432     int cbp;
 433     int top_cbp;
 434     int left_cbp;
 435     /* chroma_pred_mode for i4x4 or i16x16, else 0 */
 436     uint8_t     *chroma_pred_mode_table;
 437     int         last_qscale_diff;
 438     int16_t     (*mvd_table[2])[2];
 439     DECLARE_ALIGNED_8(int16_t, mvd_cache[2][5*8][2]);
 440     uint8_t     *direct_table;
 441     uint8_t     direct_cache[5*8];
 442
 443     uint8_t zigzag_scan[16];
 444     uint8_t zigzag_scan8x8[64];
 445     uint8_t zigzag_scan8x8_cavlc[64];
 446     uint8_t field_scan[16];
 447     uint8_t field_scan8x8[64];
 448     uint8_t field_scan8x8_cavlc[64];
 449     const uint8_t *zigzag_scan_q0;
 450     const uint8_t *zigzag_scan8x8_q0;
 451     const uint8_t *zigzag_scan8x8_cavlc_q0;
 452     const uint8_t *field_scan_q0;
 453     const uint8_t *field_scan8x8_q0;
 454     const uint8_t *field_scan8x8_cavlc_q0;
 455
 456     int x264_build;
 457
 458     /**
 459      * @defgroup multithreading Members for slice based multithreading
 460      * @{
 461      */
 462     struct H264Context *thread_context[MAX_THREADS];
 463
 464     /**
 465      * current slice number, used to initalize slice_num of each thread/context
 466      */
 467     int current_slice;
 468
 469     /**
 470      * Max number of threads / contexts.
 471      * This is equal to AVCodecContext.thread_count unless
 472      * multithreaded decoding is impossible, in which case it is
 473      * reduced to 1.
 474      */
 475     int max_contexts;
 476
 477     /**
 478      *  1 if the single thread fallback warning has already been
 479      *  displayed, 0 otherwise.
 480      */
 481     int single_decode_warning;
 482
 483     int last_slice_type;
 484     /** @} */
 485
 486     int mb_xy;
 487
 488     uint32_t svq3_watermark_key;
 489
 490     /**
 491      * pic_struct in picture timing SEI message
 492      */
 493     SEI_PicStructType sei_pic_struct;
 494 }H264Context;
 495
 496 #endif /* AVCODEC_H264_H */