#define LIBVA_UTILS_UPLOAD_DOWNLOAD_YUV_SURFACE 1

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#include <getopt.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <assert.h>
#include <pthread.h>
#include <errno.h>
#include <math.h>
#include <va/va.h>
#include "va_display.h"

#define ALIGN16(x)  ((x+15)&~15)
#define CHECK_VASTATUS(va_status,func)                                  \
    if (va_status != VA_STATUS_SUCCESS) {                               \
        fprintf(stderr,"%s:%s (%d) failed,exit\n", __func__, func, __LINE__); \
        exit(1);                                                        \
    }

#define MIN(a, b) ((a)>(b)?(b):(a))
#define MAX(a, b) ((a)>(b)?(a):(b))

#define CHECK_NULL(p)                                           \
    if(!(p))                                                      \
    {                                                           \
        fprintf(stderr, "Null pointer at:%s:%d\n", __func__, __LINE__); \
        exit(1);                                                \
    }
    
#define CHECK_CONDITION(cod)                                    \
    if(!(cod))                                                      \
    {                                                           \
        fprintf(stderr, "Unexpected condition:%s:%d\n", __func__, __LINE__); \
        exit(1);                                                \
    }

#define CHECK_BS_NULL(p)         \
    CHECK_NULL(p)        \
    CHECK_NULL(p->buffer)      

#include "loadsurface.h"

/*****
 * 
 * Bit stream management
 * 
 * 
 * */


#define BITSTREAM_ALLOCATE_STEPPING 1024 // in byte

struct __bitstream {
    uint8_t *buffer; // managed by u8 to avoid swap every 4byte
    int bit_offset;
    int max_size_in_byte;
};
typedef struct __bitstream bitstream;


static void
bitstream_start(bitstream *bs)
{
    CHECK_NULL(bs);
    bs->max_size_in_byte = BITSTREAM_ALLOCATE_STEPPING;
    bs->buffer = calloc(bs->max_size_in_byte * sizeof(uint8_t), 1);
    CHECK_NULL(bs->buffer);
    bs->bit_offset = 0;
}

static void
put_ui(bitstream* bs, uint32_t val, int size_in_bits)
{
    CHECK_BS_NULL(bs);
    CHECK_CONDITION((size_in_bits + bs->bit_offset) <= (8 * bs->max_size_in_byte));
    int remain_bits = 8 - (bs->bit_offset % 8);

    // make sure val does not overflow size_in_bits
    val &= (0xffffffff >> (32 - size_in_bits));

    if(size_in_bits <= remain_bits)
    {
        bs->buffer[bs->bit_offset / 8] |= val << (remain_bits - size_in_bits);
        bs->bit_offset += size_in_bits;
    }
    else
    {
        
        put_ui(bs, val >> (size_in_bits - remain_bits), remain_bits);
        put_ui(bs, val & (~(0xffffffff << (size_in_bits - remain_bits))), size_in_bits - remain_bits);

    }

}

static void
put_aligning_bits(bitstream* bs)
{
    CHECK_BS_NULL(bs);
    while (bs->bit_offset & 7)
        put_ui(bs, 0, 1);; //trailing_zero_bit
}

static void
put_trailing_bits(bitstream* bs)
{
    CHECK_BS_NULL(bs);
    put_ui(bs, 1, 1); //trailing_one_bit
    while (bs->bit_offset & 7)
        put_ui(bs, 0, 1);; //trailing_zero_bit
}

static void
bitstream_free(bitstream* bs)
{
    CHECK_BS_NULL(bs);
    free(bs->buffer);
    bs->bit_offset = 0;
    bs->max_size_in_byte = 0;
}

static void
bitstream_cat(bitstream *bs1, bitstream *bs2)
{
    CHECK_NULL(bs1);
    CHECK_NULL(bs2);
    CHECK_CONDITION(! (bs1->bit_offset & 7));
    if(! (bs1->bit_offset & 7)) //byte aligned
    {
        memcpy(bs1->buffer + (bs1->bit_offset / 8), bs2->buffer, bs2->bit_offset/8);
        bs1->bit_offset += bs2->bit_offset;
        bitstream_free(bs2);
    }
    else
    {
        //when call this function to concat 2 bitstreams, the first bitstream should always be byte aligned
        CHECK_CONDITION(0);
    }
}

/******
 * definition of para set structure
 * 
 * 
 * 
 * */

#define PRIMARY_REF_BITS              3
#define PRIMARY_REF_NONE              7

#define REF_FRAMES_LOG2               3
#define NUM_REF_FRAMES                (1 << REF_FRAMES_LOG2)
#define REFS_PER_FRAME                7
#define TOTAL_REFS_PER_FRAME          8
#define MAX_MODE_LF_DELTAS            2
#define MAX_MB_PLANE                  3

#define CDEF_MAX_STRENGTHS            8
#define CDEF_STRENGTH_BITS            6
#define CDEF_STRENGTH_DIVISOR         4
#define AV1_MAX_NUM_TILE_COLS         64
#define AV1_MAX_NUM_TILE_ROWS         64
#define MAX_NUM_OPERATING_POINTS      32

#define SURFACE_NUM 16 /* 16 surfaces for source YUV */


enum {
    SINGLE_REFERENCE      = 0,
    COMPOUND_REFERENCE    = 1,
    REFERENCE_MODE_SELECT = 2,
    REFERENCE_MODES       = 3,
} REFERENCE_MODE;

enum FRAME_TYPE
{
    KEY_FRAME = 0,
    INTER_FRAME = 1,
    INTRA_ONLY_FRAME = 2,
    SWITCH_FRAME = 3,
    NUM_FRAME_TYPES,
};

enum INTERP_FILTER{
    EIGHTTAP_REGULAR,
    EIGHTTAP_SMOOTH,
    EIGHTTAP_SHARP,
    BILINEAR,
    SWITCHABLE,
    INTERP_FILTERS_ALL
};

enum AV1_OBU_TYPE
{
    OBU_SEQUENCE_HEADER = 1,
    OBU_TEMPORAL_DELIMITER = 2,
    OBU_FRAME_HEADER = 3,
    OBU_TILE_GROUP = 4,
    OBU_METADATA = 5,
    OBU_FRAME = 6,
    OBU_REDUNDANT_FRAME_HEADER = 7,
    OBU_PADDING = 15,
};

struct LoopFilterParams
{
    int32_t loop_filter_level[4];
    int32_t loop_filter_sharpness;
    uint8_t loop_filter_delta_enabled;
    uint8_t loop_filter_delta_update;
    // 0 = Intra, Last, Last2, Last3, GF, BWD, ARF
    int8_t loop_filter_ref_deltas[TOTAL_REFS_PER_FRAME];
    // 0 = ZERO_MV, MV
    int8_t loop_filter_mode_deltas[MAX_MODE_LF_DELTAS];
};

struct TileInfoAv1
{
    uint32_t uniform_tile_spacing_flag;
    uint32_t TileColsLog2;
    uint32_t TileRowsLog2;
    uint32_t TileCols;
    uint32_t TileRows;
    uint32_t TileWidthInSB[AV1_MAX_NUM_TILE_COLS];  // valid for 0 <= i < TileCols
    uint32_t TileHeightInSB[AV1_MAX_NUM_TILE_ROWS]; // valid for 0 <= i < TileRows
    uint32_t context_update_tile_id;
    uint32_t TileSizeBytes;
};


struct QuantizationParams
{
    uint32_t base_q_idx;
    int32_t DeltaQYDc;
    int32_t DeltaQUDc;
    int32_t DeltaQUAc;
    int32_t DeltaQVDc;
    int32_t DeltaQVAc;
    uint32_t using_qmatrix;
    uint32_t qm_y;
    uint32_t qm_u;
    uint32_t qm_v;
};

struct CdefParams
{
    uint32_t cdef_damping;
    uint32_t cdef_bits;
    uint32_t cdef_y_pri_strength[CDEF_MAX_STRENGTHS];
    uint32_t cdef_y_sec_strength[CDEF_MAX_STRENGTHS];
    uint32_t cdef_uv_pri_strength[CDEF_MAX_STRENGTHS];
    uint32_t cdef_uv_sec_strength[CDEF_MAX_STRENGTHS];
};

enum RestorationType
{
    RESTORE_NONE,
    RESTORE_SWITCHABLE,
    RESTORE_WIENER,
    RESTORE_SGRPROJ,
    RESTORE_TYPES = 4,
};

enum {
    BITDEPTH_8 = 8,
    BITDEPTH_10 = 10
};

enum {
    INTRA_FRAME     = 0,
    LAST_FRAME      = 1,
    LAST2_FRAME     = 2,
    LAST3_FRAME     = 3,
    GOLDEN_FRAME    = 4,
    BWDREF_FRAME    = 5,
    ALTREF2_FRAME   = 6,
    ALTREF_FRAME    = 7,
    MAX_REF_FRAMES  = 8
};

struct LRParams
{
    enum RestorationType lr_type[MAX_MB_PLANE];
    uint32_t lr_unit_shift;
    uint32_t lr_uv_shift;
    uint32_t lr_unit_extra_shift;
};

enum TX_MODE{
    ONLY_4X4 = 0,     // only 4x4 transform used
    TX_MODE_LARGEST,  // transform size is the largest possible for pu size
    TX_MODE_SELECT,   // transform specified for each block
    TX_MODES,
};

struct ColorConfig
{
    uint32_t BitDepth                      ;
    uint32_t mono_chrome                   ;
    uint32_t color_primaries               ;
    uint32_t transfer_characteristics      ;
    uint32_t matrix_coefficients           ;
    uint32_t color_description_present_flag;
    uint32_t color_range                   ;
    uint32_t chroma_sample_position        ;
    uint32_t subsampling_x                 ;
    uint32_t subsampling_y                 ;
    uint32_t separate_uv_delta_q           ;
};

typedef struct FrameHeader
{

    uint32_t show_existing_frame;
    uint32_t frame_to_show_map_idx;
    uint64_t frame_presentation_time;
    uint32_t display_frame_id;
    enum FRAME_TYPE frame_type;
    uint32_t show_frame;
    uint32_t showable_frame;
    uint32_t error_resilient_mode;
    uint32_t disable_cdf_update;
    uint32_t allow_screen_content_tools;
    uint32_t force_integer_mv;
    uint32_t frame_size_override_flag;
    uint32_t order_hint;
    uint32_t primary_ref_frame;

    uint8_t refresh_frame_flags;

    uint32_t FrameWidth;//input
    uint32_t FrameHeight;//input
    uint32_t use_superres;
    uint32_t SuperresDenom;
    uint32_t UpscaledWidth;
    uint32_t RenderWidth;
    uint32_t RenderHeight;

    uint32_t allow_intrabc;
    int32_t ref_frame_idx[REFS_PER_FRAME];
    uint32_t allow_high_precision_mv;
    enum INTERP_FILTER interpolation_filter;
    //uint32_t is_motion_mode_switchable;
    uint32_t use_ref_frame_mvs; 
    uint32_t disable_frame_end_update_cdf;

    uint32_t sbCols; 
    uint32_t sbRows;
    uint32_t sbSize; //64 by default

    struct TileInfoAv1 tile_info;
    struct QuantizationParams quantization_params; 

    uint32_t delta_q_present;
    uint32_t delta_q_res;

    uint32_t delta_lf_present; 
    uint32_t delta_lf_res; 
    uint32_t delta_lf_multi;

    uint32_t CodedLossless;
    uint32_t AllLossless;

    struct LoopFilterParams loop_filter_params;
    struct CdefParams cdef_params;
    struct LRParams lr_params;

    enum TX_MODE TxMode;
    uint32_t reference_select;
    uint32_t skipModeAllowed;
    uint32_t skipModeFrame[2];
    uint32_t skip_mode_present;
    uint32_t allow_warped_motion;
    uint32_t reduced_tx_set;

} FH;

typedef struct SequenceHeader
{
    uint32_t seq_profile                      ;
    uint32_t still_picture                    ;
    uint32_t reduced_still_picture_header     ;

    uint32_t timing_info_present_flag         ;

    uint32_t decoder_model_info_present_flag  ;

    uint32_t operating_points_cnt_minus_1     ; 
    uint32_t operating_point_idc[MAX_NUM_OPERATING_POINTS]                                   ;
    uint32_t seq_level_idx[MAX_NUM_OPERATING_POINTS]                                         ;
    uint32_t seq_tier[MAX_NUM_OPERATING_POINTS]                                              ;
    uint32_t decoder_model_present_for_this_op[MAX_NUM_OPERATING_POINTS]                     ;
    uint32_t initial_display_delay_minus_1[MAX_NUM_OPERATING_POINTS]                         ;

    uint32_t frame_width_bits                   ; //15 as default value
    uint32_t frame_height_bits                  ; //15 as default value

    uint32_t frame_id_numbers_present_flag      ; // default 0

    uint32_t sbSize                             ; //default 64
    uint32_t enable_filter_intra                ; 
    uint32_t enable_intra_edge_filter           ;
    uint32_t enable_interintra_compound         ;
    uint32_t enable_masked_compound             ;
    uint32_t enable_warped_motion               ; 
    uint32_t enable_dual_filter                 ; 
    uint32_t enable_order_hint                  ;//default set to 1
    uint32_t enable_jnt_comp                    ;
    uint32_t enable_ref_frame_mvs               ; 
    uint32_t seq_force_screen_content_tools     ; 
    uint32_t seq_force_integer_mv               ; 
    uint32_t order_hint_bits_minus1             ; //default 8 - 1
    uint32_t enable_superres                    ; 
    uint32_t enable_cdef                        ;
    uint32_t enable_restoration                 ;

    struct ColorConfig color_config; //default

    uint32_t film_grain_param_present           ;

    uint32_t frame_rate_extN;
    uint32_t frame_rate_extD;
} SH;

