xref: /frameworks/base/media/libstagefright/codecs/avc/common/include/avcint_common.h

/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/**
This file contains common code shared between AVC decoder and AVC encoder for
internal use only.
@publishedAll
*/

#ifndef AVCINT_COMMON_H_INCLUDED
#define AVCINT_COMMON_H_INCLUDED

#ifndef AVCAPI_COMMON_H_INCLUDED
#include "avcapi_common.h"
#endif


#ifndef TRUE
#define TRUE  1
#define FALSE 0
#endif



/**
Mathematic functions defined in subclause 5.7.
Can be replaced with assembly instructions for speedup.
@publishedAll
*/
#define AVC_ABS(x)   (((x)<0)? -(x) : (x))
#define AVC_SIGN(x)  (((x)<0)? -1 : 1)
#define AVC_SIGN0(x) (((x)<0)? -1 : (((x)>0) ? 1 : 0))
#define AVC_MAX(x,y) ((x)>(y)? (x):(y))
#define AVC_MIN(x,y) ((x)<(y)? (x):(y))
#define AVC_MEDIAN(A,B,C) ((A) > (B) ? ((A) < (C) ? (A) : (B) > (C) ? (B) : (C)): (B) < (C) ? (B) : (C) > (A) ? (C) : (A))
#define AVC_CLIP3(a,b,x) (AVC_MAX(a,AVC_MIN(x,b)))  /* clip x between a and b */
#define AVC_CLIP(x)  AVC_CLIP3(0,255,x)
#define AVC_FLOOR(x) ((int)(x))
#define AVC_RASTER_SCAN(x,y,n)  ((x)+(y)*(n))
#define AVC_ROUND(x) (AVC_SIGN(x)*AVC_FLOOR(AVC_ABS(x)+0.5))
#define AVC_INVERSE_RASTER_SCAN(a,b,c,d,e) (((e)==0)? (((a)%((d)/(b)))*(b)): (((a)/((d)/(b)))*(c)))
/* a:block address, b:block width, c:block height, d:total_width, e:x or y coordinate */

#define DEFAULT_ATTR  0  /* default memory attribute  */
#define FAST_MEM_ATTR 1  /* fast memory attribute */


/* This section is for definition of constants. */
#define MB_SIZE 16
#define BLOCK_SIZE 4
#define EMULATION_PREVENTION_THREE_BYTE 0x3
#define NUM_PIXELS_IN_MB  (24*16)
#define NUM_BLKS_IN_MB 24

#define AVCNumI4PredMode  9
#define AVCNumI16PredMode  4
#define AVCNumIChromaMode  4

/* constants used in the structures below */
#define MAXIMUMVALUEOFcpb_cnt   32  /* used in HRDParams */
#define MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE 255   /* used in SeqParamSet */
#define MAX_NUM_SLICE_GROUP  8      /* used in PicParamSet */
#define MAX_REF_PIC_LIST_REORDERING 32  /* 32 is maximum according to Annex A, SliceHeader */
#define MAX_DEC_REF_PIC_MARKING 64   /* 64 is the maximum possible given the max num ref pictures to 31. */
#define MAX_FS (16+1)  /* pre-defined size of frame store array */
#define MAX_LEVEL_IDX  15  /* only 15 levels defined for now */
#define MAX_REF_PIC_LIST 33 /* max size of the RefPicList0 and RefPicList1 */


/**
Architectural related macros.
@publishedAll
*/
#ifdef USE_PRED_BLOCK
#define MB_BASED_DEBLOCK
#endif

/**
Picture type, PV created.
@publishedAll
*/
typedef enum
{
    AVC_FRAME = 3
} AVCPictureType;

/**
This slice type follows Table 7-3. The bottom 5 items may not needed.
@publishedAll
*/
typedef enum
{
    AVC_P_SLICE = 0,
    AVC_B_SLICE = 1,
    AVC_I_SLICE = 2,
    AVC_SP_SLICE = 3,
    AVC_SI_SLICE = 4,
    AVC_P_ALL_SLICE = 5,
    AVC_B_ALL_SLICE = 6,
    AVC_I_ALL_SLICE = 7,
    AVC_SP_ALL_SLICE = 8,
    AVC_SI_ALL_SLICE = 9
} AVCSliceType;

/**
Types of the macroblock and partition. PV Created.
@publishedAll
*/
typedef enum
{
    /* intra */
    AVC_I4,
    AVC_I16,
    AVC_I_PCM,
    AVC_SI4,

    /* inter for both P and B*/
    AVC_BDirect16,
    AVC_P16,
    AVC_P16x8,
    AVC_P8x16,
    AVC_P8,
    AVC_P8ref0,
    AVC_SKIP
} AVCMBMode;

/**
Enumeration for sub-macroblock mode, interpreted from sub_mb_type.
@publishedAll
*/
typedef enum
{
    /* for sub-partition mode */
    AVC_BDirect8,
    AVC_8x8,
    AVC_8x4,
    AVC_4x8,
    AVC_4x4
} AVCSubMBMode;

