h264data.h

wince 平台下的h264 压缩代码程序

/*
 * H26L/H264/AVC/JVT/14496-10/... encoder/decoder
 * Copyright (c) 2003 Michael Niedermayer <[e-mail]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/**
 * @file h264data.h
 * @brief 
 *     H264 / AVC / MPEG4 part10 codec data table
 * @author Michael Niedermayer <[e-mail]>
 */
//#include "common.h"

#define VERT_PRED             0
#define HOR_PRED              1
#define DC_PRED               2
#define DIAG_DOWN_LEFT_PRED   3
#define DIAG_DOWN_RIGHT_PRED  4
#define VERT_RIGHT_PRED       5
#define HOR_DOWN_PRED         6
#define VERT_LEFT_PRED        7
#define HOR_UP_PRED           8

#define LEFT_DC_PRED          9
#define TOP_DC_PRED           10
#define DC_128_PRED           11


#define DC_PRED8x8            0
#define HOR_PRED8x8           1
#define VERT_PRED8x8          2
#define PLANE_PRED8x8         3

#define LEFT_DC_PRED8x8       4
#define TOP_DC_PRED8x8        5
#define DC_128_PRED8x8        6

#define EXTENDED_SAR          255

//AS by ty
/*#define MAX_SPS_COUNT 32
#define MAX_PPS_COUNT 256

#define MAX_MMCO_COUNT 66

typedef struct SPS{    
    int profile_idc;
    int level_idc;
    int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
    int poc_type;                      ///< pic_order_cnt_type
    int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
    int delta_pic_order_always_zero_flag;
    int offset_for_non_ref_pic;
    int offset_for_top_to_bottom_field;
    int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
    int ref_frame_count;               ///< num_ref_frames
    int gaps_in_frame_num_allowed_flag;
    int mb_width;                      ///< frame_width_in_mbs_minus1 + 1
    int mb_height;                     ///< frame_height_in_mbs_minus1 + 1
    int frame_mbs_only_flag;
    int mb_aff;                        ///<mb_adaptive_frame_field_flag
    int direct_8x8_inference_flag;
    int crop;                   ///< frame_cropping_flag
    int crop_left;              ///< frame_cropping_rect_left_offset
    int crop_right;             ///< frame_cropping_rect_right_offset
    int crop_top;               ///< frame_cropping_rect_top_offset
    int crop_bottom;            ///< frame_cropping_rect_bottom_offset
    int vui_parameters_present_flag;
    AVRational sar;
    short offset_for_ref_frame[256]; //FIXME dyn aloc?
}SPS;

typedef struct PPS{
    int sps_id;
    int cabac;                  ///< entropy_coding_mode_flag
    int pic_order_present;      ///< pic_order_present_flag
    int slice_group_count;      ///< num_slice_groups_minus1 + 1
    int mb_slice_group_map_type;
    int ref_count[2];           ///< num_ref_idx_l0/1_active_minus1 + 1
    int weighted_pred;          ///< weighted_pred_flag
    int weighted_bipred_idc;
    int init_qp;                ///< pic_init_qp_minus26 + 26
    int init_qs;                ///< pic_init_qs_minus26 + 26
    int chroma_qp_index_offset;
    int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
    int constrained_intra_pred; ///< constrained_intra_pred_flag
    int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
}PPS;
typedef enum MMCOOpcode{
    MMCO_END=0,
    MMCO_SHORT2UNUSED,
    MMCO_LONG2UNUSED,
    MMCO_SHORT2LONG,
    MMCO_SET_MAX_LONG,
    MMCO_RESET, 
    MMCO_LONG,
} MMCOOpcode;
typedef struct MMCO{
    MMCOOpcode opcode;
    int short_frame_num;
    int long_index;
} MMCO;*/