struct ObuExtensionHeader {
    uint32_t temporal_id;
    uint32_t spatial_id;
};

struct BitOffsets
{
    uint32_t QIndexBitOffset;
    uint32_t SegmentationBitOffset;
    uint32_t SegmentationBitSize; 
    uint32_t LoopFilterParamsBitOffset;
    uint32_t FrameHdrOBUSizeInBits;
    uint32_t FrameHdrOBUSizeByteOffset;
    uint32_t UncompressedHeaderByteOffset;
    uint32_t CDEFParamsBitOffset;
    uint32_t CDEFParamsSizeInBits;
};

struct Av1InputParameters
{
    char* srcyuv;
    char* recyuv;
    char* output;
    uint32_t profile;
    
    uint32_t order_hint_bits;
    uint32_t enable_cdef;
    uint32_t width;
    uint32_t height;
    uint32_t LDB;
    uint32_t frame_rate_extN;
    uint32_t frame_rate_extD;
    uint32_t level;

    // for brc
    uint32_t bit_rate;
    uint8_t MinBaseQIndex;
    uint8_t MaxBaseQIndex;

    uint32_t intra_period;
    uint32_t ip_period;
    uint32_t RateControlMethod;
    uint32_t BRefType;
    int encode_syncmode;
    int calc_psnr;
    int frame_count;
    int frame_width_aligned;
    int frame_height_aligned;
    uint32_t base_qindex;
    int bit_depth;
    int target_bitrate;
    int max_bitrate;
    int buffer_size;
    int initial_buffer_fullness;

};


static  VADisplay va_dpy;
static  VAProfile av1_profile;
static  VAEntrypoint entryPoint;
static  VAConfigAttrib attrib[VAConfigAttribTypeMax];
static  VAConfigAttrib config_attrib[VAConfigAttribTypeMax];
static  int config_attrib_num = 0;
static  VASurfaceID src_surface[SURFACE_NUM];
static  VABufferID  coded_buf[SURFACE_NUM];
static  VASurfaceID ref_surface[SURFACE_NUM];
static  VAConfigID config_id;
static  VAContextID context_id;

// buffer 
static  VAEncSequenceParameterBufferAV1 seq_param;
static  VAEncPictureParameterBufferAV1 pic_param;
static  VAEncTileGroupBufferAV1 tile_group_param;

// sh fh ips
static  struct Av1InputParameters ips;
static  FH fh;
static  SH sh;
struct BitOffsets offsets;


static  unsigned long long current_frame_encoding = 0;
static  unsigned long long current_frame_display = 0;
static  int current_frame_type;
#define current_slot (current_frame_display % SURFACE_NUM)

/* thread to save coded data/upload source YUV */
struct storage_task_t {
    void *next;
    unsigned long long display_order;
    unsigned long long encode_order;
};
static  struct storage_task_t *storage_task_header = NULL, *storage_task_tail = NULL;
#define SRC_SURFACE_IN_ENCODING 0
#define SRC_SURFACE_IN_STORAGE  1
static  int srcsurface_status[SURFACE_NUM];
//static  int encode_syncmode = 0; moved to input pars
static  pthread_mutex_t encode_mutex = PTHREAD_MUTEX_INITIALIZER;
static  pthread_cond_t  encode_cond = PTHREAD_COND_INITIALIZER;
static  pthread_t encode_thread;

static  char *coded_fn = NULL;
static  FILE *coded_fp = NULL, *srcyuv_fp = NULL, *recyuv_fp = NULL;
static  unsigned long long srcyuv_frames = 0;
static  int srcyuv_fourcc = VA_FOURCC_IYUV;

static  uint64_t frame_size = 0;

/* for performance profiling */
static unsigned int UploadPictureTicks = 0;
static unsigned int BeginPictureTicks = 0;
static unsigned int RenderPictureTicks = 0;
static unsigned int EndPictureTicks = 0;
static unsigned int SyncPictureTicks = 0;
static unsigned int SavePictureTicks = 0;
static unsigned int TotalTicks = 0;

static  unsigned int frame_coded = 0;

static  int rc_default_modes[] = {
    VA_RC_VBR,
    VA_RC_CQP,
    VA_RC_VBR_CONSTRAINED,
    VA_RC_CBR,
    VA_RC_VCM,
    VA_RC_NONE,
};

static int len_ivf_header;
static int len_seq_header;
static int len_pic_header;


/*
 * Helper function for profiling purposes
 */
static unsigned int GetTickCount()
{
    struct timeval tv;
    if (gettimeofday(&tv, NULL))
        return 0;
    return tv.tv_usec / 1000 + tv.tv_sec * 1000;
}

static char *fourcc_to_string(int fourcc)
{
    switch (fourcc) {
    case VA_FOURCC_NV12:
        return "NV12";
    case VA_FOURCC_IYUV:
        return "IYUV";
    case VA_FOURCC_YV12:
        return "YV12";
    case VA_FOURCC_UYVY:
        return "UYVY";
    default:
        return "Unknown";
    }
}

static int string_to_fourcc(char *str)
{
    CHECK_NULL(str);
    int fourcc;

    if (!strncmp(str, "NV12", 4))
        fourcc = VA_FOURCC_NV12;
    else if (!strncmp(str, "IYUV", 4))
        fourcc = VA_FOURCC_IYUV;
    else if (!strncmp(str, "YV12", 4))
        fourcc = VA_FOURCC_YV12;
    else if (!strncmp(str, "UYVY", 4))
        fourcc = VA_FOURCC_UYVY;
    else {
        printf("Unknow FOURCC\n");
        fourcc = -1;
    }
    return fourcc;
}

static int string_to_rc(char *str)
{
    CHECK_NULL(str);
    int rc_mode;

    if (!strncmp(str, "NONE", 4))
        rc_mode = VA_RC_NONE;
    else if (!strncmp(str, "CBR", 3))
        rc_mode = VA_RC_CBR;
    else if (!strncmp(str, "VBR", 3))
        rc_mode = VA_RC_VBR;
    else if (!strncmp(str, "VCM", 3))
        rc_mode = VA_RC_VCM;
    else if (!strncmp(str, "CQP", 3))
        rc_mode = VA_RC_CQP;
    else if (!strncmp(str, "VBR_CONSTRAINED", 15))
        rc_mode = VA_RC_VBR_CONSTRAINED;
    else {
        printf("Unknown RC mode\n");
        rc_mode = -1;
    }
    return rc_mode;
}

static void print_help()
{

    //./av1encode -n 8 -f 30 --intra_period 4 --ip_period 1 --rcmode CQP --srcyuv ./input.yuv --recyuv ./rec.yuv --fourcc IYUV --level 8  --height 1080 --width 1920 --base_q_idx 128 -o ./out.av1 -t 3360000  -u 210 -d 420 --LDB

    printf("./av1encode <options>\n");
    printf("   -n <frames> -f <frame rate> -o <output>\n");
    printf("   --intra_period <number>\n");
    printf("   --ip_period <number>\n");
    printf("   --rcmode <16 for CQP>\n");
    printf("   --srcyuv <filename> load YUV from a file\n");
    printf("   --fourcc <NV12|IYUV|YV12> source YUV fourcc\n");
    printf("   --recyuv <filename> save reconstructed YUV into a file\n");
    printf("   --enablePSNR calculate PSNR of recyuv vs. srcyuv\n");
    printf("   --level\n");
    printf("   --height <number>\n");
    printf("   --width <number>\n");
    printf("   --base_q_idx <number> 1-255\n");

    printf(" sample usage");
    printf("./av1encode -n 8 -f 30 --intra_period 4 --ip_period 1 --rcmode CQP --srcyuv ./input.yuv --recyuv ./rec.yuv --fourcc IYUV --level 8  --height 1080 --width 1920 --base_q_idx 128 -o ./out.av1 -t 3360000  -u 210 -d 420 --LDB");


}

static void process_cmdline(int argc, char *argv[])
{

    int c;
    const struct option long_opts[] = {
        {"help",            no_argument,        NULL, 0 },
        {"intra_period",    required_argument,  NULL, 1 },
        {"ip_period",       required_argument,  NULL, 2 },
        {"rcmode",          required_argument,  NULL, 3 },
        {"srcyuv",          required_argument,  NULL, 4 },
        {"recyuv",          required_argument,  NULL, 5 },
        {"fourcc",          required_argument,  NULL, 6 },
        {"syncmode",        no_argument,        NULL, 7 },
        {"enablePSNR",      no_argument,        NULL, 8 },
        {"level",           required_argument,  NULL, 9 },
        {"height",          required_argument,  NULL, 10 },
        {"width",           required_argument,  NULL, 11 },
        {"base_q_idx",      required_argument,  NULL, 12},
        {"LDB",             no_argument,        NULL, 13},
        {NULL,              no_argument,        NULL, 0 }

    };
    int long_index;

    while ((c = getopt_long_only(argc, argv, "n:f:o:t:m:u:d:?", long_opts, &long_index)) != EOF) 
    {
        switch (c) 
        {
            case 'n':
                ips.frame_count = atoi(optarg);
                break;
            case 'f':
                ips.frame_rate_extN = (int)(atoi(optarg) * 100);
                ips.frame_rate_extD = 100;
                break;
            case 'o':
                ips.output = strdup(optarg);
                break;
            case 1:
                ips.intra_period = atoi(optarg);
                break;
            case 2:
                ips.ip_period = atoi(optarg);
                break;
            case 3:
                ips.RateControlMethod = string_to_rc(optarg); //16:cqp 2:CBR 4:VBR
                break;
            case 4:
                ips.srcyuv = strdup(optarg);
                break;
            case 5:
                ips.recyuv = strdup(optarg);
                break;
            case 6:
                srcyuv_fourcc = string_to_fourcc(optarg);
                break;
            case 7:
                ips.encode_syncmode = 1;
                break;
            case 8:
                ips.calc_psnr = 1;
                break;
            case 9:
                ips.level = atoi(optarg);
                break;
            case 10:
                ips.height = atoi(optarg);
                ips.frame_height_aligned = (ips.height + 63) & (~63);
                break;
            case 11:
                ips.width = atoi(optarg);
                ips.frame_width_aligned = (ips.width + 63) & (~63);
                break;
            case 12:
                ips.base_qindex = atoi(optarg);
                break;
            case 13:
                ips.LDB = 1;
                break;
            case 't':
                ips.target_bitrate = atoi(optarg);
                break;
            case 'm':
                ips.max_bitrate = atoi(optarg);
                break;
            case 'u':
                ips.buffer_size = atoi(optarg) * 8000;
                break;
            case 'd':
                ips.initial_buffer_fullness = atoi(optarg) * 8000;
                break;
            case 0:
            case ':':
            case '?':
                print_help();
                exit(0);
        }
    }

    // init other input parameters as default value
    ips.MaxBaseQIndex = 255;
    ips.MinBaseQIndex = 1;
    ips.bit_depth = 8;

    if(ips.RateControlMethod == VA_RC_CBR) ips.max_bitrate = ips.target_bitrate; //set max = target in CBR case

    if(ips.RateControlMethod == VA_RC_VBR) //VBR
    {
        if(ips.max_bitrate == 0)
        {
            printf("max bitrate is not provided in VBR mode\n");
            exit(0);
        }
    }

    // interface with IO
    /* open source file */
    if (ips.srcyuv) {
        srcyuv_fp = fopen(ips.srcyuv, "r");

        if (srcyuv_fp == NULL)
            printf("Open source YUV file %s failed, use auto-generated YUV data\n", ips.srcyuv);
        else {
            struct stat tmp;

            fstat(fileno(srcyuv_fp), &tmp);
            srcyuv_frames = tmp.st_size / (ips.width * ips.height * 1.5);
            printf("Source YUV file %s with %llu frames\n", ips.srcyuv, srcyuv_frames);

            if (ips.frame_count == 0)
                ips.frame_count = srcyuv_frames;
        }
    }

    /* open source file */
    if (ips.recyuv) {
        recyuv_fp = fopen(ips.recyuv, "w+");

        if (recyuv_fp == NULL)
            printf("Open reconstructed YUV file %s failed\n", ips.recyuv);
    }

    if (ips.output == NULL) {
        struct stat buf;
        if (stat("/tmp", &buf) == 0)
            ips.output = strdup("/tmp/test.av1");
        else if (stat("/sdcard", &buf) == 0)
            ips.output = strdup("/sdcard/test.av1");
        else
            ips.output = strdup("./test.av1");
    }

    /* store coded data into a file */
    if (ips.output) {
        coded_fp = fopen(ips.output, "w+");
    } else {
        printf("Copy file string failed");
        exit(1);
    }
    if (coded_fp == NULL) {
        printf("Open file %s failed, exit\n", ips.output);
        exit(1);
    }

}