/**
Mode of prediction of partition or sub-partition. PV Created.
Do not change the order!!! Used in table look-up mode prediction in
vlc.c.
@publishedAll
*/
typedef enum
{
    AVC_Pred_L0 = 0,
    AVC_Pred_L1,
    AVC_BiPred,
    AVC_Direct
} AVCPredMode;


/**
Mode of intra 4x4 prediction. Table 8-2
@publishedAll
*/
typedef enum
{
    AVC_I4_Vertical = 0,
    AVC_I4_Horizontal,
    AVC_I4_DC,
    AVC_I4_Diagonal_Down_Left,
    AVC_I4_Diagonal_Down_Right,
    AVC_I4_Vertical_Right,
    AVC_I4_Horizontal_Down,
    AVC_I4_Vertical_Left,
    AVC_I4_Horizontal_Up
} AVCIntra4x4PredMode;

/**
Mode of intra 16x16 prediction. Table 8-3
@publishedAll
*/
typedef enum
{
    AVC_I16_Vertical = 0,
    AVC_I16_Horizontal,
    AVC_I16_DC,
    AVC_I16_Plane
} AVCIntra16x16PredMode;


/**
Mode of intra chroma prediction. Table 8-4
@publishedAll
*/
typedef enum
{
    AVC_IC_DC = 0,
    AVC_IC_Horizontal,
    AVC_IC_Vertical,
    AVC_IC_Plane
} AVCIntraChromaPredMode;

/**
Type of residual going to residual_block_cavlc function, PV created.
@publishedAll
*/
typedef enum
{
    AVC_Luma,
    AVC_Intra16DC,
    AVC_Intra16AC,
    AVC_ChromaDC,
    AVC_ChromaAC
} AVCResidualType;


/**
This structure contains VUI parameters as specified in Annex E.
Some variables may be removed from the structure if they are found to be useless to store.
@publishedAll
*/
typedef struct tagHRDParams
{
    uint  cpb_cnt_minus1;                                   /* ue(v), range 0..31 */
    uint  bit_rate_scale;                          /* u(4) */
    uint  cpb_size_scale;                          /* u(4) */
    uint32  bit_rate_value_minus1[MAXIMUMVALUEOFcpb_cnt];/* ue(v), range 0..2^32-2 */
    uint32  cpb_size_value_minus1[MAXIMUMVALUEOFcpb_cnt]; /* ue(v), range 0..2^32-2 */
    uint  cbr_flag[MAXIMUMVALUEOFcpb_cnt];         /* u(1) */
    uint  initial_cpb_removal_delay_length_minus1;   /* u(5), default 23 */
    uint  cpb_removal_delay_length_minus1;           /* u(5), default 23 */
    uint  dpb_output_delay_length_minus1;            /* u(5), default 23 */
    uint  time_offset_length;                        /* u(5), default 24 */
} AVCHRDParams;

/**
This structure contains VUI parameters as specified in Annex E.
Some variables may be removed from the structure if they are found to be useless to store.
@publishedAll
*/
typedef struct tagVUIParam
{
    uint      aspect_ratio_info_present_flag;     /* u(1) */
    uint  aspect_ratio_idc;                     /* u(8), table E-1 */
    uint  sar_width;                          /* u(16) */
    uint  sar_height;                         /* u(16) */
    uint      overscan_info_present_flag;         /* u(1) */
    uint      overscan_appropriate_flag;        /* u(1) */
    uint      video_signal_type_present_flag;     /* u(1) */
    uint  video_format;                         /* u(3), Table E-2, default 5, unspecified */
    uint      video_full_range_flag;            /* u(1) */
    uint      colour_description_present_flag;  /* u(1) */
    uint  colour_primaries;                   /* u(8), Table E-3, default 2, unspecified */
    uint  transfer_characteristics;           /* u(8), Table E-4, default 2, unspecified */
    uint  matrix_coefficients;                /* u(8), Table E-5, default 2, unspecified */
    uint      chroma_location_info_present_flag;  /* u(1) */
    uint  chroma_sample_loc_type_top_field;                /* ue(v), Fig. E-1range 0..5, default 0 */
    uint  chroma_sample_loc_type_bottom_field;                /* ue(v) */
    uint      timing_info_present_flag;           /* u(1) */
    uint  num_units_in_tick;                    /* u(32), must be > 0 */
    uint  time_scale;                           /* u(32), must be > 0 */
    uint      fixed_frame_rate_flag;            /* u(1), Eq. C-13 */
    uint      nal_hrd_parameters_present_flag;    /* u(1) */
    AVCHRDParams nal_hrd_parameters;               /* hrd_paramters */
    uint      vcl_hrd_parameters_present_flag;    /* u(1) */
    AVCHRDParams vcl_hrd_parameters;               /* hrd_paramters */
    /* if ((nal_hrd_parameters_present_flag || (vcl_hrd_parameters_present_flag)) */
    uint      low_delay_hrd_flag;               /* u(1) */
    uint    pic_struct_present_flag;
    uint      bitstream_restriction_flag;         /* u(1) */
    uint      motion_vectors_over_pic_boundaries_flag;    /* u(1) */
    uint  max_bytes_per_pic_denom;              /* ue(v), default 2 */
    uint  max_bits_per_mb_denom;                /* ue(v), range 0..16, default 1 */
    uint  log2_max_mv_length_vertical;          /* ue(v), range 0..16, default 16 */
    uint  log2_max_mv_length_horizontal;        /* ue(v), range 0..16, default 16 */
    uint  max_dec_frame_reordering;             /* ue(v) */
    uint  max_dec_frame_buffering;              /* ue(v) */
} AVCVUIParams;