//typedef struct H264Context{
//    MpegEncContext s;
//    int nal_ref_idc;	
//    int nal_unit_type;
//#define NAL_SLICE		1
//#define NAL_DPA			2
//#define NAL_DPB			3
//#define NAL_DPC			4
//#define NAL_IDR_SLICE		5
//#define NAL_SEI			6
//#define NAL_SPS			7
//#define NAL_PPS			8
//#define NAL_PICTURE_DELIMITER	9
//#define NAL_FILTER_DATA		10
//    uint8_t *rbsp_buffer;
//    int rbsp_buffer_size;
//    int chroma_qp; //QPc
//    int prev_mb_skiped; //FIXME remove (IMHO not used)
//    //prediction stuff
//    int chroma_pred_mode;
//    int intra16x16_pred_mode;
//    
//    int8_t intra4x4_pred_mode_cache[5*8];
//    int8_t (*intra4x4_pred_mode)[8];
//    void (*pred4x4  [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp?
//    void (*pred8x8  [4+3])(uint8_t *src, int stride);
//    void (*pred16x16[4+3])(uint8_t *src, int stride);
//    unsigned int topleft_samples_available;
//    unsigned int top_samples_available;
//    unsigned int topright_samples_available;
//    unsigned int left_samples_available;
//    uint8_t (*top_border)[16+2*8];
//    uint8_t left_border[17+2*9];
//    /**
//     * non zero coeff count cache.
//     * is 64 if not available.
//     */
//    uint8_t non_zero_count_cache[6*8];
//    uint8_t (*non_zero_count)[16];
//    /**
//     * Motion vector cache.
//     */
//    int16_t mv_cache[2][5*8][2];
//    int8_t ref_cache[2][5*8];
//#define LIST_NOT_USED -1 //FIXME rename?
//#define PART_NOT_AVAILABLE -2
//    
//    /**
//     * is 1 if the specific list MV&references are set to 0,0,-2.
//     */
//    int mv_cache_clean[2];
//    int block_offset[16+8];
//    int chroma_subblock_offset[16]; //FIXME remove
//    
//    uint16_t *mb2b_xy; //FIXME are these 4 a good idea?
//    uint16_t *mb2b8_xy;
//    int b_stride;
//    int b8_stride;
//    int halfpel_flag;
//    int thirdpel_flag;
//    int unknown_svq3_flag;
//    int next_slice_index;
//    SPS sps_buffer[MAX_SPS_COUNT];
//    SPS sps; ///< current sps
//    
//    PPS pps_buffer[MAX_PPS_COUNT];
//    /**
//     * current pps
//     */
//    PPS pps; //FIXME move tp Picture perhaps? (->no) do we need that?
//    int slice_num;
//    uint8_t *slice_table_base;
//    uint8_t *slice_table;      ///< slice_table_base + mb_stride + 1
//    int slice_type;
//    int slice_type_fixed;
//    
//    //interlacing specific flags
//    int mb_field_decoding_flag;
//    
//    int sub_mb_type[4];
//    
//    //POC stuff
//    int poc_lsb;
//    int poc_msb;
//    int delta_poc_bottom;
//    int delta_poc[2];
//    int frame_num;
//    int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0
//    int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0
//    int frame_num_offset;         ///< for POC type 2
//    int prev_frame_num_offset;    ///< for POC type 2
//    int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2
//    /**
//     * frame_num for frames or 2*frame_num for field pics.
//     */
//    int curr_pic_num;
//    
//    /**
//     * max_frame_num or 2*max_frame_num for field pics.
//     */
//    int max_pic_num;
//    //Weighted pred stuff
//    int luma_log2_weight_denom;
//    int chroma_log2_weight_denom;
//    int luma_weight[2][16];
//    int luma_offset[2][16];
//    int chroma_weight[2][16][2];
//    int chroma_offset[2][16][2];
//   
//    //deblock
//    int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0 
//    int slice_alpha_c0_offset;
//    int slice_beta_offset;
//     
//    int redundant_pic_count;
//    
//    int direct_spatial_mv_pred;
//    /**
//     * num_ref_idx_l0/1_active_minus1 + 1
//     */
//    int ref_count[2];// FIXME split for AFF
//    Picture *short_ref[16];
//    Picture *long_ref[16];
//    Picture default_ref_list[2][32];
//    Picture ref_list[2][32]; //FIXME size?
//    Picture field_ref_list[2][32]; //FIXME size?
//    
//    /**
//     * memory management control operations buffer.
//     */
//    MMCO mmco[MAX_MMCO_COUNT];
//    int mmco_index;
//    
//    int long_ref_count;  ///< number of actual long term references
//    int short_ref_count; ///< number of actual short term references
//    
//    //data partitioning
//    GetBitContext intra_gb;
//    GetBitContext inter_gb;
//    GetBitContext *intra_gb_ptr;
//    GetBitContext *inter_gb_ptr;
//    
////    DCTELEM mb[16*24] __align8;
//    DCTELEM __align8 mb[16*24] ;
//    /**
//     * Cabac
//     */
//    CABACContext cabac;
//    uint8_t      cabac_state[399];
//    int          cabac_init_idc;
//    /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
//    uint16_t     *cbp_table;
//    /* chroma_pred_mode for i4x4 or i16x16, else 0 */
//    uint8_t     *chroma_pred_mode_table;
//    int         last_qscale_diff;
//    int16_t     (*mvd_table[2])[2];
//    int16_t     mvd_cache[2][5*8][2];
//}H264Context;
//AE by ty

static const AVRational pixel_aspect[14]={
 {0, 1},
 {1, 1},
 {12, 11},
 {10, 11},
 {16, 11},
 {40, 33},
 {24, 11},
 {20, 11},
 {32, 11},
 {80, 33},
 {18, 11},
 {15, 11},
 {64, 33},
 {160,99},
};

static const uint8_t golomb_to_pict_type[5]=
{P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};

static const uint8_t pict_type_to_golomb[7]=
{-1, 2, 0, 1, -1, 4, 3};

static const uint8_t chroma_qp[52]={
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,
   12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
   28,29,29,30,31,32,32,33,34,34,35,35,36,36,37,37,
   37,38,38,38,39,39,39,39

};

static const uint8_t golomb_to_intra4x4_cbp[48]={
 47, 31, 15,  0, 23, 27, 29, 30,  7, 11, 13, 14, 39, 43, 45, 46,
 16,  3,  5, 10, 12, 19, 21, 26, 28, 35, 37, 42, 44,  1,  2,  4,
  8, 17, 18, 20, 24,  6,  9, 22, 25, 32, 33, 34, 36, 40, 38, 41
};
 
static const uint8_t golomb_to_inter_cbp[48]={
  0, 16,  1,  2,  4,  8, 32,  3,  5, 10, 12, 15, 47,  7, 11, 13,
 14,  6,  9, 31, 35, 37, 42, 44, 33, 34, 36, 40, 39, 43, 45, 46,
 17, 18, 20, 24, 19, 21, 26, 28, 23, 27, 29, 30, 22, 25, 38, 41