static char *rc_to_string(int rcmode)
{
    switch (rcmode) {
    case VA_RC_NONE:
        return "NONE";
    case VA_RC_CBR:
        return "CBR";
    case VA_RC_VBR:
        return "VBR";
    case VA_RC_VCM:
        return "VCM";
    case VA_RC_CQP:
        return "CQP";
    case VA_RC_VBR_CONSTRAINED:
        return "VBR_CONSTRAINED";
    default:
        return "Unknown";
    }
}

static int print_input()
{
    printf("frame count: %d \n", ips.frame_count);
    printf("frame rate: %d \n", ips.frame_rate_extN / ips.frame_rate_extD);
    printf("Intra period: %d \n", ips.intra_period);
    printf("Gop ref dist: %d \n", ips.ip_period);
    printf("rcmode: %s \n", rc_to_string(ips.RateControlMethod));
    printf("source yuv: %s \n", ips.srcyuv);
    printf("recon yuv: %s \n", ips.recyuv);
    printf("output bitstream: %s \n", ips.output);
    printf("level index: %d \n", ips.level);
    printf("frame height: %d \n", ips.height);
    printf("frame width: %d \n", ips.width);
    printf("base_q_index: %d \n", ips.base_qindex);
    printf("target_bitrate: %d bps\n", ips.target_bitrate);
    printf("max_bitrate: %d bps\n", ips.max_bitrate);
    return 0;
}



static int init_va(void)
{
    va_dpy = va_open_display();
    VAStatus va_status;
    int major_ver, minor_ver;
    va_status = vaInitialize(va_dpy, &major_ver, &minor_ver);
    CHECK_VASTATUS(va_status, "vaInitialize");
    av1_profile = VAProfileAV1Profile0;
    entryPoint = VAEntrypointEncSliceLP;

    unsigned int i;
    for (i = 0; i < VAConfigAttribTypeMax; i++)
    attrib[i].type = i;


    va_status = vaGetConfigAttributes(va_dpy, av1_profile, entryPoint,
                                      &attrib[0], VAConfigAttribTypeMax);
    CHECK_VASTATUS(va_status, "vaGetConfigAttributes");
    /* check the interested configattrib */
    if ((attrib[VAConfigAttribRTFormat].value & VA_RT_FORMAT_YUV420) == 0) {
        printf("Not find desired YUV420 RT format\n");
        exit(1);
    } else {
        config_attrib[config_attrib_num].type = VAConfigAttribRTFormat;
        config_attrib[config_attrib_num].value = VA_RT_FORMAT_YUV420;
        config_attrib_num++;
    }

    if (attrib[VAConfigAttribRateControl].value != VA_ATTRIB_NOT_SUPPORTED) {
        int tmp = attrib[VAConfigAttribRateControl].value;

        printf("Support rate control mode (0x%x):", tmp);

        if (tmp & VA_RC_NONE)
            printf("NONE ");
        if (tmp & VA_RC_CBR)
            printf("CBR ");
        if (tmp & VA_RC_VBR)
            printf("VBR ");
        if (tmp & VA_RC_VCM)
            printf("VCM ");
        if (tmp & VA_RC_CQP)
            printf("CQP ");
        if (tmp & VA_RC_VBR_CONSTRAINED)
            printf("VBR_CONSTRAINED ");

        printf("\n");

        if (ips.RateControlMethod == -1 || !(ips.RateControlMethod & tmp))  {
            if (ips.RateControlMethod != -1) {
                printf("Warning: Don't support the specified RateControl mode: %s!!!, switch to ", rc_to_string(ips.RateControlMethod));
            }

            for (i = 0; i < sizeof(rc_default_modes) / sizeof(rc_default_modes[0]); i++) {
                if (rc_default_modes[i] & tmp) {
                    ips.RateControlMethod = rc_default_modes[i];
                    break;
                }
            }

            printf("RateControl mode: %s\n", rc_to_string(ips.RateControlMethod));
        }

        config_attrib[config_attrib_num].type = VAConfigAttribRateControl;
        config_attrib[config_attrib_num].value = ips.RateControlMethod;
        config_attrib_num++;
    }


    if (attrib[VAConfigAttribEncPackedHeaders].value != VA_ATTRIB_NOT_SUPPORTED) {
        int tmp = attrib[VAConfigAttribEncPackedHeaders].value;

        printf("Support VAConfigAttribEncPackedHeaders\n");

        config_attrib[config_attrib_num].type = VAConfigAttribEncPackedHeaders;
        config_attrib[config_attrib_num].value = VA_ENC_PACKED_HEADER_NONE;

        if (tmp & VA_ENC_PACKED_HEADER_SEQUENCE) {
            printf("Support packed sequence headers\n");
            config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_SEQUENCE;
        }

        if (tmp & VA_ENC_PACKED_HEADER_PICTURE) {
            printf("Support packed picture headers\n");
            config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_PICTURE;
        }

        if (tmp & VA_ENC_PACKED_HEADER_SLICE) {
            printf("Support packed slice headers\n");
            config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_SLICE;
        }

        if (tmp & VA_ENC_PACKED_HEADER_MISC) {
            printf("Support packed misc headers\n");
            config_attrib[config_attrib_num].value |= VA_ENC_PACKED_HEADER_MISC;
        }

        config_attrib_num++;
    }

    if (attrib[VAConfigAttribEncInterlaced].value != VA_ATTRIB_NOT_SUPPORTED) {
        int tmp = attrib[VAConfigAttribEncInterlaced].value;

        printf("Support VAConfigAttribEncInterlaced\n");

        if (tmp & VA_ENC_INTERLACED_FRAME)
            printf("support VA_ENC_INTERLACED_FRAME\n");
        if (tmp & VA_ENC_INTERLACED_FIELD)
            printf("Support VA_ENC_INTERLACED_FIELD\n");
        if (tmp & VA_ENC_INTERLACED_MBAFF)
            printf("Support VA_ENC_INTERLACED_MBAFF\n");
        if (tmp & VA_ENC_INTERLACED_PAFF)
            printf("Support VA_ENC_INTERLACED_PAFF\n");

        config_attrib[config_attrib_num].type = VAConfigAttribEncInterlaced;
        config_attrib[config_attrib_num].value = VA_ENC_PACKED_HEADER_NONE;
        config_attrib_num++;
    }

    return 0;
}

static int setup_encode()
{
    VAStatus va_status;
    VASurfaceID *tmp_surfaceid;
    int codedbuf_size, i;

    va_status = vaCreateConfig(va_dpy, av1_profile, entryPoint,
                               &config_attrib[0], config_attrib_num, &config_id);
    CHECK_VASTATUS(va_status, "vaCreateConfig");

    /* create source surfaces */
    va_status = vaCreateSurfaces(va_dpy,
                                 VA_RT_FORMAT_YUV420, ips.frame_width_aligned, ips.frame_height_aligned,
                                 &src_surface[0], SURFACE_NUM,
                                 NULL, 0);
    CHECK_VASTATUS(va_status, "vaCreateSurfaces");

    /* create reference surfaces */
    va_status = vaCreateSurfaces(
                    va_dpy,
                    VA_RT_FORMAT_YUV420, ips.frame_width_aligned, ips.frame_height_aligned,
                    &ref_surface[0], SURFACE_NUM,
                    NULL, 0
                );
    CHECK_VASTATUS(va_status, "vaCreateSurfaces");

    tmp_surfaceid = calloc(2 * SURFACE_NUM, sizeof(VASurfaceID));
    if (tmp_surfaceid) {
        memcpy(tmp_surfaceid, src_surface, SURFACE_NUM * sizeof(VASurfaceID));
        memcpy(tmp_surfaceid + SURFACE_NUM, ref_surface, SURFACE_NUM * sizeof(VASurfaceID));
    }

    /* Create a context for this encode pipe */
    va_status = vaCreateContext(va_dpy, config_id,
                                ips.frame_width_aligned, ips.frame_height_aligned,
                                VA_PROGRESSIVE,
                                tmp_surfaceid, 2 * SURFACE_NUM,
                                &context_id);
    CHECK_VASTATUS(va_status, "vaCreateContext");
    free(tmp_surfaceid);

    codedbuf_size = ((long long int) ips.frame_width_aligned * ips.frame_height_aligned * 400) / (16 * 16);

    for (i = 0; i < SURFACE_NUM; i++) {
        /* create coded buffer once for all
         * other VA buffers which won't be used again after vaRenderPicture.
         * so APP can always vaCreateBuffer for every frame
         * but coded buffer need to be mapped and accessed after vaRenderPicture/vaEndPicture
         * so VA won't maintain the coded buffer
         */
        va_status = vaCreateBuffer(va_dpy, context_id, VAEncCodedBufferType,
                                   codedbuf_size, 1, NULL, &coded_buf[i]);
        CHECK_VASTATUS(va_status, "vaCreateBuffer");
    }

    return 0;
}


static int release_encode()
{
    int i;

    vaDestroySurfaces(va_dpy, &src_surface[0], SURFACE_NUM);
    vaDestroySurfaces(va_dpy, &ref_surface[0], SURFACE_NUM);

    for (i = 0; i < SURFACE_NUM; i++)
        vaDestroyBuffer(va_dpy, coded_buf[i]);

    vaDestroyContext(va_dpy, context_id);
    vaDestroyConfig(va_dpy, config_id);

    return 0;
}

static int deinit_va()
{
    vaTerminate(va_dpy);

    va_close_display(va_dpy);

    return 0;
}


/*
 * Return displaying order with specified periods and encoding order
 * displaying_order: displaying order
 * frame_type: frame type
 */
void encoding2display_order(
    unsigned long long encoding_order, int intra_period,
    unsigned long long *displaying_order,
    int *frame_type)
{

    // simple case for IPPP av1

    *displaying_order = encoding_order;
    // all KEY FRAME *frame_type = KEY_FRAME;
    *frame_type = (encoding_order % intra_period) ? INTER_FRAME : KEY_FRAME;
    return;

}

static void
fill_sps_header()
{
    memset(&sh, 0, sizeof(sh));

    sh.seq_level_idx[0] = ips.level;

    sh.frame_width_bits = 15;
    sh.frame_height_bits = 15;
    sh.sbSize = 64;
    sh.order_hint_bits_minus1 = 8 - 1;
    sh.enable_cdef = 1;
    sh.enable_order_hint = 1;
    sh.color_config.separate_uv_delta_q = 1;

}