/**
This structure contains information in a sequence parameter set NAL.
Some variables may be removed from the structure if they are found to be useless to store.
@publishedAll
*/
typedef struct tagSeqParamSet
{
    uint   Valid;            /* indicates the parameter set is valid */

    uint  profile_idc;              /* u(8) */
    uint   constrained_set0_flag;  /* u(1) */
    uint   constrained_set1_flag;  /* u(1) */
    uint   constrained_set2_flag;  /* u(1) */
    uint   constrained_set3_flag;  /* u(1) */
    uint  level_idc;               /* u(8) */
    uint  seq_parameter_set_id;    /* ue(v), range 0..31 */
    uint  log2_max_frame_num_minus4; /* ue(v), range 0..12 */
    uint pic_order_cnt_type;        /* ue(v), range 0..2 */
    /* if( pic_order_cnt_type == 0 )  */
    uint log2_max_pic_order_cnt_lsb_minus4; /* ue(v), range 0..12 */
    /* else if( pic_order_cnt_type == 1 ) */
    uint delta_pic_order_always_zero_flag;  /* u(1) */
    int32  offset_for_non_ref_pic;       /* se(v) */
    int32  offset_for_top_to_bottom_field;  /* se(v) */
    uint  num_ref_frames_in_pic_order_cnt_cycle;   /* ue(v) , range 0..255 */
    /* for( i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++ ) */
    int32   offset_for_ref_frame[MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE];        /* se(v) */
    uint  num_ref_frames;                           /* ue(v), range 0..16 */
    uint   gaps_in_frame_num_value_allowed_flag;    /* u(1) */
    uint  pic_width_in_mbs_minus1;                  /* ue(v) */
    uint  pic_height_in_map_units_minus1;           /* ue(v) */
    uint   frame_mbs_only_flag;                     /* u(1) */
    /* if( !frame_mbs_only_flag ) */
    uint   mb_adaptive_frame_field_flag;          /* u(1) */
    uint   direct_8x8_inference_flag;    /* u(1), must be 1 when frame_mbs_only_flag is 0 */
    uint   frame_cropping_flag;                     /* u(1) */
    /* if( frmae_cropping_flag) */
    uint  frame_crop_left_offset;                /* ue(v) */
    uint  frame_crop_right_offset;               /* ue(v) */
    uint  frame_crop_top_offset;                 /* ue(v) */
    uint  frame_crop_bottom_offset;              /* ue(v) */
    uint   vui_parameters_present_flag;                      /* u(1) */
//  uint nal_hrd_parameters_present_flag;
//  uint vcl_hrd_parameters_present_flag;
//  AVCHRDParams *nal_hrd_parameters;
//  AVCHRDParams *vcl_hrd_parameters;
    AVCVUIParams vui_parameters;                  /* AVCVUIParam */
} AVCSeqParamSet;

/**
This structure contains information in a picture parameter set NAL.
Some variables may be removed from the structure if they are found to be useless to store.
@publishedAll
*/
typedef struct tagPicParamSet
{
    uint  pic_parameter_set_id;              /* ue(v), range 0..255 */
    uint  seq_parameter_set_id;              /* ue(v), range 0..31 */
    uint  entropy_coding_mode_flag;         /* u(1) */
    uint  pic_order_present_flag;        /* u(1) */
    uint  num_slice_groups_minus1;           /* ue(v), range in Annex A */
    /* if( num_slice_groups_minus1 > 0) */
    uint  slice_group_map_type;           /* ue(v), range 0..6 */
    /* if( slice_group_map_type = = 0 ) */
    /* for(0:1:num_slice_groups_minus1) */
    uint  run_length_minus1[MAX_NUM_SLICE_GROUP]; /* ue(v) */
    /* else if( slice_group_map_type = = 2 ) */
    /* for(0:1:num_slice_groups_minus1-1) */
    uint  top_left[MAX_NUM_SLICE_GROUP-1];      /* ue(v) */
    uint  bottom_right[MAX_NUM_SLICE_GROUP-1];  /* ue(v) */
    /* else if( slice_group_map_type = = 3 || 4 || 5 */
    uint  slice_group_change_direction_flag;        /* u(1) */
    uint  slice_group_change_rate_minus1;            /* ue(v) */
    /* else if( slice_group_map_type = = 6 ) */
    uint  pic_size_in_map_units_minus1;          /* ue(v) */
    /* for(0:1:pic_size_in_map_units_minus1) */
    uint  *slice_group_id;                           /* complete MBAmap u(v) */
    uint  num_ref_idx_l0_active_minus1;                  /* ue(v), range 0..31 */
    uint  num_ref_idx_l1_active_minus1;                  /* ue(v), range 0..31 */
    uint  weighted_pred_flag;                           /* u(1) */
    uint  weighted_bipred_idc;                          /* u(2), range 0..2 */
    int   pic_init_qp_minus26;                       /* se(v), range -26..25 */
    int   pic_init_qs_minus26;                       /* se(v), range -26..25 */
    int   chroma_qp_index_offset;                    /* se(v), range -12..12 */
    uint  deblocking_filter_control_present_flag;       /* u(1) */
    uint  constrained_intra_pred_flag;                  /* u(1) */
    uint  redundant_pic_cnt_present_flag;               /* u(1) */
} AVCPicParamSet;