static void
fill_pps_header(uint64_t displaying_order)
{

    fh.show_existing_frame = 0;
    fh.frame_to_show_map_idx = 0;
    fh.frame_presentation_time = 0;
    fh.display_frame_id = 0;
    fh.frame_type = current_frame_type;
    fh.show_frame = 1;
    fh.showable_frame = 1;
    fh.error_resilient_mode = (fh.frame_type == KEY_FRAME) ? 1 : 0;
    fh.disable_cdf_update = 0;
    fh.allow_screen_content_tools = 0;
    fh.force_integer_mv = 0;
    fh.frame_size_override_flag = 0;
    fh.order_hint = displaying_order; //for I/P frame
    fh.primary_ref_frame = (fh.frame_type == KEY_FRAME || fh.frame_type == INTRA_ONLY_FRAME) ? PRIMARY_REF_NONE : 0;
    // depends on reference frames
    // by default, always refresh idx0
    fh.refresh_frame_flags = (fh.frame_type == KEY_FRAME || fh.frame_type == INTRA_ONLY_FRAME) ? 0xff : 0x01;
    fh.FrameWidth = ips.width;
    fh.FrameHeight = ips.height;
    fh.use_superres = 0;
    fh.SuperresDenom = 0;
    fh.UpscaledWidth = fh.FrameWidth;
    fh.RenderWidth = fh.FrameWidth;
    fh.RenderHeight = fh.FrameHeight;
    fh.allow_intrabc = 0;
    for(uint8_t i = 0; i < REFS_PER_FRAME; i++)
        fh.ref_frame_idx[i] = 0;
    fh.allow_high_precision_mv = 0;
    fh.interpolation_filter = 0; 
    fh.use_ref_frame_mvs = 0;
    fh.disable_frame_end_update_cdf = 0;
    fh.sbCols = ((fh.FrameWidth+63)&(~63))/64;
    fh.sbRows = ((fh.FrameHeight+63)&(~63))/64;
    fh.sbSize = 64;
    fh.tile_info.uniform_tile_spacing_flag = 1;
    fh.tile_info.context_update_tile_id = 0;
    fh.quantization_params.base_q_idx = ips.base_qindex;
    fh.quantization_params.DeltaQYDc = 0;
    fh.quantization_params.DeltaQUDc = 0;
    fh.quantization_params.DeltaQUAc = 0;
    fh.quantization_params.DeltaQVDc = 0;
    fh.quantization_params.DeltaQVAc = 0;
    fh.quantization_params.using_qmatrix = 0;
    fh.quantization_params.qm_y = 15;
    fh.quantization_params.qm_u = 15;
    fh.quantization_params.qm_v = 15;
    fh.delta_q_present = 0;
    fh.delta_q_res = 0;
    fh.delta_lf_present = 1;
    fh.delta_lf_res = 0;
    fh.delta_lf_multi = 1;
    fh.CodedLossless = 0;
    fh.AllLossless = 0;
    fh.cdef_params.cdef_damping = 5;
    fh.cdef_params.cdef_bits = 3;
    fh.cdef_params.cdef_y_pri_strength[0] = 9;
    fh.cdef_params.cdef_y_sec_strength[0] = 0;
    fh.cdef_params.cdef_uv_pri_strength[0] = 9;
    fh.cdef_params.cdef_uv_sec_strength[0] = 0;

    fh.cdef_params.cdef_y_pri_strength[1] = 12;
    fh.cdef_params.cdef_y_sec_strength[1] = 2;
    fh.cdef_params.cdef_uv_pri_strength[1] = 12;
    fh.cdef_params.cdef_uv_sec_strength[1] = 2;

    fh.cdef_params.cdef_y_pri_strength[2] = 0;
    fh.cdef_params.cdef_y_sec_strength[2] = 0;
    fh.cdef_params.cdef_uv_pri_strength[2] = 0;
    fh.cdef_params.cdef_uv_sec_strength[2] = 0;

    fh.cdef_params.cdef_y_pri_strength[3] = 6;
    fh.cdef_params.cdef_y_sec_strength[3] = 0;
    fh.cdef_params.cdef_uv_pri_strength[3] = 6;
    fh.cdef_params.cdef_uv_sec_strength[3] = 0;

    fh.cdef_params.cdef_y_pri_strength[4] = 2;
    fh.cdef_params.cdef_y_sec_strength[4] = 0;
    fh.cdef_params.cdef_uv_pri_strength[4] = 2;
    fh.cdef_params.cdef_uv_sec_strength[4] = 0;

    fh.cdef_params.cdef_y_pri_strength[5] = 4;
    fh.cdef_params.cdef_y_sec_strength[5] = 1;
    fh.cdef_params.cdef_uv_pri_strength[5] = 4;
    fh.cdef_params.cdef_uv_sec_strength[5] = 1;

    fh.cdef_params.cdef_y_pri_strength[6] = 1;
    fh.cdef_params.cdef_y_sec_strength[6] = 0;
    fh.cdef_params.cdef_uv_pri_strength[6] = 1;
    fh.cdef_params.cdef_uv_sec_strength[6] = 0;

    fh.cdef_params.cdef_y_pri_strength[7] = 2;
    fh.cdef_params.cdef_y_sec_strength[7] = 1;
    fh.cdef_params.cdef_uv_pri_strength[7] = 2;
    fh.cdef_params.cdef_uv_sec_strength[7] = 1;

    fh.loop_filter_params.loop_filter_level[0] = 15;
    fh.loop_filter_params.loop_filter_level[1] = 15;
    fh.loop_filter_params.loop_filter_level[2] = 8;
    fh.loop_filter_params.loop_filter_level[3] = 8;

    fh.loop_filter_params.loop_filter_sharpness = 0;
    fh.loop_filter_params.loop_filter_delta_enabled = 0;
    fh.loop_filter_params.loop_filter_delta_update = 0;

    fh.TxMode = TX_MODE_SELECT;
    fh.reference_select = ips.LDB ? 1 : 0;
    fh.skipModeAllowed = 0;
    fh.skipModeFrame[0] = 0;
    fh.skipModeFrame[1] = 0;
    fh.allow_warped_motion = 0;
    fh.reduced_tx_set = 1;

}


// brief interface with va, render bitstream
static void
va_render_packed_data(bitstream* bs)
{
    CHECK_BS_NULL(bs);
    VAEncPackedHeaderParameterBuffer packedheader_param_buffer;
    VABufferID packed_para_bufid = VA_INVALID_ID;
    VABufferID packed_data_bufid = VA_INVALID_ID;
    VABufferID render_id[2] = {VA_INVALID_ID};
    unsigned int length_in_bits = bs->bit_offset;

    unsigned char *packedpic_buffer = bs->buffer;
    VAStatus va_status;

    packedheader_param_buffer.type = VAEncPackedHeaderPicture; 
    packedheader_param_buffer.bit_length = length_in_bits;
    packedheader_param_buffer.has_emulation_bytes = 0;

    va_status = vaCreateBuffer(va_dpy,
                               context_id,
                               VAEncPackedHeaderParameterBufferType,
                               sizeof(packedheader_param_buffer), 1, &packedheader_param_buffer,
                               &packed_para_bufid);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");

    va_status = vaCreateBuffer(va_dpy,
                               context_id,
                               VAEncPackedHeaderDataBufferType,
                               (length_in_bits + 7) / 8, 1, packedpic_buffer,
                               &packed_data_bufid);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");

    render_id[0] = packed_para_bufid;
    render_id[1] = packed_data_bufid;
    va_status = vaRenderPicture(va_dpy, context_id, render_id, 2);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    //free(packedpic_buffer); free outside this function call

    if (packed_para_bufid != VA_INVALID_ID) {
        vaDestroyBuffer(va_dpy, packed_para_bufid);
        packed_para_bufid = VA_INVALID_ID;
    }
    if (packed_data_bufid != VA_INVALID_ID) {
        vaDestroyBuffer(va_dpy, packed_data_bufid);
        packed_data_bufid = VA_INVALID_ID;
    }

}

static void
render_ivf_frame_header()
{
    // write 12 empty byte to driver
    // IVF frame header is filled after encoding
    // first 4 byte is u32 for bit stream length
    // last 8 byte is u64 for display order
    bitstream bs;
    bitstream_start(&bs);

    for (size_t i = 0; i < 12; i++)
    {
        put_ui(&bs, 0x00, 8);
    }

    va_render_packed_data(&bs);

    bitstream_free(&bs);
}

static void
render_ivf_header()
{
    bitstream bs;
    bitstream_start(&bs);
    uint32_t ivfSeqHeader[11] = {0x46494B44, 0x00200000, 0x31305641,
    (uint32_t)(fh.UpscaledWidth + (fh.FrameHeight << 16)),
    ips.frame_rate_extN,// FrameRateExtN
    ips.frame_rate_extD,// FrameRateExtD
    ips.frame_count/*numFramesInFile*/,
    0x00000000,
    0,0,0 };

    // 
    uint8_t* hdr = (uint8_t*) ivfSeqHeader;
    for (size_t i = 0; i < 44; i++)
    {
        put_ui(&bs, hdr[i], 8);
    }

    va_render_packed_data(&bs);

    bitstream_free(&bs);
}

static void
render_TD()
{
    // OBU_TEMPORAL_DELIMITER
    bitstream bs;
    bitstream_start(&bs);
    put_ui(&bs, 0x12, 8);
    put_ui(&bs, 0x00, 8);

    va_render_packed_data(&bs);

    bitstream_free(&bs);
}


static void
build_sps_buffer(VAEncSequenceParameterBufferAV1* sps)
{
    CHECK_NULL(sps);

    sps->seq_profile = (uint8_t)sh.seq_profile;
    sps->seq_level_idx = (uint8_t)(sh.seq_level_idx[0]);

    sps->intra_period = ips.intra_period;
    sps->ip_period    = ips.ip_period;

    sps->bits_per_second = ips.target_bitrate;;

    sps->order_hint_bits_minus_1 = (uint8_t)(sh.order_hint_bits_minus1);

    sps->seq_fields.bits.still_picture              = sh.still_picture;
    sps->seq_fields.bits.enable_filter_intra        = sh.enable_filter_intra;
    sps->seq_fields.bits.enable_intra_edge_filter   = sh.enable_intra_edge_filter;
    sps->seq_fields.bits.enable_interintra_compound = sh.enable_interintra_compound;
    sps->seq_fields.bits.enable_masked_compound     = sh.enable_masked_compound;
    sps->seq_fields.bits.enable_warped_motion       = sh.enable_warped_motion;
    sps->seq_fields.bits.enable_dual_filter         = sh.enable_dual_filter;
    sps->seq_fields.bits.enable_order_hint          = sh.enable_order_hint;
    sps->seq_fields.bits.enable_jnt_comp            = sh.enable_jnt_comp;
    sps->seq_fields.bits.enable_ref_frame_mvs       = sh.enable_ref_frame_mvs;
    sps->seq_fields.bits.enable_superres            = sh.enable_superres;
    sps->seq_fields.bits.enable_cdef                = sh.enable_cdef;
    sps->seq_fields.bits.enable_restoration         = sh.enable_restoration;
    sps->seq_fields.bits.bit_depth_minus8           = ips.bit_depth - 8;
    sps->seq_fields.bits.subsampling_x              = 0;
    sps->seq_fields.bits.subsampling_y              = 0;

}


static void
render_sequence()
{
    VABufferID seq_param_buf_id = VA_INVALID_ID;
    VAStatus va_status;

    VAEncSequenceParameterBufferAV1 sps_buffer;
    memset(&sps_buffer, 0, sizeof(sps_buffer));
    build_sps_buffer(&sps_buffer);

    va_status = vaCreateBuffer(va_dpy, context_id, VAEncSequenceParameterBufferType,
                               sizeof(sps_buffer), 1, &sps_buffer, &seq_param_buf_id);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");;

    va_status = vaRenderPicture(va_dpy, context_id, &seq_param_buf_id, 1);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    if (seq_param_buf_id != VA_INVALID_ID) {
        vaDestroyBuffer(va_dpy, seq_param_buf_id);
        seq_param_buf_id = VA_INVALID_ID;
    }

}

static void
render_rc_buffer()
{
    VABufferID rc_param_buf = VA_INVALID_ID;
    VAStatus va_status;
    VABufferID render_id = VA_INVALID_ID;

    VAEncMiscParameterBuffer *misc_param;
    VAEncMiscParameterRateControl *misc_rate_ctrl;

    va_status = vaCreateBuffer(va_dpy, context_id,
                            VAEncMiscParameterBufferType,
                            sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterRateControl),
                            1, NULL, &rc_param_buf);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");

    vaMapBuffer(va_dpy, rc_param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeRateControl;
    misc_rate_ctrl = (VAEncMiscParameterRateControl *)misc_param->data;
    memset(misc_rate_ctrl, 0, sizeof(*misc_rate_ctrl));
    misc_rate_ctrl->bits_per_second = ips.max_bitrate;
    misc_rate_ctrl->target_percentage = (int)(100.0 * (double)ips.target_bitrate / (double)ips.max_bitrate);
    vaUnmapBuffer(va_dpy, rc_param_buf);

    render_id = rc_param_buf;

    va_status = vaRenderPicture(va_dpy, context_id, &render_id, 1);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    if (rc_param_buf != VA_INVALID_ID) 
    {
        vaDestroyBuffer(va_dpy, rc_param_buf);
        rc_param_buf = VA_INVALID_ID;
    }
}


static void
render_hrd_buffer()
{
    VABufferID param_buf = VA_INVALID_ID;
    VAStatus va_status;
    VABufferID render_id = VA_INVALID_ID;

    VAEncMiscParameterBuffer *misc_param;
    VAEncMiscParameterHRD *misc_hrd;

    va_status = vaCreateBuffer(va_dpy, context_id,
                            VAEncMiscParameterBufferType,
                            sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterHRD),
                            1, NULL, &param_buf);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");

    vaMapBuffer(va_dpy, param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeHRD;
    misc_hrd = (VAEncMiscParameterHRD *)misc_param->data;
    memset(misc_hrd, 0, sizeof(*misc_hrd));

    misc_hrd->initial_buffer_fullness = ips.initial_buffer_fullness;
    misc_hrd->buffer_size = ips.buffer_size;

    vaUnmapBuffer(va_dpy, param_buf);

    render_id = param_buf;

    va_status = vaRenderPicture(va_dpy, context_id, &render_id, 1);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    if (param_buf != VA_INVALID_ID) 
    {
        vaDestroyBuffer(va_dpy, param_buf);
        param_buf = VA_INVALID_ID;
    }
}


static void
render_fr_buffer()
{
    VABufferID param_buf = VA_INVALID_ID;
    VAStatus va_status;
    VABufferID render_id = VA_INVALID_ID;

    VAEncMiscParameterBuffer *misc_param;
    VAEncMiscParameterFrameRate *misc_fr;

    va_status = vaCreateBuffer(va_dpy, context_id,
                            VAEncMiscParameterBufferType,
                            sizeof(VAEncMiscParameterBuffer) + sizeof(VAEncMiscParameterFrameRate),
                            1, NULL, &param_buf);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");

    vaMapBuffer(va_dpy, param_buf, (void **)&misc_param);
    misc_param->type = VAEncMiscParameterTypeFrameRate;
    misc_fr = (VAEncMiscParameterFrameRate *)misc_param->data;
    memset(misc_fr, 0, sizeof(*misc_fr));

    misc_fr->framerate = ips.frame_rate_extN | (ips.frame_rate_extD << 16);

    vaUnmapBuffer(va_dpy, param_buf);

    render_id = param_buf;

    va_status = vaRenderPicture(va_dpy, context_id, &render_id, 1);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    if (param_buf != VA_INVALID_ID) 
    {
        vaDestroyBuffer(va_dpy, param_buf);
        param_buf = VA_INVALID_ID;
    }
}

static void
render_misc_buffer()
{
    render_rc_buffer();
    render_hrd_buffer();
    render_fr_buffer();
}



static void
render_tile_group()
{
    VABufferID tile_param_buf_id = VA_INVALID_ID;
    VAStatus va_status;

    VAEncTileGroupBufferAV1 tile_group_buffer = {0}; //default setting

    va_status = vaCreateBuffer(va_dpy, context_id, VAEncSliceParameterBufferType,
                               sizeof(tile_group_buffer), 1, &tile_group_buffer, &tile_param_buf_id);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");;

    va_status = vaRenderPicture(va_dpy, context_id, &tile_param_buf_id, 1);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    if (tile_param_buf_id != VA_INVALID_ID) {
        vaDestroyBuffer(va_dpy, tile_param_buf_id);
        tile_param_buf_id = VA_INVALID_ID;
    }

}


static void
pack_obu_header(bitstream *bs, int obu_type, uint32_t obu_extension_flag)
{
    put_ui(bs, 0, 1); //obu_forbidden_bit
    put_ui(bs, obu_type, 4); //type
    put_ui(bs, obu_extension_flag, 1);
    put_ui(bs, 1, 1); //obu_has_size_field
    put_ui(bs, 0, 1); //reserved

    if (obu_extension_flag) {
        //  Obu Extension Header
        // not written to bitstream by default
    }
}



static void
pack_obu_header_size(bitstream *bs, 
                    uint32_t value,
                    uint8_t fixed_output_len)
{
    // pack leb128
    uint64_t leb128_buf = 0;
    uint8_t leb128_size = 0;

    uint8_t* buf = (uint8_t*)(&leb128_buf);

    if (!fixed_output_len)
    {
        // general encoding
        do {
            buf[leb128_size] = value & 0x7fU;
            if (value >>= 7)
            {
                buf[leb128_size] |= 0x80U;
            }
            leb128_size++;
        } while (value);
    }
    else
    {
        // get fixed len of output, in this case, LEB128 will have fixed length
        uint8_t value_byte_count = 0;
        do {
            buf[value_byte_count++] = value & 0x7fU;
            value >>= 7;
        } while (value);

        for (int i = 0; i < fixed_output_len - 1; i++)
        {
            buf[i] |= 0x80U;
            leb128_size++;
        }
        leb128_size++;
    }

    // write to bitstream
    const uint8_t* ptr = (uint8_t*)(&leb128_buf);
    for (uint8_t i = 0; i < leb128_size; i++)
        put_ui(bs, ptr[i], 8);
}

static void
pack_operating_points(bitstream* bs)
{
    put_ui(bs, sh.operating_points_cnt_minus_1, 5);
    
    for(uint8_t i = 0;i <= sh.operating_points_cnt_minus_1;i++)
    {
        //put_ui(bs, sh.operating_point_idc[i], 12);
        put_ui(bs, sh.operating_point_idc[i] >> 4, 8);
        put_ui(bs, sh.operating_point_idc[i] & 0x9f, 4);
        
        put_ui(bs, sh.seq_level_idx[i], 5);
        if(sh.seq_level_idx[i]>7)
            put_ui(bs, sh.seq_tier[i], 1);
    }
}

static void
pack_frame_size_info(bitstream* bs)
{
    //pack frame size info
    put_ui(bs, 15, 4);//frame_width_bits_minus_1
    put_ui(bs, 15, 4);//frame_height_bits_minus_1
    put_ui(bs, fh.UpscaledWidth - 1, 16);//max_frame_width_minus_1
    put_ui(bs, fh.FrameHeight - 1, 16);//max_frame_height_minus_1
    // end of pack frame size info
}


static void
pack_seq_data(bitstream *bs)
{
    put_ui(bs, sh.seq_profile, 3);
    put_ui(bs, sh.still_picture, 1);
    put_ui(bs, 0, 1);//reduced_still_picture_header
    put_ui(bs, 0, 1);//timing_info_present_flag
    put_ui(bs, 0, 1);//initial_display_delay_present_flag
    pack_operating_points(bs);

    pack_frame_size_info(bs);


    put_ui(bs, 0, 1);//frame_id_numbers_present_flag (affects FH)

    put_ui(bs, 0, 1);//use_128x128_superblock
    put_ui(bs, sh.enable_filter_intra, 1);//enable_filter_intra
    put_ui(bs, sh.enable_intra_edge_filter, 1);//enable_intra_edge_filter
    put_ui(bs, sh.enable_interintra_compound, 1);//enable_interintra_compound
    put_ui(bs, sh.enable_masked_compound, 1);//enable_masked_compound
    put_ui(bs, sh.enable_warped_motion, 1);//enable_warped_motion
    put_ui(bs, sh.enable_dual_filter, 1);//enable_dual_filter
    put_ui(bs, sh.enable_order_hint, 1);//enable_order_hint

    if (sh.enable_order_hint)
    {
        put_ui(bs, 0, 1); //enable_jnt_comp
        put_ui(bs, fh.use_ref_frame_mvs, 1);//enable_ref_frame_mvs
    }

    put_ui(bs, 1, 1);//seq_choose_screen_content_tools
    put_ui(bs, sh.seq_force_integer_mv, 1);//seq_choose_integer_mv

    if (!sh.seq_force_integer_mv)
    {
        put_ui(bs, 0, 1); //seq_force_integer_mv
    }

    if (sh.enable_order_hint)
    {
        put_ui(bs, sh.order_hint_bits_minus1, 3);//affects FH
    }

    put_ui(bs, sh.enable_superres, 1);//enable_superres
    put_ui(bs, sh.enable_cdef, 1);//enable_cdef
    put_ui(bs, sh.enable_restoration, 1);//enable_restoration

    // pack color config
    put_ui(bs, sh.color_config.BitDepth == BITDEPTH_10 ? 1 : 0, 1);
    if (sh.seq_profile != 1)
        put_ui(bs, 0, 1);; //mono_chrome
        
    put_ui(bs, sh.color_config.color_description_present_flag, 1);

    if (sh.color_config.color_description_present_flag)
    {
        put_ui(bs, sh.color_config.color_primaries, 8);
        put_ui(bs, sh.color_config.transfer_characteristics, 8);
        put_ui(bs, sh.color_config.matrix_coefficients, 8);
    }

    put_ui(bs, sh.color_config.color_range, 1);//color_range

    if (sh.seq_profile == 0)
        put_ui(bs, 0, 2); //chroma_sample_position

    put_ui(bs, sh.color_config.separate_uv_delta_q, 1); //separate_uv_delta_q

    put_ui(bs, 0, 1);//film_grain_params_present

    put_trailing_bits(bs);
}

static void
build_packed_seq_header(bitstream* bs)
{
    CHECK_BS_NULL(bs);
    CHECK_CONDITION(bs->bit_offset == 0);
    // handle vairable length
    // seq obu data
    bitstream obu_data;
    bitstream_start(&obu_data);
    pack_seq_data(&obu_data);

    uint32_t obu_extension_flag = sh.operating_points_cnt_minus_1 ? 1 : 0;
    pack_obu_header(bs, OBU_SEQUENCE_HEADER, obu_extension_flag);

    //calculate data size
    uint32_t obu_size_in_bytes = (obu_data.bit_offset + 7) / 8;
    pack_obu_header_size(bs, obu_size_in_bytes, 0);
    
    bitstream_cat(bs, &obu_data);
}

static int
render_packedsequence()
{
    int len;
    bitstream bs;
    bitstream_start(&bs);

    build_packed_seq_header(&bs);

    len = (bs.bit_offset + 7) / 8;

    va_render_packed_data(&bs);

    bitstream_free(&bs);

    return len;
}

static void
pack_show_existing_frame(bitstream* bs)
{
    return; //only for B frame, not enable by default
}


static void
pack_show_frame(bitstream* bs)
{
    put_ui(bs, fh.show_frame, 1);
    if(!fh.show_frame)
        put_ui(bs, fh.showable_frame, 1);
}

static void
pack_error_resilient(bitstream* bs)
{
    if (!(fh.frame_type == SWITCH_FRAME || (fh.frame_type == KEY_FRAME && fh.show_frame)))
        put_ui(bs, 0, 1); //error_resilient_mode
}


static void
pack_ref_frame_flags(bitstream* bs, uint8_t error_resilient_mode, uint8_t isI)
{
    uint8_t primary_ref_frame = PRIMARY_REF_NONE;
    if(isI || error_resilient_mode) 
        primary_ref_frame = PRIMARY_REF_NONE;
    else
        put_ui(bs, 0, 3); //primary_ref_frame
    if (!(fh.frame_type == SWITCH_FRAME || (fh.frame_type == KEY_FRAME && fh.show_frame)))
        put_ui(bs, fh.refresh_frame_flags, NUM_REF_FRAMES);
}

static void
pack_interpolation_filter(bitstream* bs)
{
    const uint8_t is_filter_switchable = (fh.interpolation_filter == 4 ? 1 : 0);
    put_ui(bs, is_filter_switchable, 1);//is_filter_switchable
    if (!is_filter_switchable)
    {
        put_ui(bs, fh.interpolation_filter, 2);//interpolation_filter
    }
}

static void
pack_render_size(bitstream* bs)
{
    uint32_t render_and_frame_size_different = 0;

    put_ui(bs, render_and_frame_size_different, 1);//render_and_frame_size_different

    if (render_and_frame_size_different == 1)
    {
        put_ui(bs, fh.RenderWidth - 1, 16);//render_width_minus_1
        put_ui(bs, fh.RenderHeight - 1, 16);//render_height_minus_1
    }
}


static void
pack_frame_size(bitstream *bs)
{
    if (fh.frame_size_override_flag)
    {
        put_ui(bs, fh.UpscaledWidth - 1, sh.frame_width_bits + 1); //frame_width_minus_1
        put_ui(bs, fh.FrameHeight - 1, sh.frame_height_bits + 1); //frame_height_minus_1
    }

}


static void
pack_frame_size_with_refs(bitstream* bs)
{
    CHECK_BS_NULL(bs);
    uint32_t found_ref = 0;

    for (int8_t ref = 0; ref < REFS_PER_FRAME; ref++)
        put_ui(bs, found_ref, 1);//found_ref

    // if found_ref == 9
    pack_frame_size(bs);
    pack_render_size(bs);


}

static void
pack_frame_ref_info(bitstream* bs, uint8_t error_resilient_mode)
{
    if (sh.enable_order_hint)
        put_ui(bs, 0, 1); //frame_refs_short_signaling

    for (uint8_t ref = 0; ref < REFS_PER_FRAME; ref++)
        put_ui(bs, fh.ref_frame_idx[ref], REF_FRAMES_LOG2);

    if (fh.frame_size_override_flag && !error_resilient_mode)
    {
        pack_frame_size_with_refs(bs);
    }
    else
    {
        pack_frame_size(bs);
        pack_render_size(bs);
    }

    put_ui(bs, fh.allow_high_precision_mv, 1); //allow_high_precision_mv

    //PackInterpolationFilter(bs, fh);
    pack_interpolation_filter(bs);

    put_ui(bs, 0, 1);//is_motion_switchable

    if (fh.use_ref_frame_mvs)
        put_ui(bs, 1, 1); //use_ref_frame_mvs
}





static void
pack_tile_info(bitstream* bs)
{
    // use single tile by default
    put_ui(bs, 1, 1);//uniform_tile_spacing_flag
    put_ui(bs, 0, 1);//increment_tile_cols_log2
    put_ui(bs, 0, 1);//increment_tile_rows_log2
}

static uint16_t
write_SU(int32_t value, uint16_t n)
{
    int16_t signMask = 1 << (n - 1);
    if (value & signMask)
    {
        value = value - 2 * signMask;
    }
    return value;
}

static void
pack_delta_q_value(bitstream* bs, int32_t deltaQ)
{
    if (deltaQ)
    {
        put_ui(bs, 1, 1);
        put_ui(bs, write_SU(deltaQ, 7), 7);
    }
    else
        put_ui(bs, 0, 1);
}

static void
pack_quantization_params(bitstream* bs)
{
    put_ui(bs, fh.quantization_params.base_q_idx, 8); //base_q_idx

    pack_delta_q_value(bs, fh.quantization_params.DeltaQYDc);

    bool diff_uv_delta = false;
    if (fh.quantization_params.DeltaQUDc != fh.quantization_params.DeltaQVDc
        || fh.quantization_params.DeltaQUAc != fh.quantization_params.DeltaQVAc)
        diff_uv_delta = true;

    if (sh.color_config.separate_uv_delta_q)
        put_ui(bs, diff_uv_delta, 1);

    pack_delta_q_value(bs, fh.quantization_params.DeltaQUDc);
    pack_delta_q_value(bs, fh.quantization_params.DeltaQUAc);

    if (diff_uv_delta)
    {
        pack_delta_q_value(bs, fh.quantization_params.DeltaQVDc);
        pack_delta_q_value(bs, fh.quantization_params.DeltaQVAc);
    }

    put_ui(bs, fh.quantization_params.using_qmatrix, 1);//using_qmatrix
    if (fh.quantization_params.using_qmatrix)
    {
        put_ui(bs, fh.quantization_params.qm_y, 4);
        put_ui(bs, fh.quantization_params.qm_u, 4);
        if (sh.color_config.separate_uv_delta_q)
            put_ui(bs, fh.quantization_params.qm_v, 4);
    }
}