/**
This structure contains slice header information.
Some variables may be removed from the structure if they are found to be useless to store.
@publishedAll
*/
typedef struct tagSliceHeader
{
    uint    first_mb_in_slice;      /* ue(v) */
    AVCSliceType slice_type;                /* ue(v), Table 7-3, range 0..9 */
    uint    pic_parameter_set_id;   /* ue(v), range 0..255 */
    uint    frame_num;              /* u(v), see log2max_frame_num_minus4 */
    /* if( !frame_mbs_only_flag) */
    uint    field_pic_flag;         /* u(1) */
    /* if(field_pic_flag) */
    uint bottom_field_flag; /* u(1) */
    /* if(nal_unit_type == 5) */
    uint    idr_pic_id;         /* ue(v), range 0..65535 */
    /* if(pic_order_cnt_type==0) */
    uint    pic_order_cnt_lsb;  /* u(v), range 0..MaxPicOrderCntLsb-1 */
    /* if(pic_order_present_flag && !field_pic_flag) */
    int32 delta_pic_order_cnt_bottom;   /* se(v) */
    /* if(pic_order_cnt_type==1 && !delta_pic_order_always_zero_flag) */
    /* if(pic_order_present_flag && !field_pic_flag) */
    int32 delta_pic_order_cnt[2];
    /* if(redundant_pic_cnt_present_flag) */
    uint redundant_pic_cnt; /* ue(v), range 0..127 */
    /* if(slice_type == B) */
    uint direct_spatial_mv_pred_flag; /* u(1) */
    /* if(slice_type == P || slice_type==SP || slice_type==B) */
    uint num_ref_idx_active_override_flag;  /* u(1) */
    /* if(num_ref_idx_active_override_flag) */
    uint num_ref_idx_l0_active_minus1;  /* ue(v) */
    /* if(slie_type == B) */
    uint num_ref_idx_l1_active_minus1;  /* ue(v) */

    /* ref_pic_list_reordering() */
    uint ref_pic_list_reordering_flag_l0;   /* u(1) */
    uint reordering_of_pic_nums_idc_l0[MAX_REF_PIC_LIST_REORDERING];   /* ue(v), range 0..3 */
    uint abs_diff_pic_num_minus1_l0[MAX_REF_PIC_LIST_REORDERING];   /* ue(v) */
    uint long_term_pic_num_l0[MAX_REF_PIC_LIST_REORDERING];     /* ue(v) */
    uint ref_pic_list_reordering_flag_l1;   /* u(1) */
    uint reordering_of_pic_nums_idc_l1[MAX_REF_PIC_LIST_REORDERING];   /* ue(v), range 0..3 */
    uint abs_diff_pic_num_minus1_l1[MAX_REF_PIC_LIST_REORDERING];   /* ue(v) */
    uint long_term_pic_num_l1[MAX_REF_PIC_LIST_REORDERING];     /* ue(v) */

    /* end ref_pic_list_reordering() */
    /* if(nal_ref_idc!=0) */
    /* dec_ref_pic_marking() */
    uint    no_output_of_prior_pics_flag;   /* u(1) */
    uint long_term_reference_flag;      /* u(1) */
    uint    adaptive_ref_pic_marking_mode_flag; /* u(1) */
    uint    memory_management_control_operation[MAX_DEC_REF_PIC_MARKING];   /* ue(v), range 0..6 */
    uint difference_of_pic_nums_minus1[MAX_DEC_REF_PIC_MARKING];    /* ue(v) */
    uint    long_term_pic_num[MAX_DEC_REF_PIC_MARKING];             /* ue(v) */
    uint    long_term_frame_idx[MAX_DEC_REF_PIC_MARKING];           /* ue(v) */
    uint    max_long_term_frame_idx_plus1[MAX_DEC_REF_PIC_MARKING]; /* ue(v) */
    /* end dec_ref_pic_marking() */
    /* if(entropy_coding_mode_flag && slice_type!=I && slice_type!=SI) */
    uint cabac_init_idc;        /* ue(v), range 0..2 */
    int slice_qp_delta;     /* se(v), range 0..51 */
    /* if(slice_type==SP || slice_type==SI) */
    /* if(slice_type==SP) */
    uint    sp_for_switch_flag; /* u(1) */
    int slice_qs_delta;     /* se(v) */

    /* if(deblocking_filter_control_present_flag)*/
    uint disable_deblocking_filter_idc; /* ue(v), range 0..2 */
    /* if(disable_deblocking_filter_idc!=1) */
    int slice_alpha_c0_offset_div2; /* se(v), range -6..6, default 0 */
    int slice_beta_offset_div_2; /* se(v), range -6..6, default 0 */
    /* if(num_slice_groups_minus1>0 && slice_group_map_type>=3 && slice_group_map_type<=5)*/
    uint    slice_group_change_cycle;   /* u(v), use ceil(log2(PicSizeInMapUnits/SliceGroupChangeRate + 1)) bits*/

} AVCSliceHeader;