static void
pack_loop_filter_params(bitstream* bs)
{
    if (fh.CodedLossless || fh.allow_intrabc)
        return;
    
    put_ui(bs, fh.loop_filter_params.loop_filter_level[0], 6);//loop_filter_level[0]
    put_ui(bs, fh.loop_filter_params.loop_filter_level[1], 6);//loop_filter_level[1]

    if (fh.loop_filter_params.loop_filter_level[0] || fh.loop_filter_params.loop_filter_level[1])
    {

        put_ui(bs, fh.loop_filter_params.loop_filter_level[2], 6);//loop_filter_level[2]
        put_ui(bs, fh.loop_filter_params.loop_filter_level[3], 6);//loop_filter_level[3]
    }

    put_ui(bs, fh.loop_filter_params.loop_filter_sharpness, 3); //loop_filter_sharpness
    put_ui(bs, 0, 1); //loop_filter_delta_enabled

}

static void
pack_cdef_params(bitstream* bs)
{
    if (!sh.enable_cdef || fh.CodedLossless || fh.allow_intrabc)
        return;

    uint16_t num_planes = sh.color_config.mono_chrome ? 1 : 3;

    put_ui(bs, fh.cdef_params.cdef_damping - 3, 2);//cdef_damping_minus_3
    put_ui(bs, fh.cdef_params.cdef_bits, 2);//cdef_bits

    for (uint16_t i = 0; i < (1 << fh.cdef_params.cdef_bits); ++i)
    {
        put_ui(bs, fh.cdef_params.cdef_y_pri_strength[i], 4);//cdef_y_pri_strength[0]
        put_ui(bs, fh.cdef_params.cdef_y_sec_strength[i], 2);//cdef_y_sec_strength[0]

        if (num_planes > 1)
        {
            put_ui(bs, fh.cdef_params.cdef_uv_pri_strength[i], 4);//cdef_uv_pri_strength[0]
            put_ui(bs, fh.cdef_params.cdef_uv_sec_strength[i], 2);//cdef_uv_sec_strength[0]
        }
    }
}


static void
pack_lr_params(bitstream* bs)
{
    if (fh.AllLossless || fh.allow_intrabc || !sh.enable_restoration)
        return;

    bool usesLR = false;
    bool usesChromaLR = false;

    for (int i = 0; i < MAX_MB_PLANE; i++)
    {
        put_ui(bs, fh.lr_params.lr_type[i], 2);
        if (fh.lr_params.lr_type[i] != RESTORE_NONE)
        {
            usesLR = true;
            if (i > 0)
            {
                usesChromaLR = true;
            }
        }
    }

    if (usesLR)
    {
        put_ui(bs, fh.lr_params.lr_unit_shift, 1);

        if (sh.sbSize != 1 && fh.lr_params.lr_unit_shift) 
        {
            put_ui(bs, fh.lr_params.lr_unit_extra_shift, 1);
        }

        if (sh.color_config.subsampling_x && sh.color_config.subsampling_y && usesChromaLR)
        {
            put_ui(bs, fh.lr_params.lr_uv_shift, 1);
        }
    }
}


static void
pack_delta_q_params(bitstream* bs)
{
    if (fh.quantization_params.base_q_idx)
        put_ui(bs, fh.delta_q_present, 1); //delta_q_present
    if (fh.delta_q_present)
    {
        put_ui(bs, 0, 2); //delta_q_res
        put_ui(bs, fh.delta_lf_present, 1); //delta_lf_present
        put_ui(bs, 0, 2); //delta_lf_res
        put_ui(bs, fh.delta_lf_multi, 1); //delta_lf_multi
    }
}

static void
pack_frame_reference_mode(bitstream* bs, bool frameIsIntra)
{
    if (frameIsIntra)
        return;
    put_ui(bs, fh.reference_select, 1); //reference_select
}

static void
pack_skip_mode_params(bitstream* bs)
{
    if (fh.skipModeAllowed)
        put_ui(bs, fh.skip_mode_present, 1); //skip_mode_present
}

static void
pack_wrapped_motion(bitstream* bs, bool frameIsIntra)
{
    if (frameIsIntra)
        return;

    if (sh.enable_warped_motion)
        put_ui(bs, 0, 1); //allow_warped_motion
}

static void
pack_global_motion_params(bitstream* bs, bool frameIsIntra)
{
    if (frameIsIntra)
        return;

    for (uint8_t i = LAST_FRAME; i <= ALTREF_FRAME; i++)
        put_ui(bs, 0, 1); //is_global[7]
}

static void
pack_frame_header(bitstream* bs)
{
    const uint8_t isI = (fh.frame_type == INTRA_ONLY_FRAME || fh.frame_type == KEY_FRAME);

    put_ui(bs, fh.frame_type, 2);

    pack_show_frame(bs);

    uint8_t error_resilient_mode = 0;
    pack_error_resilient(bs);
    
    put_ui(bs, fh.disable_cdf_update, 1);
    put_ui(bs, fh.allow_screen_content_tools, 1);
    put_ui(bs, fh.frame_size_override_flag, 1);

    // pack order hint
    if(sh.enable_order_hint)
        put_ui(bs, fh.order_hint, sh.order_hint_bits_minus1 + 1);

    // PackRefFrameFlags
    pack_ref_frame_flags(bs, error_resilient_mode, isI);

    if (!isI)
    {
        pack_frame_ref_info(bs, error_resilient_mode);
    }
    else
    {
        pack_frame_size(bs);
        pack_render_size(bs);
        if (fh.allow_screen_content_tools && fh.UpscaledWidth == fh.FrameWidth)
            put_ui(bs, fh.allow_intrabc, 1);
    }


    if (!fh.disable_cdf_update)
        put_ui(bs, fh.disable_frame_end_update_cdf, 1); //disable_frame_end_update_cdf

    pack_tile_info(bs);


    //quantization_params
    offsets.QIndexBitOffset = bs->bit_offset;
    pack_quantization_params(bs);


    //segmentation_params
    offsets.SegmentationBitOffset = bs->bit_offset;
    put_ui(bs, 0, 1); //segmentation_enabled

    offsets.SegmentationBitSize = bs->bit_offset - offsets.SegmentationBitOffset;

    pack_delta_q_params(bs);

    offsets.LoopFilterParamsBitOffset = bs->bit_offset;
    pack_loop_filter_params(bs);

    offsets.CDEFParamsBitOffset = bs->bit_offset;
    pack_cdef_params(bs);
    offsets.CDEFParamsSizeInBits = bs->bit_offset - offsets.CDEFParamsBitOffset;

    pack_lr_params(bs);

    const uint8_t tx_mode_select = fh.TxMode ? 1 : 0;
   
    if (!fh.CodedLossless)
    put_ui(bs, tx_mode_select, 1); //tx_mode_select

    pack_frame_reference_mode(bs, isI);
    pack_skip_mode_params(bs);
    pack_wrapped_motion(bs, isI);

    put_ui(bs, fh.reduced_tx_set, 1); //reduced_tx_set

    pack_global_motion_params(bs, isI);
}

static void
build_packed_pic_header(bitstream* bs)
{
    // handle vairable length
    // pack obu payload and then put header

    // pic obu data
    bitstream tmp;
    bitstream_start(&tmp);

    put_ui(&tmp, fh.show_existing_frame, 1); //show_existing_frame
    if (fh.show_existing_frame)
        pack_show_existing_frame(&tmp); // only for B frame
    else
        pack_frame_header(&tmp);


    offsets.FrameHdrOBUSizeInBits = tmp.bit_offset;

    const uint32_t obu_extension_flag = sh.operating_points_cnt_minus_1 ? 1 : 0;
    const uint32_t obu_header_offset  = bs->bit_offset;

    put_aligning_bits(&tmp);

    pack_obu_header(bs, OBU_FRAME, obu_extension_flag);

    offsets.FrameHdrOBUSizeByteOffset = (bs->bit_offset >> 3) + len_ivf_header + 2 + len_seq_header; // first frame with IVF header

    const uint32_t obu_size_in_bytes = (tmp.bit_offset + 7) / 8;
    pack_obu_header_size(bs, obu_size_in_bytes, fh.show_existing_frame? 0: 4);


    if (!fh.show_existing_frame)
    {
        // The offset is related to frame or frame header OBU. IVF, sequence, and other headers should not be counted.
        const uint32_t obuPayloadOffset     = bs->bit_offset - obu_header_offset;
        offsets.QIndexBitOffset           += obuPayloadOffset;
        offsets.SegmentationBitOffset     += obuPayloadOffset;
        offsets.LoopFilterParamsBitOffset += obuPayloadOffset;
        offsets.CDEFParamsBitOffset       += obuPayloadOffset;
        //offsets.CDEFParamsSizeInBits is not needed to be updated.
        offsets.FrameHdrOBUSizeInBits     += obuPayloadOffset;
    }


    bitstream_cat(bs, &tmp);
}

static void
render_packedpicture()
{
    bitstream bs;
    bitstream_start(&bs);

    build_packed_pic_header(&bs);

    va_render_packed_data(&bs);

    bitstream_free(&bs);
}

static void
fill_ref_params(VAEncPictureParameterBufferAV1* pps)
{
    CHECK_NULL(pps);
    if(fh.frame_type == KEY_FRAME)
    {
        return;
    }
    else if(fh.frame_type == INTER_FRAME)
    {
        // use last frame as reference
        pps->reference_frames[0] = ref_surface[((current_frame_display - 1) % SURFACE_NUM)];
        pps->ref_frame_ctrl_l0.fields.search_idx0 = LAST_FRAME;

        // for Low delay B
        pps->ref_frame_ctrl_l1.fields.search_idx0 = ips.LDB ? BWDREF_FRAME : INTRA_FRAME;
    }

}