/**
This struct contains information about the neighboring pixel.
@publishedAll
*/
typedef struct tagPixPos
{
    int available;
    int mb_addr;    /* macroblock address of the current pixel, see below */
    int x;      /* x,y positions of current pixel relative to the macroblock mb_addr */
    int y;
    int pos_x;  /* x,y positions of current pixel relative to the picture. */
    int pos_y;
} AVCPixelPos;

typedef struct tagNeighborAvailability
{
    int left;
    int top;    /* macroblock address of the current pixel, see below */
    int top_right;      /* x,y positions of current pixel relative to the macroblock mb_addr */
} AVCNeighborAvailability;


/**
This structure contains picture data and related information necessary to be used as
reference frame.
@publishedAll
*/
typedef struct tagPictureData
{
    uint16 RefIdx;  /* index used for reference frame */
    uint8 *Sl;   /* derived from base_dpb in AVCFrameStore */
    uint8 *Scb;  /* for complementary fields, YUV are interlaced */
    uint8 *Scr;  /* Sl of top_field and bottom_fields will be one line apart and the
                    stride will be 2 times the width. */
    /* For non-complementary field, the above still applies. A special
       output formatting is required. */

    /* Then, necessary variables that need to be stored */
    AVCPictureType  picType; /* frame, top-field or bot-field */
    /*bool*/
    uint    isReference;
    /*bool*/
    uint    isLongTerm;
    int     PicOrderCnt;
    int     PicNum;
    int     LongTermPicNum;

    int     width; /* how many pixel per line */
    int     height;/* how many line */
    int     pitch; /* how many pixel between the line */

    uint    padded; /* flag for being padded */

} AVCPictureData;

/**
This structure contains information for frame storage.
@publishedAll
*/
typedef struct tagFrameStore
{
    uint8 *base_dpb;    /* base pointer for the YCbCr */

    int     IsReference; /*  0=not used for ref; 1=top used; 2=bottom used; 3=both fields (or frame) used */
    int     IsLongTerm;  /*  0=not used for ref; 1=top used; 2=bottom used; 3=both fields (or frame) used */
    /* if IsLongTerm is true, IsReference can be ignored. */
    /* if IsReference is true, IsLongterm will be checked for short-term or long-term. */
    /* IsUsed must be true to enable the validity of IsReference and IsLongTerm */

    int     IsOutputted;  /* has it been outputted via AVCDecGetOutput API, then don't output it again,
                            wait until it is returned. */
    AVCPictureData frame;

    int     FrameNum;
    int     FrameNumWrap;
    int     LongTermFrameIdx;
    int     PicOrderCnt; /* of the frame, smaller of the 2 fields */

} AVCFrameStore;

/**
This structure maintains the actual memory for the decoded picture buffer (DPB) which is
allocated at the beginning according to profile/level.
Once decoded_picture_buffer is allocated, Sl,Scb,Scr in
AVCPictureData structure just point to the address in decoded_picture_buffer.
used_size maintains the used space.
NOTE:: In order to maintain contiguous memory space, memory equal to a single frame is
assigned at a time. Two opposite fields reside in the same frame memory.

  |-------|---|---|---|xxx|-------|xxx|---|-------|   decoded_picture_buffer
    frame  top bot top      frame      bot  frame
      0     1   1   2         3         4     5

  bot 2 and top 4 do not exist, the memory is not used.

@publishedAll
*/
typedef struct tagDecPicBuffer
{
    uint8 *decoded_picture_buffer;  /* actual memory */
    uint32  dpb_size;       /* size of dpb in bytes */
    uint32  used_size;  /* used size */
    struct tagFrameStore    *fs[MAX_FS]; /* list of frame stored, actual buffer */
    int     num_fs;  /* size of fs */

} AVCDecPicBuffer;