static void
build_pps_buffer(VAEncPictureParameterBufferAV1* pps)
{
    CHECK_NULL(pps);
    // InitPPS
    memset(&(pps->reference_frames), VA_INVALID_ID, 8);

    //frame size
    pps->frame_height_minus_1  =(uint16_t)(fh.FrameHeight - 1);
    pps->frame_width_minus_1 = (uint16_t)(fh.UpscaledWidth - 1);

    //bitstream
    pps->coded_buf = coded_buf[current_slot];
    
    for(int k = 0; k < REFS_PER_FRAME; k++)
        pps->ref_frame_idx[k] = 0;

    pps->picture_flags.bits.use_ref_frame_mvs = fh.use_ref_frame_mvs;
    pps->picture_flags.bits.long_term_reference = 0;
    pps->picture_flags.bits.allow_intrabc = fh.allow_intrabc;

    pps->seg_id_block_size = 0;

    //quantizer
    pps->y_dc_delta_q = (uint8_t)(fh.quantization_params.DeltaQYDc);
    pps->u_dc_delta_q = (uint8_t)(fh.quantization_params.DeltaQUDc);
    pps->u_ac_delta_q = (uint8_t)(fh.quantization_params.DeltaQUAc);
    pps->v_dc_delta_q = (uint8_t)(fh.quantization_params.DeltaQVDc);
    pps->v_ac_delta_q = (uint8_t)(fh.quantization_params.DeltaQVAc);

    //other params
    pps->picture_flags.bits.error_resilient_mode = fh.error_resilient_mode;
    pps->interpolation_filter = (uint8_t)(fh.interpolation_filter);
    pps->picture_flags.bits.use_superres = fh.use_superres;
    pps->picture_flags.bits.allow_high_precision_mv = fh.allow_high_precision_mv;
    pps->picture_flags.bits.reduced_tx_set = fh.reduced_tx_set;
    pps->picture_flags.bits.palette_mode_enable = fh.allow_screen_content_tools;

    //tx_mod
    pps->mode_control_flags.bits.tx_mode = fh.TxMode;
    pps->temporal_id = 0;
    pps->superres_scale_denominator = (uint8_t)(fh.SuperresDenom);

    //q_matrix
    pps->qmatrix_flags.bits.using_qmatrix = fh.quantization_params.using_qmatrix;
    pps->qmatrix_flags.bits.qm_y = fh.quantization_params.qm_y;
    pps->qmatrix_flags.bits.qm_u = fh.quantization_params.qm_u;
    pps->qmatrix_flags.bits.qm_v = fh.quantization_params.qm_v;

    pps->picture_flags.bits.frame_type = fh.frame_type;
    pps->base_qindex     = (uint8_t)fh.quantization_params.base_q_idx;
    pps->min_base_qindex = ips.MinBaseQIndex;
    pps->max_base_qindex = ips.MaxBaseQIndex;

    pps->order_hint = (uint8_t)(fh.order_hint);

    //reference frame
    pps->primary_ref_frame = (uint8_t)(fh.primary_ref_frame);
    pps->ref_frame_ctrl_l0.value = 0;
    pps->ref_frame_ctrl_l1.value = 0;
    fill_ref_params(pps);
    pps->refresh_frame_flags = fh.refresh_frame_flags;

    // //loop filter  
    // auto& lf = fh.loop_filter_params;
    pps->filter_level[0] = (uint8_t)(fh.loop_filter_params.loop_filter_level[0]);
    pps->filter_level[1] = (uint8_t)(fh.loop_filter_params.loop_filter_level[1]);
    pps->filter_level_u  = (uint8_t)(fh.loop_filter_params.loop_filter_level[2]);
    pps->filter_level_v  = (uint8_t)(fh.loop_filter_params.loop_filter_level[3]);
    pps->loop_filter_flags.bits.sharpness_level        = fh.loop_filter_params.loop_filter_sharpness;
    pps->loop_filter_flags.bits.mode_ref_delta_enabled = fh.loop_filter_params.loop_filter_delta_enabled;
    pps->loop_filter_flags.bits.mode_ref_delta_update  = fh.loop_filter_params.loop_filter_delta_update;

    for(int k = 0;k < 8;k++)
        pps->ref_deltas[k] = 0;



    //block-level deltas
    pps->mode_control_flags.bits.delta_q_present  = fh.delta_q_present;
    pps->mode_control_flags.bits.delta_q_res  = fh.delta_q_res;
    pps->mode_control_flags.bits.delta_lf_res  = fh.delta_lf_res;
    pps->mode_control_flags.bits.delta_lf_present = fh.delta_lf_present;
    pps->mode_control_flags.bits.delta_lf_multi   = fh.delta_lf_multi;

    pps->mode_control_flags.bits.reference_mode = fh.reference_select ?
        REFERENCE_MODE_SELECT : SINGLE_REFERENCE;
    pps->mode_control_flags.bits.skip_mode_present = fh.skip_mode_present;

    //tile
    pps->tile_cols = 1; 
    pps->width_in_sbs_minus_1[0] = (uint16_t)(((fh.UpscaledWidth+63)&(~63))/64 - 1);


    pps->tile_rows = 1;
    pps->height_in_sbs_minus_1[0] = (uint16_t)(((fh.FrameHeight+63)&(~63))/64 - 1);

    pps->context_update_tile_id = (uint8_t)(fh.tile_info.context_update_tile_id);

    //cdef
    if(sh.enable_cdef)
    {

        pps->cdef_damping_minus_3 = (uint8_t)(fh.cdef_params.cdef_damping - 3);
        pps->cdef_bits = (uint8_t)(fh.cdef_params.cdef_bits);

        for (uint8_t i = 0; i < CDEF_MAX_STRENGTHS; i++)
        {
            pps->cdef_y_strengths[i]  = (uint8_t)(fh.cdef_params.cdef_y_pri_strength[i] * CDEF_STRENGTH_DIVISOR + fh.cdef_params.cdef_y_sec_strength[i]);
            pps->cdef_uv_strengths[i] = (uint8_t)(fh.cdef_params.cdef_uv_pri_strength[i] * CDEF_STRENGTH_DIVISOR + fh.cdef_params.cdef_uv_sec_strength[i]);
        }
    }

    //loop restoration
    pps->loop_restoration_flags.bits.yframe_restoration_type  = (fh.lr_params.lr_type[0] == RESTORE_WIENER) ? 1 : 0;
    pps->loop_restoration_flags.bits.cbframe_restoration_type = (fh.lr_params.lr_type[1] == RESTORE_WIENER) ? 1 : 0;
    pps->loop_restoration_flags.bits.crframe_restoration_type = (fh.lr_params.lr_type[2] == RESTORE_WIENER) ? 1 : 0;
    pps->loop_restoration_flags.bits.lr_unit_shift            = fh.lr_params.lr_unit_shift;
    pps->loop_restoration_flags.bits.lr_uv_shift              = fh.lr_params.lr_uv_shift;

    //context
    pps->picture_flags.bits.disable_cdf_update = fh.disable_cdf_update;
    pps->picture_flags.bits.disable_frame_end_update_cdf = fh.disable_frame_end_update_cdf;
    pps->picture_flags.bits.disable_frame_recon = (fh.refresh_frame_flags == 0);

    pps->num_tile_groups_minus1 = 0;

    pps->tile_group_obu_hdr_info.bits.obu_extension_flag = 0;
    pps->tile_group_obu_hdr_info.bits.obu_has_size_field = 1;
    pps->tile_group_obu_hdr_info.bits.temporal_id = 0;
    pps->tile_group_obu_hdr_info.bits.spatial_id  = 0;

    //other params
    pps->picture_flags.bits.error_resilient_mode = fh.error_resilient_mode;
    pps->picture_flags.bits.enable_frame_obu     = 1;
    pps->reconstructed_frame = ref_surface[current_slot];

    //offsets need update
    pps->size_in_bits_frame_hdr_obu     = offsets.FrameHdrOBUSizeInBits;
    pps->byte_offset_frame_hdr_obu_size = offsets.FrameHdrOBUSizeByteOffset;
    pps->bit_offset_loopfilter_params   = offsets.LoopFilterParamsBitOffset;
    pps->bit_offset_qindex              = offsets.QIndexBitOffset;
    pps->bit_offset_segmentation        = offsets.SegmentationBitOffset;
    pps->bit_offset_cdef_params         = offsets.CDEFParamsBitOffset;
    pps->size_in_bits_cdef_params       = offsets.CDEFParamsSizeInBits;

    //q_matrix
    pps->qmatrix_flags.bits.using_qmatrix = fh.quantization_params.using_qmatrix;
    pps->qmatrix_flags.bits.qm_y = fh.quantization_params.qm_y;
    pps->qmatrix_flags.bits.qm_u = fh.quantization_params.qm_u;
    pps->qmatrix_flags.bits.qm_v = fh.quantization_params.qm_v;

    pps->skip_frames_reduced_size = 0;
}


static void
render_picture()
{
    VABufferID pic_param_buf_id = VA_INVALID_ID;
    VAStatus va_status;

    VAEncPictureParameterBufferAV1 pps_buffer;
    memset(&pps_buffer, 0, sizeof(pps_buffer));
    build_pps_buffer(&pps_buffer);

    va_status = vaCreateBuffer(va_dpy, context_id, VAEncPictureParameterBufferType,
                               sizeof(pps_buffer), 1, &pps_buffer, &pic_param_buf_id);
    CHECK_VASTATUS(va_status, "vaCreateBuffer");;

    va_status = vaRenderPicture(va_dpy, context_id, &pic_param_buf_id, 1);
    CHECK_VASTATUS(va_status, "vaRenderPicture");

    if (pic_param_buf_id != VA_INVALID_ID) {
        vaDestroyBuffer(va_dpy, pic_param_buf_id);
        pic_param_buf_id = VA_INVALID_ID;
    }

}

static int upload_source_YUV_once_for_all()
{
    int box_width = 8;
    int row_shift = 0;
    int i;

    for (i = 0; i < SURFACE_NUM; i++) {
        printf("\rLoading data into surface %d.....", i);
        upload_surface(va_dpy, src_surface[i], box_width, row_shift, 0);

        row_shift++;
        if (row_shift == (2 * box_width)) row_shift = 0;
    }
    printf("Complete surface loading\n");

    return 0;
}

static struct storage_task_t * storage_task_dequeue(void)
{
    struct storage_task_t *header;

    pthread_mutex_lock(&encode_mutex);

    header = storage_task_header;
    if (storage_task_header != NULL) {
        if (storage_task_tail == storage_task_header)
            storage_task_tail = NULL;
        storage_task_header = header->next;
    }

    pthread_mutex_unlock(&encode_mutex);

    return header;
}

static int load_surface(VASurfaceID surface_id, unsigned long long display_order)
{
    unsigned char *srcyuv_ptr = NULL, *src_Y = NULL, *src_U = NULL, *src_V = NULL;
    unsigned long long frame_start, mmap_start;
    char *mmap_ptr = NULL;
    int frame_size, mmap_size;

    if (srcyuv_fp == NULL)
        return 0;

    /* allow encoding more than srcyuv_frames */
    display_order = display_order % srcyuv_frames;
    frame_size = ips.width * ips.height * 3 / 2; /* for YUV420 */
    frame_start = display_order * frame_size;

    mmap_start = frame_start & (~0xfff);
    mmap_size = (frame_size + (frame_start & 0xfff) + 0xfff) & (~0xfff);
    mmap_ptr = mmap(0, mmap_size, PROT_READ, MAP_SHARED,
                    fileno(srcyuv_fp), mmap_start);
    if (mmap_ptr == MAP_FAILED) {
        printf("Failed to mmap YUV file (%s)\n", strerror(errno));
        return 1;
    }
    srcyuv_ptr = (unsigned char *)mmap_ptr + (frame_start & 0xfff);
    if (srcyuv_fourcc == VA_FOURCC_NV12) {
        src_Y = srcyuv_ptr;
        src_U = src_Y + ips.width * ips.height;
        src_V = NULL;
    } else if (srcyuv_fourcc == VA_FOURCC_IYUV ||
               srcyuv_fourcc == VA_FOURCC_YV12) {
        src_Y = srcyuv_ptr;
        if (srcyuv_fourcc == VA_FOURCC_IYUV) {
            src_U = src_Y + ips.width * ips.height;
            src_V = src_U + (ips.width / 2) * (ips.height / 2);
        } else { /* YV12 */
            src_V = src_Y + ips.width * ips.height;
            src_U = src_V + (ips.width / 2) * (ips.height / 2);
        }
    } else {
        printf("Unsupported source YUV format\n");
        exit(1);
    }

    upload_surface_yuv(va_dpy, surface_id,
                       srcyuv_fourcc, ips.width, ips.height,
                       src_Y, src_U, src_V);
    if (mmap_ptr)
        munmap(mmap_ptr, mmap_size);

    return 0;
}

static int save_codeddata(unsigned long long display_order, unsigned long long encode_order)
{
    VACodedBufferSegment *buf_list = NULL;
    VAStatus va_status;
    unsigned int coded_size = 0;

    va_status = vaMapBuffer(va_dpy, coded_buf[display_order % SURFACE_NUM], (void **)(&buf_list));
    CHECK_VASTATUS(va_status, "vaMapBuffer");

    long frame_start = ftell(coded_fp);

    while (buf_list != NULL) {
        coded_size += fwrite(buf_list->buf, 1, buf_list->size, coded_fp);
        buf_list = (VACodedBufferSegment *) buf_list->next;

        frame_size += coded_size;
    }

    long frame_end = ftell(coded_fp);
    vaUnmapBuffer(va_dpy, coded_buf[display_order % SURFACE_NUM]);

    if(encode_order == 0)
    {
        //first frame
        unsigned int ivf_size = coded_size - 32 - 12;
        fseek(coded_fp, frame_start + 32, SEEK_SET);
        fwrite(&ivf_size, 4, 1, coded_fp);
        fwrite(&display_order, 8, 1, coded_fp);
        fseek(coded_fp, frame_end, SEEK_SET);
    }
    else
    {
        //other frames
        unsigned int ivf_size = coded_size - 12;
        fseek(coded_fp, frame_start, SEEK_SET);
        fwrite(&ivf_size, 4, 1, coded_fp);
        fwrite(&display_order, 8, 1, coded_fp);
        fseek(coded_fp, frame_end, SEEK_SET);
    }
    

    printf("\n      "); /* return back to startpoint */
    switch (encode_order % 4) {
    case 0:
        printf("|");
        break;
    case 1:
        printf("/");
        break;
    case 2:
        printf("-");
        break;
    case 3:
        printf("\\");
        break;
    }
    printf("%08lld", encode_order);
    printf("(%06d bytes coded)\n", coded_size);

    fflush(coded_fp);

    return 0;
}