/**
This structure contains macroblock related variables.
@publishedAll
*/
typedef struct tagMacroblock
{
    AVCIntraChromaPredMode  intra_chroma_pred_mode;  /* ue(v) */

    int32 mvL0[16];  /* motion vectors, 16 bit packed (x,y) per element  */
    int32 mvL1[16];
    int16 ref_idx_L0[4];
    int16 ref_idx_L1[4];
    uint16 RefIdx[4]; /* ref index, has value of AVCPictureData->RefIdx */
    /* stored data */
    /*bool*/
    uint    mb_intra; /* intra flag */
    /*bool*/
    uint    mb_bottom_field;

    AVCMBMode mbMode;   /* type of MB prediction */
    AVCSubMBMode subMbMode[4]; /* for each 8x8 partition */

    uint    CBP; /* CodeBlockPattern */
    AVCIntra16x16PredMode i16Mode; /* Intra16x16PredMode */
    AVCIntra4x4PredMode i4Mode[16]; /* Intra4x4PredMode, in raster scan order */
    int NumMbPart; /* number of partition */
    AVCPredMode MBPartPredMode[4][4]; /* prediction mode [MBPartIndx][subMBPartIndx] */
    int MbPartWidth;
    int MbPartHeight;
    int NumSubMbPart[4];  /* for each 8x8 partition */
    int SubMbPartWidth[4];  /* for each 8x8 partition */
    int SubMbPartHeight[4]; /* for each 8x8 partition */

    uint8 nz_coeff[NUM_BLKS_IN_MB];  /* [blk_y][blk_x], Chroma is [4..5][0...3], see predict_nnz() function */

    int QPy; /* Luma QP */
    int QPc; /* Chroma QP */
    int QSc; /* Chroma QP S-picture */

    int slice_id;           // MC slice
} AVCMacroblock;


/**
This structure contains common internal variables between the encoder and decoder
such that some functions can be shared among them.
@publishedAll
*/
typedef struct tagCommonObj
{
    /* put these 2 up here to make sure they are word-aligned */
    int16   block[NUM_PIXELS_IN_MB]; /* for transformed residue coefficient */
    uint8   *pred_block;    /* pointer to prediction block, could point to a frame */
#ifdef USE_PRED_BLOCK
    uint8   pred[688];  /* for prediction */
    /* Luma [0-399], Cb [400-543], Cr[544-687] */
#endif
    int     pred_pitch; /* either equal to 20 or to frame pitch */

    /* temporary buffers for intra prediction */
    /* these variables should remain inside fast RAM */
#ifdef MB_BASED_DEBLOCK
    uint8   *intra_pred_top; /* a row of pixel for intra prediction */
    uint8   intra_pred_left[17]; /* a column of pixel for intra prediction */
    uint8   *intra_pred_top_cb;
    uint8   intra_pred_left_cb[9];
    uint8   *intra_pred_top_cr;
    uint8   intra_pred_left_cr[9];
#endif
    /* pointer to the prediction area for intra prediction */
    uint8   *pintra_pred_top;   /* pointer to the top intra prediction value */
    uint8   *pintra_pred_left;  /* pointer to the left intra prediction value */
    uint8   intra_pred_topleft; /* the [-1,-1] neighboring pixel */
    uint8   *pintra_pred_top_cb;
    uint8   *pintra_pred_left_cb;
    uint8   intra_pred_topleft_cb;
    uint8   *pintra_pred_top_cr;
    uint8   *pintra_pred_left_cr;
    uint8   intra_pred_topleft_cr;

    int QPy;
    int QPc;
    int QPy_div_6;
    int QPy_mod_6;
    int QPc_div_6;
    int QPc_mod_6;
    /**** nal_unit ******/
    /* previously in AVCNALUnit format */
    uint    NumBytesInRBSP;
    int     forbidden_bit;
    int     nal_ref_idc;
    AVCNalUnitType  nal_unit_type;
    AVCNalUnitType  prev_nal_unit_type;
    /*bool*/
    uint    slice_data_partitioning; /* flag when nal_unit_type is between 2 and 4 */
    /**** ******** ******/
    AVCSliceType slice_type;
    AVCDecPicBuffer     *decPicBuf; /* decoded picture buffer */

    AVCSeqParamSet *currSeqParams; /*  the currently used one */

    AVCPicParamSet  *currPicParams; /* the currently used one */
    uint        seq_parameter_set_id;
    /* slice header */
    AVCSliceHeader *sliceHdr;   /* slice header param syntax variables */

    AVCPictureData  *currPic; /* pointer to current picture */
    AVCFrameStore   *currFS;  /* pointer to current frame store */
    AVCPictureType  currPicType; /* frame, top-field or bot-field */
    /*bool*/
    uint    newPic; /* flag for new picture */
    uint            newSlice; /* flag for new slice */
    AVCPictureData  *prevRefPic; /* pointer to previous picture */

    AVCMacroblock   *mblock; /* array of macroblocks covering entire picture */
    AVCMacroblock   *currMB; /* pointer to current macroblock */
    uint                    mbNum; /* number of current MB */
    int                 mb_x;  /* x-coordinate of the current mbNum */
    int                 mb_y;  /* y-coordinate of the current mbNum */

    /* For internal operation, scratch memory for MV, prediction, transform, etc.*/
    uint32 cbp4x4; /* each bit represent nonzero 4x4 block in reverse raster scan order */
    /* starting from luma, Cb and Cr, lsb toward msb */
    int mvd_l0[4][4][2]; /* [mbPartIdx][subMbPartIdx][compIdx], se(v) */
    int mvd_l1[4][4][2]; /* [mbPartIdx][subMbPartIdx][compIdx], se(v) */

    int mbAddrA, mbAddrB, mbAddrC, mbAddrD; /* address of neighboring MBs */
    /*bool*/
    uint    mbAvailA, mbAvailB, mbAvailC, mbAvailD; /* availability */
    /*bool*/
    uint    intraAvailA, intraAvailB, intraAvailC, intraAvailD; /* for intra mode */
    /***********************************************/
    /* The following variables are defined in the draft. */
    /* They may need to be stored in PictureData structure and used for reference. */
    /* In that case, just move or copy it to AVCDecPictureData structure. */

    int     padded_size;    /* size of extra padding to a frame */

    uint    MaxFrameNum;    /*2^(log2_max_frame_num_minus4+4), range 0.. 2^16-1 */
    uint    MaxPicOrderCntLsb; /*2^(log2_max_pic_order_cnt_lsb_minus4+4), 0..2^16-1 */
    uint    PicWidthInMbs;  /*pic_width_in_mbs_minus1+1 */
    uint    PicWidthInSamplesL; /* PicWidthInMbs*16 */
    uint    PicWidthInSamplesC; /* PicWIdthInMbs*8 */
    uint    PicHeightInMapUnits; /* pic_height_in_map_units_minus1+1 */
    uint    PicSizeInMapUnits;  /* PicWidthInMbs*PicHeightInMapUnits */
    uint    FrameHeightInMbs;   /*(2-frame_mbs_only_flag)*PicHeightInMapUnits */

    uint    SliceGroupChangeRate; /* slice_group_change_rate_minus1 + 1 */

    /* access unit */
    uint    primary_pic_type;   /* u(3), Table 7-2, kinda informative only */

    /* slice data partition */
    uint    slice_id;           /* ue(v) */

    uint    UnusedShortTermFrameNum;
    uint    PrevRefFrameNum;
    uint    MbaffFrameFlag; /* (mb_adaptive_frame_field_flag && !field_pic_flag) */
    uint    PicHeightInMbs; /* FrameHeightInMbs/(1+field_pic_flag) */
    int     PicHeightInSamplesL; /* PicHeightInMbs*16 */
    int     PicHeightInSamplesC; /* PicHeightInMbs*8 */
    uint    PicSizeInMbs;   /* PicWidthInMbs*PicHeightInMbs */
    uint    level_idc;
    int     numMBs;
    uint    MaxPicNum;
    uint    CurrPicNum;
    int     QSy;    /* 26+pic_init_qp_minus26+slice_qs_delta */
    int     FilterOffsetA;
    int     FilterOffsetB;
    uint    MapUnitsInSliceGroup0;  /* Min(slie_group_change_cycle*SliceGroupChangeRate,PicSizeInMapUnits) */
    /* dec_ref_pic_marking */
    int     MaxLongTermFrameIdx;
    int     LongTermFrameIdx;

    /* POC related variables */
    /*bool*/
    uint    mem_mgr_ctrl_eq_5;  /* if memory_management_control_operation equal to 5 flag */
    int     PicOrderCnt;
    int     BottomFieldOrderCnt, TopFieldOrderCnt;
    /* POC mode 0 */
    int     prevPicOrderCntMsb;
    uint    prevPicOrderCntLsb;
    int     PicOrderCntMsb;
    /* POC mode 1 */
    int     prevFrameNumOffset, FrameNumOffset;
    uint    prevFrameNum;
    int     absFrameNum;
    int     picOrderCntCycleCnt, frameNumInPicOrderCntCycle;
    int     expectedDeltaPerPicOrderCntCycle;
    int     expectedPicOrderCnt;

    /* FMO */
    int *MbToSliceGroupMap;  /* to be re-calculate at the beginning */

    /* ref pic list */
    AVCPictureData  *RefPicList0[MAX_REF_PIC_LIST]; /* list 0 */
    AVCPictureData  *RefPicList1[MAX_REF_PIC_LIST]; /* list 1 */
    AVCFrameStore   *refFrameList0ShortTerm[32];
    AVCFrameStore   *refFrameList1ShortTerm[32];
    AVCFrameStore   *refFrameListLongTerm[32];
    int     refList0Size;
    int     refList1Size;

    /* slice data semantics*/
    int mb_skip_run;    /* ue(v) */
    /*uint  mb_skip_flag;*/ /* ae(v) */
    /* uint end_of_slice_flag;*//* ae(v) */
    /***********************************************/

    /* function pointers */
    int (*is_short_ref)(AVCPictureData *s);
    int (*is_long_ref)(AVCPictureData *s);

} AVCCommonObj;

/**
Commonly used constant arrays.
@publishedAll
*/
/**
Zigzag scan from 1-D to 2-D. */
const static uint8 ZZ_SCAN[16] = {0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15};
/* Zigzag scan from 1-D to 2-D output to block[24][16]. */
const static uint8 ZZ_SCAN_BLOCK[16] = {0, 1, 16, 32, 17, 2, 3, 18, 33, 48, 49, 34, 19, 35, 50, 51};

/**
From zigzag to raster for luma DC value */
const static uint8 ZIGZAG2RASTERDC[16] = {0, 4, 64, 128, 68, 8, 12, 72, 132, 192, 196, 136, 76, 140, 200, 204};