static int save_recyuv(VASurfaceID surface_id,
                       unsigned long long display_order,
                       unsigned long long encode_order)
{
    unsigned char *dst_Y = NULL, *dst_U = NULL, *dst_V = NULL;

    if (recyuv_fp == NULL)
        return 0;

    if (srcyuv_fourcc == VA_FOURCC_NV12) {
        int uv_size = 2 * (ips.width / 2) * (ips.height / 2);
        dst_Y = malloc(2 * uv_size);
        if (dst_Y == NULL) {
            printf("Failed to allocate memory for dst_Y\n");
            exit(1);
        }

        dst_U = malloc(uv_size);
        if (dst_U == NULL) {
            printf("Failed to allocate memory for dst_U\n");
            free(dst_Y);
            exit(1);
        }

        memset(dst_Y, 0, 2 * uv_size);
        memset(dst_U, 0, uv_size);
    } else if (srcyuv_fourcc == VA_FOURCC_IYUV ||
               srcyuv_fourcc == VA_FOURCC_YV12) {
        int uv_size = (ips.width / 2) * (ips.height / 2);
        dst_Y = malloc(4 * uv_size);
        if (dst_Y == NULL) {
            printf("Failed to allocate memory for dst_Y\n");
            exit(1);
        }

        dst_U = malloc(uv_size);
        if (dst_U == NULL) {
            printf("Failed to allocate memory for dst_U\n");
            free(dst_Y);
            exit(1);
        }

        dst_V = malloc(uv_size);
        if (dst_V == NULL) {
            printf("Failed to allocate memory for dst_V\n");
            free(dst_Y);
            free(dst_U);
            exit(1);
        }

        memset(dst_Y, 0, 4 * uv_size);
        memset(dst_U, 0, uv_size);
        memset(dst_V, 0, uv_size);
    } else {
        printf("Unsupported source YUV format\n");
        exit(1);
    }

    download_surface_yuv(va_dpy, surface_id,
                         srcyuv_fourcc, ips.width, ips.height,
                         dst_Y, dst_U, dst_V);
    fseek(recyuv_fp, display_order * ips.width * ips.height * 1.5, SEEK_SET);

    if (srcyuv_fourcc == VA_FOURCC_NV12) {
        int uv_size = 2 * (ips.width / 2) * (ips.height / 2);
        fwrite(dst_Y, uv_size * 2, 1, recyuv_fp);
        fwrite(dst_U, uv_size, 1, recyuv_fp);
    } else if (srcyuv_fourcc == VA_FOURCC_IYUV ||
               srcyuv_fourcc == VA_FOURCC_YV12) {
        int uv_size = (ips.width / 2) * (ips.height / 2);
        fwrite(dst_Y, uv_size * 4, 1, recyuv_fp);

        if (srcyuv_fourcc == VA_FOURCC_IYUV) {
            fwrite(dst_U, uv_size, 1, recyuv_fp);
            fwrite(dst_V, uv_size, 1, recyuv_fp);
        } else {
            fwrite(dst_V, uv_size, 1, recyuv_fp);
            fwrite(dst_U, uv_size, 1, recyuv_fp);
        }
    }

    if (dst_Y)
        free(dst_Y);
    if (dst_U)
        free(dst_U);
    if (dst_V)
        free(dst_V);

    fflush(recyuv_fp);

    return 0;
}

static void storage_task(unsigned long long display_order, unsigned long long encode_order)
{
    unsigned int tmp;
    VAStatus va_status;

    tmp = GetTickCount();
    va_status = vaSyncSurface(va_dpy, src_surface[display_order % SURFACE_NUM]);
    CHECK_VASTATUS(va_status, "vaSyncSurface");
    SyncPictureTicks += GetTickCount() - tmp;
    tmp = GetTickCount();
    save_codeddata(display_order, encode_order);
    SavePictureTicks += GetTickCount() - tmp;

    save_recyuv(ref_surface[display_order % SURFACE_NUM], display_order, encode_order);

    /* reload a new frame data */
    tmp = GetTickCount();
    if (srcyuv_fp != NULL)
        load_surface(src_surface[display_order % SURFACE_NUM], display_order + SURFACE_NUM);
    UploadPictureTicks += GetTickCount() - tmp;

    pthread_mutex_lock(&encode_mutex);
    srcsurface_status[display_order % SURFACE_NUM] = SRC_SURFACE_IN_ENCODING;
    pthread_mutex_unlock(&encode_mutex);
}


static void * storage_task_thread(void *t)
{
    while (1) {
        struct storage_task_t *current;

        current = storage_task_dequeue();
        if (current == NULL) {
            pthread_mutex_lock(&encode_mutex);
            pthread_cond_wait(&encode_cond, &encode_mutex);
            pthread_mutex_unlock(&encode_mutex);
            continue;
        }

        storage_task(current->display_order, current->encode_order);

        free(current);

        /* all frames are saved, exit the thread */
        if (++frame_coded >= ips.frame_count)
            break;
    }

    return 0;
}

static int storage_task_queue(unsigned long long display_order, unsigned long long encode_order)
{
    struct storage_task_t *tmp;

    tmp = calloc(1, sizeof(struct storage_task_t));
    if (tmp) {
        tmp->display_order = display_order;
        tmp->encode_order = encode_order;
    }

    pthread_mutex_lock(&encode_mutex);

    if (storage_task_header == NULL) {
        storage_task_header = tmp;
        storage_task_tail = tmp;
    } else {
        storage_task_tail->next = tmp;
        storage_task_tail = tmp;
    }

    srcsurface_status[display_order % SURFACE_NUM] = SRC_SURFACE_IN_STORAGE;
    pthread_cond_signal(&encode_cond);

    pthread_mutex_unlock(&encode_mutex);

    return 0;
}

static int encode_frames(void)
{
    unsigned int i, tmp;
    VAStatus va_status;
    //VASurfaceStatus surface_status;

    /* upload RAW YUV data into all surfaces */
    tmp = GetTickCount();
    if (srcyuv_fp != NULL) {
        for (i = 0; i < SURFACE_NUM; i++)
            load_surface(src_surface[i], i);
    } else
        upload_source_YUV_once_for_all();
    UploadPictureTicks += GetTickCount() - tmp;

    /* ready for encoding */
    memset(srcsurface_status, SRC_SURFACE_IN_ENCODING, sizeof(srcsurface_status));

    memset(&seq_param, 0, sizeof(seq_param));
    memset(&pic_param, 0, sizeof(pic_param));
    memset(&tile_group_param, 0, sizeof(tile_group_param));

    if (ips.encode_syncmode == 0)
        pthread_create(&encode_thread, NULL, storage_task_thread, NULL);

    for (current_frame_encoding = 0; current_frame_encoding < ips.frame_count; current_frame_encoding++) {
        encoding2display_order(current_frame_encoding, ips.intra_period, 
                               &current_frame_display, &current_frame_type);

        printf("%s : %lld %s : %lld type : %d\n", "encoding order", current_frame_encoding, "Display order", current_frame_display, current_frame_type);
        /* check if the source frame is ready */
        while (srcsurface_status[current_slot] != SRC_SURFACE_IN_ENCODING) {
            usleep(1);
        }

        tmp = GetTickCount();
        va_status = vaBeginPicture(va_dpy, context_id, src_surface[current_slot]);
        CHECK_VASTATUS(va_status, "vaBeginPicture");
        BeginPictureTicks += GetTickCount() - tmp;

        

        tmp = GetTickCount(); //start of render process

        // prepare parameters used for sequence and frame
        fill_sps_header();
        fill_pps_header(current_frame_display);
        
        
        // init length of packed headers
        len_ivf_header = 0;
        len_seq_header = 0;
        len_pic_header = 0;

        // render headers
        // first frame send IVF sequence header + frame header
        if(current_frame_encoding == 0) 
        {
            render_ivf_header(); //44 byte, 32byte sequence ivf header, 12 byte frame ivf header
            len_ivf_header = 44;
        }
        else 
        {
            render_ivf_frame_header(); //12 byte frame ivf header
            len_ivf_header = 12;
        }

        render_TD();//render OBU_TEMPORAL_DELIMITER

        if (current_frame_type == KEY_FRAME) {
            if(current_frame_encoding == 0)  render_sequence(); //render SPS only needed in first frame
            len_seq_header = render_packedsequence(); //render packed sequence header
        }
        else
        {
            len_seq_header = 0;
        }
        
        if((ips.RateControlMethod == 2 || ips.RateControlMethod == 4) && current_frame_encoding == 0)
        {
            // misc buffer are not need in CQP case
            // only needed in first frame
            render_misc_buffer();
        }
        

        render_packedpicture(); //render packed frame header 
        render_picture(); //render frame PPS buffer
        render_tile_group(); //render tile group buffer
        RenderPictureTicks += GetTickCount() - tmp;

        tmp = GetTickCount();
        va_status = vaEndPicture(va_dpy, context_id);
        CHECK_VASTATUS(va_status, "vaEndPicture");
        EndPictureTicks += GetTickCount() - tmp;

        if (ips.encode_syncmode)
            storage_task(current_frame_display, current_frame_encoding);
        else /* queue the storage task queue */
            storage_task_queue(current_frame_display, current_frame_encoding);

    }

    if (ips.encode_syncmode == 0) {
        int ret;
        pthread_join(encode_thread, (void **)&ret);
    }

    return 0;
}


static int calc_PSNR(double *psnr)
{
    char *srcyuv_ptr = NULL, *recyuv_ptr = NULL, tmp;
    unsigned long long min_size;
    unsigned long long i, sse = 0;
    double ssemean;
    int fourM = 0x400000; /* 4M */

    min_size = MIN(srcyuv_frames, ips.frame_count) * ips.width * ips.height * 1.5;
    for (i = 0; i < min_size; i++) {
        unsigned long long j = i % fourM;

        if ((i % fourM) == 0) {
            if (srcyuv_ptr)
                munmap(srcyuv_ptr, fourM);
            if (recyuv_ptr)
                munmap(recyuv_ptr, fourM);

            srcyuv_ptr = mmap(0, fourM, PROT_READ, MAP_SHARED, fileno(srcyuv_fp), i);
            recyuv_ptr = mmap(0, fourM, PROT_READ, MAP_SHARED, fileno(recyuv_fp), i);
            if ((srcyuv_ptr == MAP_FAILED) || (recyuv_ptr == MAP_FAILED)) {
                printf("Failed to mmap YUV files\n");
                return 1;
            }
        }
        tmp = srcyuv_ptr[j] - recyuv_ptr[j];
        sse += tmp * tmp;
    }
    ssemean = (double)sse / (double)min_size;
    *psnr = 20.0 * log10(255) - 10.0 * log10(ssemean);

    if (srcyuv_ptr)
        munmap(srcyuv_ptr, fourM);
    if (recyuv_ptr)
        munmap(recyuv_ptr, fourM);

    return 0;
}

static int print_performance(unsigned int PictureCount)
{
    unsigned int psnr_ret = 1, others = 0;
    double psnr = 0, total_size = ips.width * ips.height * 1.5 * ips.frame_count;

    if (ips.calc_psnr && srcyuv_fp && recyuv_fp)
        psnr_ret = calc_PSNR(&psnr);

    others = TotalTicks - UploadPictureTicks - BeginPictureTicks
             - RenderPictureTicks - EndPictureTicks - SyncPictureTicks - SavePictureTicks;

    printf("\n\n");

    printf("PERFORMANCE:   Frame Rate           : %.2f fps (%d frames, %d ms (%.2f ms per frame))\n",
           (double) 1000 * PictureCount / TotalTicks, PictureCount,
           TotalTicks, ((double)  TotalTicks) / (double) PictureCount);
    printf("PERFORMANCE:   Compression ratio    : %d:1\n", (unsigned int)(total_size / frame_size));
    if (psnr_ret == 0)
        printf("PERFORMANCE:   PSNR                 : %.2f (%lld frames calculated)\n",
               psnr, MIN(ips.frame_count, srcyuv_frames));

    printf("PERFORMANCE:     UploadPicture      : %d ms (%.2f, %.2f%% percent)\n",
           (int) UploadPictureTicks, ((double)  UploadPictureTicks) / (double) PictureCount,
           UploadPictureTicks / (double) TotalTicks / 0.01);
    printf("PERFORMANCE:     vaBeginPicture     : %d ms (%.2f, %.2f%% percent)\n",
           (int) BeginPictureTicks, ((double)  BeginPictureTicks) / (double) PictureCount,
           BeginPictureTicks / (double) TotalTicks / 0.01);
    printf("PERFORMANCE:     vaRenderHeader     : %d ms (%.2f, %.2f%% percent)\n",
           (int) RenderPictureTicks, ((double)  RenderPictureTicks) / (double) PictureCount,
           RenderPictureTicks / (double) TotalTicks / 0.01);
    printf("PERFORMANCE:     vaEndPicture       : %d ms (%.2f, %.2f%% percent)\n",
           (int) EndPictureTicks, ((double)  EndPictureTicks) / (double) PictureCount,
           EndPictureTicks / (double) TotalTicks / 0.01);
    printf("PERFORMANCE:     vaSyncSurface      : %d ms (%.2f, %.2f%% percent)\n",
           (int) SyncPictureTicks, ((double) SyncPictureTicks) / (double) PictureCount,
           SyncPictureTicks / (double) TotalTicks / 0.01);
    printf("PERFORMANCE:     SavePicture        : %d ms (%.2f, %.2f%% percent)\n",
           (int) SavePictureTicks, ((double)  SavePictureTicks) / (double) PictureCount,
           SavePictureTicks / (double) TotalTicks / 0.01);
    printf("PERFORMANCE:     Others             : %d ms (%.2f, %.2f%% percent)\n",
           (int) others, ((double) others) / (double) PictureCount,
           others / (double) TotalTicks / 0.01);

    if (ips.encode_syncmode == 0)
        printf("(Multithread enabled, the timing is only for reference)\n");

    return 0;
}


int main(int argc, char **argv)
{
    unsigned int start;

    process_cmdline(argc, argv);

    print_input();

    start = GetTickCount();

    init_va();
    setup_encode();

    encode_frames();

    release_encode();
    deinit_va();

    //free memory
    if(ips.output) free(ips.output);
    if(ips.srcyuv) free(ips.srcyuv);
    if(ips.recyuv) free(ips.recyuv);

    TotalTicks += GetTickCount() - start;
    print_performance(ips.frame_count);

    return 0;
}