/**
Mapping from coding scan block indx to raster scan block index */
const static int blkIdx2blkX[16] = {0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3};
const static int blkIdx2blkY[16] = {0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3};
/** from [blk8indx][blk4indx] to raster scan index */
const static int blkIdx2blkXY[4][4] = {{0, 1, 4, 5}, {2, 3, 6, 7}, {8, 9, 12, 13}, {10, 11, 14, 15}};

/*
Availability of the neighboring top-right block relative to the current block. */
const static int BlkTopRight[16] = {2, 2, 2, 3, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0};

/**
Table 8-13 Specification of QPc as a function of qPI. */
const static uint8 mapQPi2QPc[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
                                    };

/**
See 8.5.5 equation (8-252 and 8-253) the definition of v matrix. */
/* in zigzag scan */
const static int dequant_coefres[6][16] =
{
    {10, 13, 13, 10, 16, 10, 13, 13, 13, 13, 16, 10, 16, 13, 13, 16},
    {11, 14, 14, 11, 18, 11, 14, 14, 14, 14, 18, 11, 18, 14, 14, 18},
    {13, 16, 16, 13, 20, 13, 16, 16, 16, 16, 20, 13, 20, 16, 16, 20},
    {14, 18, 18, 14, 23, 14, 18, 18, 18, 18, 23, 14, 23, 18, 18, 23},
    {16, 20, 20, 16, 25, 16, 20, 20, 20, 20, 25, 16, 25, 20, 20, 25},
    {18, 23, 23, 18, 29, 18, 23, 23, 23, 23, 29, 18, 29, 23, 23, 29}
};

/**
From jm7.6 block.c. (in zigzag scan) */
const static int quant_coef[6][16] =
{
    {13107, 8066,   8066,   13107,  5243,   13107,  8066,   8066,   8066,   8066,   5243,   13107,  5243,   8066,   8066,   5243},
    {11916, 7490,   7490,   11916,  4660,   11916,  7490,   7490,   7490,   7490,   4660,   11916,  4660,   7490,   7490,   4660},
    {10082, 6554,   6554,   10082,  4194,   10082,  6554,   6554,   6554,   6554,   4194,   10082,  4194,   6554,   6554,   4194},
    {9362,  5825,   5825,   9362,   3647,   9362,   5825,   5825,   5825,   5825,   3647,   9362,   3647,   5825,   5825,   3647},
    {8192,  5243,   5243,   8192,   3355,   8192,   5243,   5243,   5243,   5243,   3355,   8192,   3355,   5243,   5243,   3355},
    {7282,  4559,   4559,   7282,   2893,   7282,   4559,   4559,   4559,   4559,   2893,   7282,   2893,   4559,   4559,   2893}
};

/**
Convert scan from raster scan order to block decoding order and
from block decoding order to raster scan order. Same table!!!
*/
const static uint8 ras2dec[16] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15};

/* mapping from level_idc to index map */
const static uint8 mapLev2Idx[61] = {255, 255, 255, 255, 255, 255, 255, 255, 255, 1,
                                     0, 1, 2, 3, 255, 255, 255, 255, 255, 255,
                                     4, 5, 6, 255, 255, 255, 255, 255, 255, 255,
                                     7, 8, 9, 255, 255, 255, 255, 255, 255, 255,
                                     10, 11, 12, 255, 255, 255, 255, 255, 255, 255,
                                     13, 14, 255, 255, 255, 255, 255, 255, 255, 255
                                    };
/* map back from index to Level IDC */
const static uint8 mapIdx2Lev[MAX_LEVEL_IDX] = {10, 11, 12, 13, 20, 21, 22, 30, 31, 32, 40, 41, 42, 50, 51};

/**
from the index map to the MaxDPB value times 2 */
const static int32 MaxDPBX2[MAX_LEVEL_IDX] = {297, 675, 1782, 1782, 1782, 3564, 6075, 6075,
        13500, 15360, 24576, 24576, 24576, 82620, 138240
                                             };

/* map index to the max frame size */
const static int MaxFS[MAX_LEVEL_IDX] = {99, 396, 396, 396, 396, 792, 1620, 1620, 3600, 5120,
                                        8192, 8192, 8192, 22080, 36864
                                        };

/* map index to max MB processing rate */
const static int32 MaxMBPS[MAX_LEVEL_IDX] = {1485, 3000, 6000, 11880, 11880, 19800, 20250, 40500,
        108000, 216000, 245760, 245760, 491520, 589824, 983040
                                            };

/* map index to max video bit rate */
const static uint32 MaxBR[MAX_LEVEL_IDX] = {64, 192, 384, 768, 2000, 4000, 4000, 10000, 14000, 20000,
        20000, 50000, 50000, 135000, 240000
                                           };

/* map index to max CPB size */
const static uint32 MaxCPB[MAX_LEVEL_IDX] = {175, 500, 1000, 2000, 2000, 4000, 4000, 10000, 14000,
        20000, 25000, 62500, 62500, 135000, 240000
                                            };

/* map index to max vertical MV range */
const static int MaxVmvR[MAX_LEVEL_IDX] = {64, 128, 128, 128, 128, 256, 256, 256, 512, 512, 512, 512, 512, 512, 512};

#endif /*  _AVCINT_COMMON_H_ */