#include "sys_config.h"
#include "tx_platform.h"
#include "list.h"
#include "dev.h"
#include "typesdef.h"
#include "lib/video/dvp/cmos_sensor/csi.h"
#include "lib/video/h264/h264_drv.h"
#include "devid.h"
#include "osal/irq.h"
#include "osal/string.h"
#include "lib/video/dvp/jpeg/jpg.h"
#include "hal/h264.h"
#include "dev/scale/hgscale.h"
#include "dev/h264/hg264.h"
#include "osal/semaphore.h"
#include "openDML.h"
#include "osal/mutex.h"
#include "lib/heap/av_heap.h"
#include "lib/heap/av_psram_heap.h"
#include "gen420_hardware_msi.h"
#include "lib/video/vpp/vpp_dev.h"
#include "lib/multimedia/msi.h"

//workqueue
#include "user_work/user_work.h"

struct timeLapse_work_t
{
	struct os_work wk;
	uint32_t timer;
	uint32_t last_kick_time;
};
static struct timeLapse_work_t *timeLapse_wk;


#define H264_MALLOC av_psram_malloc
#define H264_FREE   av_psram_free
#define H264_ZALLOC av_psram_zalloc

#define H264_LIB_MALLOC av_malloc
#define H264_LIB_FREE   av_free
#define H264_LIB_ZALLOC av_zalloc


#ifndef H264_HARDWARE_CLK
#define H264_HARDWARE_CLK	H264_MODULE_CLK_480M
#endif

#ifndef H264_I_ONLY
#define H264_I_ONLY         0
#endif


void h264_sema_up();

volatile uint32_t h264_dev_num = 1;
volatile struct	h264_cfg_t    enc_cfg;
volatile struct h264_ctl_t	  enc_ctl;
volatile struct h264_rc_ctl_t rc_ctl;

volatile struct	h264_cfg_t    enc_2_cfg;
volatile struct h264_ctl_t	  enc_2_ctl;
volatile struct h264_rc_ctl_t rc_2_ctl;

volatile struct	h264_cfg_t    *penc_cfg;
volatile struct h264_ctl_t	  *penc_ctl;
volatile struct h264_rc_ctl_t *prc_ctl;

uint8_t *h264_ref_lu_base_psram = NULL;
uint8_t *h264_ref_ch_base_psram = NULL;

uint8_t *h264_ref_lu_base_psram2 = NULL;
uint8_t *h264_ref_ch_base_psram2 = NULL;

uint8_t *h264_room_psram = NULL;


uint8_t *h264_ref_memory_base[10];


__psram_data uint8_t h264_room[H264_NODE_NUM*H264_NODE_LEN] __aligned(1024);

volatile h264_frame h264_frame_point[H264_FRAME_NUM];
volatile struct list_head *h264_module_p;		//264模块的节点指针
volatile struct list_head *h264_app_p;			//应用的节点指针
volatile struct list_head* h264_f_p;			//当前264所使用的frame
volatile h264_node h264_node_src[H264_NODE_NUM];
volatile struct list_head h264_free_tab;			//空闲列表，存放空间节点
volatile uint8 h264_error = 0;
volatile uint8 frame_done = 0;

static struct os_semaphore h264_sem = {0,NULL};

volatile struct list_head h264_queue_head;

static struct os_semaphore h264wq_sem = {0,NULL};
void h264wq_sema_init()
{
	os_sema_init(&h264wq_sem,0);
}

void h264wq_sema_down(int32 tmo_ms)
{
	os_sema_down(&h264wq_sem,tmo_ms);
}

void h264wq_sema_up()
{
	os_sema_up(&h264wq_sem);
}


/**@brief 
 * 将传入的frame根节点下的buf池都送回空间池（free_tab）中
 */
static bool free_get_node_list(volatile struct list_head *head,volatile struct list_head *free){
	bool ret = 1;
	uint32_t flags = disable_irq();
	if(list_empty((struct list_head *)head)){
		ret = 0;
		goto free_get_node_list_end;
	}	

	list_splice_init((struct list_head *)head,(struct list_head *)free);
	free_get_node_list_end:
	enable_irq(flags);
	return ret;
}

/**@brief 
 * 从初始化的frame根节点中抽取其中一个空闲的根节点进行使用，并标记frame的使用状态为正在使用
 * @param 是否开启抢占模式，如果开启，则将上一帧已完成的帧节点删掉，并返回
 */


volatile struct list_head* get_h264_new_frame_head(int grab,uint8_t devid,uint8_t is_iframe){
	uint8 frame_num = 0;
	for(frame_num = 0;frame_num < H264_FRAME_NUM;frame_num++){
		if(h264_frame_point[frame_num].usable == 0){
			h264_frame_point[frame_num].usable = 1;
			if(is_iframe){
				h264_frame_point[frame_num].h264_type = 1;
			}else{
				h264_frame_point[frame_num].h264_type = 2;
			}	
			h264_frame_point[frame_num].h264_dev_id = devid;
			return &h264_frame_point[frame_num].list;
		}

	}

	if(grab)								//是否开启抢占模式,开启抢占后，肯定有frame返回，上一帧没使用的frame肯定usable为2
	{
		
		for(frame_num = 0;frame_num < H264_FRAME_NUM;frame_num++){
			if(h264_frame_point[frame_num].usable == 2){
				h264_frame_point[frame_num].usable = 1;
				if(is_iframe){
					h264_frame_point[frame_num].h264_type = 1;
				}else{
					h264_frame_point[frame_num].h264_type = 2;
				}				
				h264_frame_point[frame_num].h264_dev_id = devid;
				free_get_node_list(&h264_frame_point[frame_num].list,&h264_free_tab);
				return &h264_frame_point[frame_num].list;
			}
		}
	}
	
	return 0;
}

/**@brief 
 * 初始化free_tab池，将mjpeg_node的节点都放到空闲池中，供frame后面提取使用
 * @param ftb 空闲池头指针
 * @param jpn mjpeg_node节点源
 * @param use_num  mjpeg_node的数量，即多少个mjpeg_node放到空闲池
 * @param addr   mjpeg_node的总buf起始地址
 * @param buf_len  每个mjpeg_node所关联到的数据量
 */
void h264_free_table_init(volatile struct list_head *ftb, volatile h264_node* h264n,int use_num,uint32 addr,uint32 buf_len){
	int itk;
	for(itk = 0;itk < use_num;itk++){
		h264n->buf_addr = (uint8*)(addr + itk*buf_len);
		list_add_tail((struct list_head *)&h264n->list,(struct list_head *)ftb); 
		h264n++;
	}
}

static void set_frame_ready(h264_frame *hf){
	hf->timestamp = os_jiffies();
	hf->usable = 2;
}


/**@brief 
 * 从空间池中提取一个节点，放到队列中，并将此节点作为返回值返回
 */
static struct list_head *get_node(volatile struct list_head *head,volatile struct list_head *del){
	struct list_head *ret = NULL;
	uint32_t flags = disable_irq();
	if(list_empty((struct list_head *)del)){
		goto get_node_end;
	}

	list_move((struct list_head *)del->next,(struct list_head *)head);
	ret = head->next;
	get_node_end:
	enable_irq(flags);
	return ret;				//返回最新的位置
}

/**@brief 
 * 从当前使用的节点回放到消息池中
 */
static bool put_node(volatile struct list_head *head,volatile struct list_head *del){
	bool ret = 1;
	uint32_t flags = disable_irq();
	if(list_empty((struct list_head *)del)){
		ret = 0;
		goto put_node_end;
	}
	list_move(del->next,(struct list_head *)head);
	put_node_end:
	enable_irq(flags);
	return ret;
}


/**@brief 
 * 获取当前jpeg节点buf地址进行返回
 */
static uint32 get_addr(volatile struct list_head *list){
	h264_node* h264n;
	h264n = list_entry((struct list_head *)list,h264_node,list);
	return (uint32)h264n->buf_addr;
}

/**@brief 
 * 将传入的frame根节点状态调整为空闲，以供下次重新获取
 */
void del_264_frame(volatile struct list_head* frame_list)
{


	h264_frame* fl;
	uint32_t flags;
	flags = disable_irq();
	if(list_empty((struct list_head *)frame_list) != TRUE){	
		free_get_node_list(frame_list,&h264_free_tab);
		fl = list_entry((struct list_head *)frame_list,h264_frame,list);
		fl->usable = 0;
		goto del_264_frame_end;

	}else{
		fl = list_entry((struct list_head *)frame_list,h264_frame,list);
		fl->usable = 0;
		goto del_264_frame_end;
	}
	del_264_frame_end:
	enable_irq(flags);
}

uint32 get_h264_node_len_new(void *get_f)
{
	return H264_NODE_LEN;
}


void del_h264_frame(void *d)
{
	h264_frame* get_f = (h264_frame*)d;
	del_264_frame((struct list_head*)get_f);

}

struct list_head* get_h264_frame()
{
	uint8 frame_num = 0;
	
	for(frame_num = 0;frame_num < H264_FRAME_NUM;frame_num++){
		if(h264_frame_point[frame_num].usable == 2){
			h264_frame_point[frame_num].usable = 1;
			return (struct list_head *)&h264_frame_point[frame_num].list;
		}
	}

	return NULL;	
}


uint32 get_h264_timestamp(void *d)
{
	struct list_head* get_f = (struct list_head*)d;
	h264_frame* hf;
	hf = list_entry(get_f,h264_frame,list);
	return hf->timestamp;
}


uint32 get_h264_which(void *d)
{
	struct list_head* get_f = (struct list_head*)d;
	h264_frame* hf;
	hf = list_entry(get_f,h264_frame,list);
	return hf->which;
}

uint32 get_h264_srcID(void *d)
{
	struct list_head* get_f = (struct list_head*)d;
	h264_frame* hf;
	hf = list_entry(get_f,h264_frame,list);
	return hf->srcID;
}

uint32 get_h264_len(void *d)
{
	uint32 flen;
	struct list_head* get_f = (struct list_head*)d;
	h264_frame* hf;
	hf = list_entry(get_f,h264_frame,list);
	flen = hf->frame_len;
	return flen;
}

uint8 get_h264_type(void *d)
{
	uint8 type;
	struct list_head* get_f = (struct list_head*)d;
	h264_frame* hf;
	hf = list_entry(get_f,h264_frame,list);
	type = hf->h264_type;
	return type;
}

uint8 get_h264_loop_num(void *d)
{
	uint8 num;
	struct list_head* get_f = (struct list_head*)d;
	h264_frame* hf;
	hf = list_entry(get_f,h264_frame,list);
	num = hf->h264_num;
	return num;
}

void *get_h264_first_buf(void *d)
{
	struct list_head* get_f = (struct list_head*)d;
	h264_node* hn;
	hn = list_entry(get_f->next,h264_node,list);
	if(hn)
	{
		return hn->buf_addr;
	}
	return NULL;
} 
 
int del_h264_first_node(void *d)
{	
	h264_frame* get_f = (h264_frame*)d;

	uint8_t *h264_buf = get_h264_first_buf(get_f);
	uint32_t h264_buf_node_len = get_h264_node_len_new((void *)get_f);
	sys_dcache_invalid_range((uint32_t *)h264_buf, h264_buf_node_len);
	put_node(&h264_free_tab,(struct list_head*)get_f);
	
	return 0;	
}
 
void *get_h264_node_buf(void *d)
{
	struct list_head* get_f = (struct list_head*)d;
	h264_node* hn;
	hn = list_entry(get_f,h264_node,list);
	if(hn)
	{
		return hn->buf_addr;
	}
	return NULL;
}


//删除节点,是实际节点
void del_h264_node(void *d)
{
	uint32_t flags;
	struct list_head* get_f = (struct list_head *)d;
	flags = disable_irq();
	list_add_tail(get_f,(struct list_head*)&h264_free_tab);
	enable_irq(flags);
}


uint32 get_h264_w_h(void *d,uint16_t *w,uint16_t *h)
{
	h264_frame* get_f = (h264_frame*)d;
	if(w)
	{
		*w = get_f->w;
	}

	if(h)
	{
		*h = get_f->h;
	}
	return 0;
}





void h264_room_init(){
	uint8_t i;
	for(i = 0;i < H264_FRAME_NUM;i++){
		INIT_LIST_HEAD((struct list_head *)&h264_frame_point[i].list);
	}

	INIT_LIST_HEAD((struct list_head *)&h264_free_tab);
	uint32_t h264_rom_addr = ((uint32_t)h264_room_psram + 0x3ff)&(~0x3ff);
	h264_free_table_init(&h264_free_tab,(h264_node*)&h264_node_src,H264_NODE_NUM,(uint32)h264_rom_addr,H264_NODE_LEN);

	for(i = 0;i < H264_FRAME_NUM;i++){
		h264_frame_point[i].usable      = 0;
		h264_frame_point[i].h264_num    = 0;
		h264_frame_point[i].h264_dev_id = 0;
	}
}

void h264_3dnr_ini(struct h264_device  *p_h264,struct h264_cfg_t *enc_cfg)
{
	uint8_t      h264_noise_level = enc_cfg->flt_noise_lev;
	uint16_t     i;
	uint32_t     wdata   ; 
	uint8_t      d0, d1, d2, d3;

	uint32_t NoiseLevel              = 8     ;   // range:0 ~ 15
	uint32_t BackGroundNoiseLevel    = 8     ;   // range:0 ~ 15
	uint32_t LightFlowLevel          = 8     ;   // range:0 ~ 15
	uint32_t MV_Threshold            = 3     ;   // 0~15, 3 bits, 0: disable mv_threshold_check, user modify
	uint32_t MV_Trust_Cut            = 3840  ;   // if max_mcost<MV_Trust_Cut then force best_mv=(0,0), and 
	                                        //min_mcost=max_mcost; set MV_Trust_Cut=0, if you want to disable.
	uint32_t Merge_Fusion_Limit      = 16    ;   // max_dif(abs(flt-org))
	uint32_t TemporalFilterParameter = 8     ;   // range 0 ~ 64, user modify
	uint32_t MD_Cmp_Level            = 9     ;  
	uint32_t MV_Bias_SF              = 1     ;

 	uint8_t min_beta_by_max_mcost[64]={
         1,  1,   6,  8,    // 1024*0 ~ 1024*1
         8, 10,  10, 12,    // 1024*1 ~ 1024*2   
        16, 18,  20, 24,    // 1024*2 ~ 1024*3
        28, 32,  36, 40,    // 1024*3 ~ 1024*4
        44, 48,  52, 56,    // 1024*4 ~ 1024*5
        60, 60,  62, 62,    // 1024*5 ~ 1024*6
        64, 64,  64, 64,    // 1024*6 ~ 1024*7
        64, 64,  64, 64,    // 1024*7 ~ 1024*8
                            
        64, 64,  64, 64,    // 1024*8 ~ 1024*9   
        64, 64,  64, 64,    // 1024*9 ~ 1024*10
        64, 64,  64, 64,    // 1024*10 ~ 1024*11
        64, 64,  64, 64,    // 1024*11 ~ 1024*12
        64, 64,  64, 64,    // 1024*12 ~ 1024*13
        64, 64,  64, 64,    // 1024*13 ~ 1024*14
        64, 64,  64, 64,    // 1024*14 ~ 1024*15
        64, 64,  64, 64,    // 1024*15 ~ 1024*16
	};

    uint8_t min_beta_by_min_mcost[32]={
         1,  1,   1,  1,    //    0 ~ 1024
         1,  1,   1,  1,    // 1024 ~ 2048
         1,  4,   8, 12,    // 2048 ~ 3072
        16, 20,  24, 28,    // 3072 ~ 4096

        28, 28,  28, 29,    // 4096 ~ 5120
        32, 35,  38, 41,    // 5120 ~ 6144
        44, 46,  49, 52,    // 6144 ~ 7168
        55, 58,  61, 64,    // 7168 ~ 8192
	};

    uint8_t min_beta_by_mdcost00[16]={
         1,  7,  15, 23,    //    0 ~ 1024
        31, 39,  47, 55,    // 1024 ~ 2048
        64, 64,  64, 64,    // 2048 ~ 3072
        64, 64,  64, 64,    // 3072 ~ 4096 
    };

	if(h264_noise_level == 4) {
	    //very high noise
	    NoiseLevel              = 9     ;   // range:0 ~ 15
	    BackGroundNoiseLevel    = 9     ;   // range:0 ~ 15
	    LightFlowLevel          = 8     ;   // range:0 ~ 15
	    MV_Threshold            = 3     ;   // 0~15, 3 bits, 0: disable mv_threshold_check, user modify
	    Merge_Fusion_Limit      = 32    ;   // max_dif(abs(flt-org))
	    MV_Trust_Cut            = 4500  ;   // if max_mcost<MV_Trust_Cut then force best_mv=(0,0), and                                                             // min_mcost=max_mcost; set MV_Trust_Cut=0, if you want to disable.
	} else if(h264_noise_level == 3) {
	    //high noise
	    NoiseLevel              = 9     ;   // range:0 ~ 15
	    BackGroundNoiseLevel    = 8     ;   // range:0 ~ 15
	    LightFlowLevel          = 8     ;   // range:0 ~ 15
	    MV_Threshold            = 3     ;   // 0~15, 3 bits, 0: disable mv_threshold_check, user modify
	    Merge_Fusion_Limit      = 24    ;   // max_dif(abs(flt-org))
	    MV_Trust_Cut            = 4500  ;   // if max_mcost<MV_Trust_Cut then force best_mv=(0,0), and                                                             // min_mcost=max_mcost; set MV_Trust_Cut=0, if you want to disable.
	} else if(h264_noise_level == 2) {
	    //medium
	    NoiseLevel              = 8     ;   // range:0 ~ 15
	    BackGroundNoiseLevel    = 7     ;   // range:0 ~ 15
	    LightFlowLevel          = 7     ;   // range:0 ~ 15
	    MV_Threshold            = 3     ;   // 0~15, 3 bits, 0: disable mv_threshold_check, user modify
	    Merge_Fusion_Limit      = 16    ;   // max_dif(abs(flt-org))
	    MV_Trust_Cut            = 3840  ;   // if max_mcost<MV_Trust_Cut then force best_mv=(0,0), and                                                             // min_mcost=max_mcost; set MV_Trust_Cut=0, if you want to disable.
	} else if(h264_noise_level == 1) {
	    //low
	    NoiseLevel              = 7     ;   // range:0 ~ 15
	    BackGroundNoiseLevel    = 6     ;   // range:0 ~ 15
	    LightFlowLevel          = 7     ;   // range:0 ~ 15
	    MV_Threshold            = 2     ;   // 0~15, 3 bits, 0: disable mv_threshold_check, user modify
	    Merge_Fusion_Limit      = 12    ;   // max_dif(abs(flt-org))
	    MV_Trust_Cut            = 2800  ;   // if max_mcost<MV_Trust_Cut then force best_mv=(0,0), and                                                             // min_mcost=max_mcost; set MV_Trust_Cut=0, if you want to disable.
	} else {
	    //very low
	    NoiseLevel              = 7     ;   // range:0 ~ 15
	    BackGroundNoiseLevel    = 5     ;   // range:0 ~ 15
	    LightFlowLevel          = 6     ;   // range:0 ~ 15
	    MV_Threshold            = 2     ;   // 0~15, 3 bits, 0: disable mv_threshold_check, user modify
	    Merge_Fusion_Limit      = 9     ;   // max_dif(abs(flt-org))
	    MV_Trust_Cut            = 1800  ;   // if max_mcost<MV_Trust_Cut then force best_mv=(0,0), and                                                             // min_mcost=max_mcost; set MV_Trust_Cut=0, if you want to disable.
	}


	//--- 1: configure each tables
	for(i=0; i<4; i++) {
	    d0 = min_beta_by_mdcost00[i*4 + 0] - 1;
	    d1 = min_beta_by_mdcost00[i*4 + 1] - 1;
	    d2 = min_beta_by_mdcost00[i*4 + 2] - 1;
	    d3 = min_beta_by_mdcost00[i*4 + 3] - 1;
	    
	    wdata = ((uint32_t)d3 << 24) | ((uint32_t)d2 << 16) | ((uint32_t)d1 << 8) | ((uint32_t)d0 << 0);
		h264_set_flt_3dnr_lut(p_h264,i,wdata);
	}

	for(i=0; i<8; i++) {
	    d0 = min_beta_by_min_mcost[i*4 + 0] - 1;
	    d1 = min_beta_by_min_mcost[i*4 + 1] - 1;
	    d2 = min_beta_by_min_mcost[i*4 + 2] - 1;
	    d3 = min_beta_by_min_mcost[i*4 + 3] - 1;
	    
	    wdata = ((uint32_t)d3 << 24) | ((uint32_t)d2 << 16) | ((uint32_t)d1 << 8) | ((uint32_t)d0 << 0);
		h264_set_flt_min_lut(p_h264,i,wdata);
	}
	    
	for(i=0; i<16; i++) {
	    d0 = min_beta_by_max_mcost[i*4 + 0] - 1;
	    d1 = min_beta_by_max_mcost[i*4 + 1] - 1;
	    d2 = min_beta_by_max_mcost[i*4 + 2] - 1;
	    d3 = min_beta_by_max_mcost[i*4 + 3] - 1;
	    
	    wdata = ((uint32_t)d3 << 24) | ((uint32_t)d2 << 16) | ((uint32_t)d1 << 8) | ((uint32_t)d0 << 0);
		h264_set_flt_max_lut(p_h264,i,wdata);
	}


	//--- 3DNR ctrl_2
	wdata = MV_Bias_SF;
	h264_set_flt_3dnr_sf(p_h264,wdata);

	//--- 3DNR ctrl_1
	wdata = (MV_Trust_Cut << 16) | ((BackGroundNoiseLevel -5) << 12) | ((NoiseLevel-5) << 8) |
	        (MD_Cmp_Level << 4)  | (MV_Threshold << 0);

	h264_set_flt_3dnr_con1(p_h264,wdata);
	//--- 3DNR ctrl_0
	wdata = (0 << 28) | (TemporalFilterParameter << 20) | ((LightFlowLevel -5) << 16) |
	        (1 << 8)  | (Merge_Fusion_Limit << 0);	
	h264_set_flt_3dnr_con(p_h264,wdata);
}


volatile uint16 recfg_h264_mbps[2];   //if stilltomove 0,represent enc_bps,else represent move_enc_bps
volatile uint16 recfg_h264_sbps[2];
volatile uint16 recfg_h264_rate[2];
volatile uint16 recfg_h264_gop[2];
volatile uint8  recfg_h264_ini_qp[2];
volatile uint8  recfg_h264_new_grop[2];

void h264_reflash_new_gop(uint8_t dev_num,uint8_t en){
	uint32_t ie;	
	ie = disable_irq();
	recfg_h264_new_grop[dev_num-1] = en;
	enable_irq(ie);
}

void h264_recfg_bsp(uint8_t dev_num,uint16_t mbps,uint16_t sbps){
	uint32_t ie;	
	ie = disable_irq();
	recfg_h264_mbps[dev_num-1] = mbps;
	recfg_h264_sbps[dev_num-1] = sbps;
	enable_irq(ie);
}

void h264_recfg_rate(uint8_t dev_num,uint16_t rate){
	uint32_t ie;	
	ie = disable_irq();
	recfg_h264_rate[dev_num-1] = rate;
	enable_irq(ie);
}

void h264_recfg_frm_gop(uint8_t dev_num,uint16_t gop){
	uint32_t ie;	
	ie = disable_irq();
	recfg_h264_gop[dev_num-1] = gop;
	enable_irq(ie);
}

void h264_recfg_ini_qp(uint8_t dev_num,uint8_t qp){
	uint32_t ie;	
	ie = disable_irq();
	recfg_h264_ini_qp[dev_num-1] = qp;
	enable_irq(ie);
}

uint8_t h264_cfg_modify(struct h264_cfg_t *enc_cfg,uint8_t dev_num){
	uint8_t result = 0;

	if(enc_cfg->stilltomove == 0){
		if(enc_cfg->enc_bps != recfg_h264_mbps[dev_num-1]){
			enc_cfg->enc_bps = recfg_h264_mbps[dev_num-1];
			result = 1;
		}		
	}else{
		if(enc_cfg->move_enc_bps != recfg_h264_mbps[dev_num-1]){
			enc_cfg->move_enc_bps = recfg_h264_mbps[dev_num-1];
			result = 1;
		}

		if(enc_cfg->still_enc_bps != recfg_h264_sbps[dev_num-1]){
			enc_cfg->still_enc_bps = recfg_h264_sbps[dev_num-1];
			result = 1;
		}
	}
	
	if(enc_cfg->frm_rate != recfg_h264_rate[dev_num-1]){
		enc_cfg->frm_rate = recfg_h264_rate[dev_num-1];
		result = 1;
	}

	if(enc_cfg->frm_gop != recfg_h264_gop[dev_num-1]){
		enc_cfg->frm_gop = recfg_h264_gop[dev_num-1];
		result = 1;
	}

	if(enc_cfg->ini_qp != recfg_h264_ini_qp[dev_num-1]){
		enc_cfg->ini_qp = recfg_h264_ini_qp[dev_num-1];
		result = 1;
	}

	return result;
}

void h264_ini_recfg(struct h264_cfg_t *enc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl){
	enc_ctl->frm_qp    = enc_cfg->ini_qp;
	enc_ctl->target_gop = ( ((uint32_t)enc_cfg->enc_bps * 1000 * (uint32_t)enc_cfg->frm_gop) / enc_cfg->frm_rate ) >> 3;  //byte target
	rc_ctl->i_qp      = enc_cfg->ini_qp;
	rc_ctl->p_qp      = enc_cfg->ini_qp;
	//--- cal I frame target byte
	rc_ctl->i_byte    = (enc_ctl->target_gop * enc_cfg->frm_ip_rate)     / (enc_cfg->frm_gop - 1 + enc_cfg->frm_ip_rate);
	rc_ctl->i_frm_max = (enc_ctl->target_gop * enc_cfg->frm_ip_rate_max) / (enc_cfg->frm_gop - 1 + enc_cfg->frm_ip_rate_max);
	rc_ctl->i_frm_min = (enc_ctl->target_gop * enc_cfg->frm_ip_rate_min) / (enc_cfg->frm_gop - 1 + enc_cfg->frm_ip_rate_min);	
}


void h264_ini_seting_cfg(struct h264_device *p_h264,struct h264_cfg_t *enc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl,uint8_t dev_num) {
  h264_reflash_new_gop(dev_num,0);
  h264_recfg_bsp(dev_num,enc_cfg->move_enc_bps,enc_cfg->move_enc_bps);
  h264_recfg_rate(dev_num,enc_cfg->frm_rate);
  h264_recfg_frm_gop(dev_num,enc_cfg->frm_gop);
  h264_recfg_ini_qp(dev_num,enc_cfg->ini_qp);
  
  enc_ctl->enc_mode  = enc_cfg->enc_mode;
  enc_ctl->frm_qp    = enc_cfg->ini_qp;
  enc_ctl->frm_width = ((enc_cfg->frm_width + 15) >> 4) << 4;   //16 pixel align
  enc_ctl->frm_height= ((enc_cfg->frm_height + 15) >> 4) << 4;  //16 pixel align
  enc_ctl->frm_luma_size = enc_ctl->frm_width * enc_ctl->frm_height;  
  enc_ctl->frm_mblines= enc_ctl->frm_height >> 4;
  enc_ctl->timeout_limit = (enc_ctl->frm_luma_size << 10) >> 17;//18
  enc_ctl->bs_byte_limit = H264_BS_SIZE-4;
  
  enc_ctl->frm_cnt    = 0;
  enc_ctl->gop_frm_cnt= 0;
  enc_ctl->idrid      = 0;
  enc_ctl->target_gop = ( ((uint32_t)enc_cfg->enc_bps * 1000 * (uint32_t)enc_cfg->frm_gop) / enc_cfg->frm_rate ) >> 3;  //byte target

  //_os_printf("frm_luma_size:%d   frm_width:%d\r\n",enc_ctl->frm_luma_size,enc_ctl->frm_width);
  if(dev_num == 1){
	//申请空间多申请了4K,主要是为了对齐使用
	  enc_ctl->ref_lu_base= ((uint32_t)h264_ref_lu_base_psram + 0xfff) & (~0xfff);    //must be 4KB aligned
	  enc_ctl->ref_lu_end = ((enc_ctl->ref_lu_base + enc_ctl->frm_luma_size + (48*enc_ctl->frm_width) + 4095) >> 12) << 12;  //4KB align
	  enc_ctl->ref_ch_base= ((uint32_t)h264_ref_ch_base_psram + 0xfff)& (~0xfff);//enc_ctl->ref_lu_end;
	  enc_ctl->ref_ch_end = ((enc_ctl->ref_ch_base + (enc_ctl->frm_luma_size >>1) + (24*enc_ctl->frm_width) + 4095) >> 12) << 12; //4KB align
  }else if(dev_num == 2){
	  enc_ctl->ref_lu_base= ((uint32_t)h264_ref_lu_base_psram2 + 0xfff) & (~0xfff);    //must be 4KB aligned
	  enc_ctl->ref_lu_end = ((enc_ctl->ref_lu_base + enc_ctl->frm_luma_size + (48*enc_ctl->frm_width) + 4095) >> 12) << 12;  //4KB align
	  enc_ctl->ref_ch_base= ((uint32_t)h264_ref_ch_base_psram2 + 0xfff)& (~0xfff);//enc_ctl->ref_lu_end;
	  enc_ctl->ref_ch_end = ((enc_ctl->ref_ch_base + (enc_ctl->frm_luma_size >>1) + (24*enc_ctl->frm_width) + 4095) >> 12) << 12; //4KB align
  }

  
  enc_ctl->last_lpf_lu_base = enc_ctl->ref_lu_base;
  enc_ctl->last_lpf_ch_base = enc_ctl->ref_ch_base;
  
//  enc_ctl->bs_base0		= (uint32_t)h264_dat_buf[0];//h264_dat_buf + (1<<20) - 1024;
//  enc_ctl->bs_base1		= (uint32_t)h264_dat_buf[1];//enc_ctl->bs_base0 + 16*1024;

  enc_ctl->enc_first_frm=1;
  
  rc_ctl->frm_rdcost= (enc_ctl->frm_luma_size >> 8) * (256*48 >> 4);//not critial initial value
  rc_ctl->i_qp      = enc_cfg->ini_qp;
  rc_ctl->p_qp      = enc_cfg->ini_qp;
  
  //--- cal I frame target byte
  rc_ctl->i_byte    = (enc_ctl->target_gop * enc_cfg->frm_ip_rate)     / (enc_cfg->frm_gop - 1 + enc_cfg->frm_ip_rate);
  rc_ctl->i_frm_max = (enc_ctl->target_gop * enc_cfg->frm_ip_rate_max) / (enc_cfg->frm_gop - 1 + enc_cfg->frm_ip_rate_max);
  rc_ctl->i_frm_min = (enc_ctl->target_gop * enc_cfg->frm_ip_rate_min) / (enc_cfg->frm_gop - 1 + enc_cfg->frm_ip_rate_min);
  
}

void h264_enc_eof_update(struct h264_cfg_t *enc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl) {
  
  uint8    rc_p_qp;
  uint8    i_qp;
  uint32   frm_target_step;
  uint32   i_byte;
  
  
  enc_ctl->frm_cnt ++;
  enc_ctl->gop_frm_cnt ++;
  enc_ctl->enc_first_frm = 0;
    
  if(enc_ctl->gop_frm_cnt == enc_cfg->frm_gop) {
      enc_ctl->gop_frm_cnt = 0;
      enc_ctl->idrid = (enc_ctl->idrid + 1) & 0x07;
      
      if(enc_cfg->rc_en) {
        //--- I frame target byte update
        rc_p_qp= (rc_ctl->p_qp_acc + (rc_ctl->p_acc_num >> 1)) / rc_ctl->p_acc_num;
        frm_target_step = (rc_ctl->i_byte >> 4) + (rc_ctl->i_byte >> 5);  //about 10%
        i_qp = rc_ctl->i_qp;
        i_byte= rc_ctl->i_byte;
        
        if(i_qp > rc_p_qp) {            //need add more byte to I frame
            if(i_qp >= (rc_p_qp + 3))
                i_byte += 2*frm_target_step;
            else if(i_qp > (rc_p_qp + 1))
                i_byte += frm_target_step;
        } else if(i_qp < rc_p_qp) {     //need add more byte to P frame
            if(i_qp <= (rc_p_qp - 3))
                i_byte -= 2*frm_target_step;
            else if(i_qp < (rc_p_qp - 1))
                i_byte -= frm_target_step;
        }
        
        //clip
        if(i_byte > rc_ctl->i_frm_max)
          i_byte = rc_ctl->i_frm_max;
        else if(i_byte < rc_ctl->i_frm_min)
          i_byte = rc_ctl->i_frm_min;
        
        rc_ctl->i_byte = i_byte;      
      } 
  }
  
}

void h264_rc_tune_eof(struct h264_device*p_h264,struct h264_cfg_t *enc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl) {

  uint32   rdata;
  uint32   bs_len          = enc_ctl->enc_bs_byte;
  uint32   frm_target      = enc_ctl->frm_target;
  uint32   frm_target_step = (enc_ctl->frm_target >> 4) + (enc_ctl->frm_target >> 5);  //about 10%

  rc_ctl->gop_remain_byte -= enc_ctl->enc_bs_byte;
  if(rc_ctl->gop_remain_byte <=0)
    rc_ctl->gop_remain_byte = 1;

  //--- just accumulate the average QP for last 4 P frame within a GOP
  if((rc_ctl->gop_remain_frame <= 3) && (enc_ctl->frm_type == 0)) {
      rc_ctl->p_qp_acc += enc_ctl->hw_cal_qp;
      rc_ctl->p_acc_num++;
  }
  
  //--- next frame QP modify for I/P frames
  if(enc_ctl->frm_type == 2) {
      rc_ctl->i_qp = enc_ctl->hw_cal_qp;
      //must within [16, 50] range, no need clip
      
  } else {
    uint8  hw_cal_qp = enc_ctl->hw_cal_qp;
    
	if(enc_cfg->cc_corect)
	{
      //high effort
      if(bs_len > (frm_target + 1*frm_target_step)) {       //real > target
          if(bs_len > (frm_target + 4*frm_target_step))         //>= 1.4*target
              hw_cal_qp += 3;
          else if(bs_len > (frm_target + 3*frm_target_step))    //>= 1.3*target
              hw_cal_qp += 3;
          else if(bs_len > (frm_target + 2*frm_target_step))    //>= 1.2*target
              hw_cal_qp += 2;
          else if(bs_len >= (frm_target + 1*frm_target_step))   //>= 1.1*target
              hw_cal_qp += 1;
      } else if(bs_len < (frm_target - 1*frm_target_step)) {//real < target
          if(bs_len <= (frm_target - 5*frm_target_step))        //<= 0.5*target
              hw_cal_qp -= 4;    	  
          else if(bs_len <= (frm_target - 3*frm_target_step))        //<= 0.7*target
              hw_cal_qp -= 2;
          else if(bs_len < (frm_target - 1*frm_target_step))    //<= 0.9*target
              hw_cal_qp -= 1;
      }
    } else {
      //low or relax mode
      //start QP change between each P frame is [-2, 3]
      if((hw_cal_qp >= (rc_ctl->p_qp + 3))) {      
        hw_cal_qp = rc_ctl->p_qp + 3;
      } else if((hw_cal_qp <= (rc_ctl->p_qp - 3))) {
        hw_cal_qp = rc_ctl->p_qp - 2;
      }
    }
  
    //clip to [16, 50]
    if(hw_cal_qp > 50)
        hw_cal_qp = 50;
    else if(hw_cal_qp < 16)
        hw_cal_qp = 16;  
  
    rc_ctl->p_qp = hw_cal_qp;
  }

  if(enc_cfg->rc_effort == 2) {
    rdata   = h264_get_enc_frame_rdcost(p_h264);
    rc_ctl->frm_rdcost = (rdata * enc_cfg->rc_grp + (enc_ctl->frm_mblines >> 1)) / ((uint32)enc_ctl->frm_mblines);       
  } 
}


void h264_read_bs(struct str_info *str)
{
	uint8_t    bs    ;
	uint8_t    sf_bit  ;

	//make sure this is str->bit_len >=25
	while(str->bit_len <= 24) {
		bs      = *(str->ptr);
		str->ptr  += 1;
		sf_bit    = 24 - str->bit_len;
		str->stream = str->stream | (((uint32_t) bs) << sf_bit);
		str->bit_len+= 8;
	}
}

void h264_byte_align(struct str_info *str)
{
	uint8_t    sf_bit  ;
	sf_bit  = str->bit_len & 0x07;
	if(sf_bit != 0) {
		str->stream = str->stream << sf_bit;
		str->bit_len -= sf_bit;
		str->used_bits += sf_bit;
		h264_read_bs(str);
	}
}

uint32_t dec_fix(struct str_info *str, uint8_t bit_num)
{
	uint32_t   val     ;
	uint8_t    sf_bit  ;

	if(bit_num > 25) {
	//print("dec_fix error, bit_num is too big.\n\r");
	}

	sf_bit= 32 - bit_num;
	val   = str->stream >> sf_bit;
	str->stream = str->stream << bit_num;
	str->bit_len -= bit_num;
	str->used_bits += bit_num;
	h264_read_bs(str);

	return(val);
}

int32_t dec_glb(struct str_info *str, uint8_t mode)
{
	uint8_t    leading_0 = 0;
	uint16_t   tmp_val   = 0;
	uint16_t   tail_val  ;
	int32_t   syn       ;

	//-- find leading zero
	while (((str->stream >> 31) & 0x01) == 0x0) {
		str->stream = str->stream << 1;
		str->bit_len -= 1;
		str->used_bits += 1;
		leading_0++;
	}

	//--- shift 1
	str->stream = str->stream << 1;
	str->bit_len -= 1;
	str->used_bits += 1;

	h264_read_bs(str);

	//--- get tail
	if(leading_0 == 0)
		tail_val = 0;
	else
		tail_val = (uint16_t) (str->stream >> (32 - leading_0));

	str->stream = str->stream << leading_0;
	str->bit_len -= leading_0;
	str->used_bits += leading_0;

	tmp_val   = (1 << leading_0) - 1 + tail_val;
	h264_read_bs(str);

	if(mode == 0)
	syn = tmp_val;
	else {
	if(tmp_val == 0)
	  syn = 0;
	else if(tmp_val & 0x01)
	  syn = (tmp_val + 1) >> 1;
	else
	  syn = 0 - (tmp_val >> 1);
	}

	return(syn);

}


void dec_pic(struct str_info *str, struct h264_header *head)
{
	uint32_t   syn_unsign;
	int32_t   syn_sign;
	uint8_t    slice_type;
	uint8_t    ref_pic_list_modification_flag_l0;
	uint8_t    modify_of_pic_muns_idc;
	int16_t   qp_delta;


	syn_sign  = dec_glb(str, 0);    //first_mb_in_slice

	syn_sign  = dec_glb(str, 0);    //slice_type
	//slice_type  = syn_sign;
	slice_type = syn_sign % 5;
	head->pic_slice_type = slice_type;

	syn_sign  = dec_glb(str, 0);    //pps_id
	syn_unsign  = dec_fix(str, (head->sps_log2_max_fnum_minus4 + 4)); //frame_num

	if(head->idr_flag) {
	syn_sign  = dec_glb(str, 0);  //idr_pic_id
	}

	syn_unsign  = dec_fix(str, (head->sps_log2_max_poc_lsb_minus4 + 4));  //pic_order_cnt_lsb

	if(slice_type == 0) {
	syn_unsign  = dec_fix(str, 1);  //num_ref_idx_active_override_flag
	}

	if(slice_type == 0) {
	syn_unsign  = dec_fix(str, 1);  //ref_pic_list_modification_flag_l0
	ref_pic_list_modification_flag_l0 = syn_unsign;
	} else {
	ref_pic_list_modification_flag_l0 = 0;
	}

	if(ref_pic_list_modification_flag_l0) {
	modify_of_pic_muns_idc = 0;
	while(modify_of_pic_muns_idc != 3) {
	  syn_sign  = dec_glb(str, 0);    //modify_of_pic_nums_idc
	  modify_of_pic_muns_idc = syn_sign;

	  if(modify_of_pic_muns_idc == 0 || modify_of_pic_muns_idc == 1) {
	    syn_sign  = dec_glb(str, 0);  //abs_diff_pic_num_minus1
	  }
	}
	}

	if(head->idr_flag) {
	syn_unsign  = dec_fix(str, 1);  //no_output_of_prior_pics_flag
	syn_unsign  = dec_fix(str, 1);  //long_term_reference_flag
	} else {
	syn_unsign  = dec_fix(str, 1);  //adaptive_ref_pic_marking_mode_flag
	}

	if((head->pps_cavlc_mode == 0) && (head->idr_flag == 0)) {
	syn_unsign  = dec_glb(str, 0);  //cabac_init_idc
	}

	syn_sign  = dec_glb(str, 1);    //slice_qp_delta
	qp_delta  = syn_sign;
	head->pic_qp= (uint8_t) ((int8_t)head->pps_qp_ini + qp_delta);

	if(head->pps_cavlc_mode == 0) {   //cabac mode, align to 8bit
		str->used_bits = ((str->used_bits + 7) >> 3) << 3; 
	}
}

void dec_sps(struct str_info *str, struct h264_header *head)
{
	uint32_t   syn_unsign;
	int32_t   syn_sign;

	syn_unsign  = dec_fix(str, 8);  //profile_idc
	syn_unsign  = dec_fix(str, 8);  //
	syn_unsign  = dec_fix(str, 8);  //level_idc
	syn_sign  = dec_glb(str, 0);  //sps_id

	syn_sign  = dec_glb(str, 0);  //log2_max_frame_num_minus4
	head->sps_log2_max_fnum_minus4 = syn_sign;

	syn_sign  = dec_glb(str, 0);  //pic_order_cnt_type

	syn_sign  = dec_glb(str, 0);  //log2_max_pic_order_cnt_lsb_minus4
	head->sps_log2_max_poc_lsb_minus4 = syn_sign;

	syn_sign  = dec_glb(str, 0);  //max_mun_ref_frames
	syn_unsign  = dec_fix(str, 1);  //gaps_in_frame_num_value_allowed_flag

	syn_sign  = dec_glb(str, 0);  //pic_width_in_mbs_minus1
	head->sps_pic_width = (syn_sign + 1) * 16;

	syn_sign  = dec_glb(str, 0);  //pic_height_in_map_units_minus1
	head->sps_pic_height= (syn_sign + 1) * 16;

	h264_byte_align(str);
}

void dec_pps(struct str_info *str, struct h264_header *head)
{
	uint32_t   syn_unsign;
	int32_t   syn_sign;

	syn_sign  = dec_glb(str, 0);    //pps_id
	syn_sign  = dec_glb(str, 0);    //sps_id
	syn_unsign  = dec_fix(str, 1);    //entropy_coding_mode_flag
	head->pps_cavlc_mode = (syn_unsign == 0)? 1 : 0;

	syn_unsign  = dec_fix(str, 1);    //bottom_filed_pic_order_in_frame...
	syn_sign  = dec_glb(str, 0);    //num_slice_groups_minus1
	syn_sign  = dec_glb(str, 0);    //num_ref_idx_l0_default_active_minus1
	syn_sign  = dec_glb(str, 0);    //num_ref_idx_l1_default_active_minus1
	syn_unsign  = dec_fix(str, 1);    //weighted_pred_flag
	syn_unsign  = dec_fix(str, 2);    //weighted_bipred_idc

	syn_sign  = dec_glb(str, 1);    //pic_init_qp_minus26
	head->pps_qp_ini = syn_sign + 26;

	syn_sign  = dec_glb(str, 1);    //pic_init_qs_minus26

	syn_sign  = dec_glb(str, 1);    //chroma_qp_index_offset
	head->pps_chrom_qp_offset = syn_sign;

	h264_byte_align(str);
}

uint8_t nal_parse(struct str_info *str, struct h264_header *head)
{
	uint32_t   syn_unsign;
	uint8_t    nal_type;

	//initial read in 4 byte
	str->used_bits = 0;
	str->bit_len = 0;
	str->stream =0;
	h264_read_bs(str);

	//--- find the 0x00000001 nal start code
	while( str->stream != 0x00000001) {
		str->stream = str->stream << 8;
		str->bit_len -= 8;
		str->used_bits += 8;
		h264_read_bs(str);
	}

	//discard 0x00000001 start code
	str->bit_len = 0;
	str->used_bits += 32;
	str->stream = 0;
	h264_read_bs(str);

	syn_unsign  = dec_fix(str, 3);
	syn_unsign  = dec_fix(str, 5);
	nal_type  = syn_unsign;
	h264_read_bs(str);
	if(nal_type == pic_idr) {
		head->idr_flag = 1;
		dec_pic(str, head);
	} else if(nal_type == pic_data) {
		head->idr_flag = 0;
		dec_pic(str, head);
	} else if(nal_type == sps) {
		dec_sps(str, head);
	} else if(nal_type == pps) {
		dec_pps(str, head);
	} else {
		_os_printf("Unsupported NAL Unit type.\n\r");
	}

	return(nal_type);
}

void  h264_dec_flag_chk(uint32_t flags) {
  if((flags & 0x10) != 0) {	//check dec_err_flag
  	_os_printf("decoder syntax error.\n\r");
  }
  
  if((flags & 0x100) != 0) {//check bitstream read length error flag
  	_os_printf("decoder stream length error.\n\r");
  }
}

//return ptr point to byte location after 0x00000001
uint8_t* find_start_code(uint8_t* ptr) {

	struct str_info   str ;

	str.ptr= ptr;
	str.bit_len=0;
	str.used_bits=0;
	str.stream=0;

	//initial with 32bit
	h264_read_bs(&str);

	//--- find the 0x00000001 nal start code
	while(str.stream != 0x00000001) {
		str.stream  = str.stream << 8;
		str.bit_len -= 8;
		str.used_bits += 8;
		h264_read_bs(&str);

		//debug only
		//if((uint32_t)str.ptr >= (H264_FILE_BS_BASE + bs_size)) {
		//  print("Start code not find.\n\r");
		//}
	}
	return(str.ptr);
}

void  h264_enc_flag_chk(uint32 flags) {
  
}


void h264_clr_intr(struct h264_device *p_h264) {
  h264_set_sta(p_h264,0);
}

void h264_cfg_srcdat(struct h264_device *p_h264,uint8_t mode){
	h264_set_src_from(p_h264,mode); 
}

void h264_get_intr_status(struct h264_device *p_h264,struct h264_cfg_t *enc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl) {
  uint32   rdata ;
  rdata = h264_get_sta(p_h264);
  enc_ctl->enc_end_flags= rdata;
  
  if(enc_cfg->rc_en) {
    //rate control info
    rdata = h264_get_rate_ctl(p_h264);
    rdata = rdata >> 16;
    enc_ctl->hw_cal_qp = (rdata + (enc_ctl->frm_mblines >> 1)) / (enc_ctl->frm_mblines);    
  }
}

uint32  h264_cal_ref_base(uint32 buf_base, uint32 buf_end, uint32 last_base, uint32 last_offset) {
  uint32   addr  ;

  addr  = ((last_base + last_offset + 4095) >> 12) << 12; //4KB align
  //ring-buffer
  if(addr >= buf_end) {
    addr = addr - buf_end;
    addr = buf_base + addr;
  }
  return(addr);
}

//--- cal RC MB Line target byte for IPPPPPPP.... GOP mode
//--- target bitrate is traced through a GOP
uint32 h264_rc_cal(struct h264_cfg_t *enc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl)
{

	uint32 grp_byte      ;   //target byte number of a RC MB line group
	uint32 frm_byte      ;   //target byte number of a frame

	if(enc_ctl->frm_type == 2) {  //I frame, first Intra frame in a GOP
	    rc_ctl->gop_remain_frame = enc_cfg->frm_gop;
	    rc_ctl->p_qp_acc  = 0;
	    rc_ctl->p_acc_num = 0;
	    rc_ctl->p_avg     = (rc_ctl->gop_remain_byte - rc_ctl->i_byte) / (enc_cfg->frm_gop - 1);
	    rc_ctl->p_frm_max = rc_ctl->p_avg + (rc_ctl->p_avg >>3);    //+0.125 times variation within a GOP
	    rc_ctl->p_frm_min = rc_ctl->p_avg - (rc_ctl->p_avg >>3);    //-0.125 times variation within a GOP
	    frm_byte          = rc_ctl->i_byte;
	} else {      //other P frame in a GOP
	    frm_byte = rc_ctl->gop_remain_byte / rc_ctl->gop_remain_frame;
	    
	    if(frm_byte > rc_ctl->p_frm_max)
	      frm_byte = rc_ctl->p_frm_max;
	    else if(frm_byte < rc_ctl->p_frm_min)
	      frm_byte = rc_ctl->p_frm_min;
	}

	if(enc_cfg->rc_effort != 2)     //low/high-effort
	  frm_byte += (frm_byte >> 4);  //add 6% more to compensate the HW inaccurate

	enc_ctl->frm_target = frm_byte;
	grp_byte = (frm_byte*enc_cfg->rc_grp + (enc_ctl->frm_mblines >> 1)) / enc_ctl->frm_mblines;

	rc_ctl->gop_remain_frame --;
	return (grp_byte);
}

extern volatile uint32_t vpp_md_cnt;
void h264_start_enc_frm(struct h264_device *p_h264,struct h264_cfg_t *penc_cfg, struct h264_ctl_t *enc_ctl, struct h264_rc_ctl_t *rc_ctl) {
  uint32   rc_grp_byte     ;
  //uint32   frm_target_step ;
  uint32   lpf_lu_base     ;
  uint32   lpf_ch_base     ;
  uint32   wdata           ;
  uint32   rdata           ;
  uint32   con             ;
//  static  uint8_t  frm_num = 2;
  h264_frame* hf;
  uint32 addr;
  h264_error = 0;
  if(enc_ctl->gop_frm_cnt == 0) {
	if(penc_cfg->auto_ctl_3dnr == 1){
		if(penc_cfg->md_3dnr_timer == 0){
			if(penc_cfg->last_vpp_md != vpp_md_cnt){
			  if(penc_cfg->md_set_3dnr == 0){
				  penc_cfg->md_3dnr_en = penc_cfg->flt3d_en;
				  penc_cfg->md_set_3dnr = 1;
			  }
			  penc_cfg->flt3d_en = 0;		 //发现有在动,3d降噪先关闭
			  penc_cfg->md_3dnr_timer = 3;
			}else{
				penc_cfg->md_set_3dnr = 0;
				penc_cfg->flt3d_en = penc_cfg->md_3dnr_en;
			}
			penc_cfg->last_vpp_md = vpp_md_cnt;
		}else{
			penc_cfg->md_3dnr_timer--;
		}
	}	

  	if(penc_cfg->flt3d_en){
		if(penc_cfg->run_gop_3dnr == 0){
			enc_ctl->enc_first_frm = 1;
  			penc_cfg->run_gop_3dnr = penc_cfg->gop_rst_3dnr;
		}
		else
			penc_cfg->run_gop_3dnr--;
	}

	if(penc_cfg->stilltomove != 0){
		if(penc_cfg->move_remain_gop){
			penc_cfg->move_remain_gop--;
			penc_cfg->enc_bps = penc_cfg->move_enc_bps;
		}else{
			penc_cfg->enc_bps = penc_cfg->still_enc_bps;
		}
		
		enc_ctl->target_gop = ( ((uint32_t)penc_cfg->enc_bps * 1000 * (uint32_t)penc_cfg->frm_gop) / penc_cfg->frm_rate ) >> 3;
	}

	
    enc_ctl->frm_type = 2;
    rc_ctl->gop_remain_byte = enc_ctl->target_gop;
    enc_ctl->frm_qp   = rc_ctl->i_qp;
  } else {	
    enc_ctl->frm_type = 0;
    enc_ctl->frm_qp   = rc_ctl->p_qp;
  }

  	// --- ISP denoise turning ---
  	if(penc_cfg->md_3dnr_timer == 0 && penc_cfg->last_vpp_md == vpp_md_cnt){
		if ((penc_cfg->flt_noise_lev != penc_cfg->flt_noise_lev_last) || (penc_cfg->flt3d_en != penc_cfg->flt3d_en_last))
		{
			h264_3dnr_ini(p_h264, penc_cfg);
			enc_ctl->enc_first_frm = 1;
			penc_cfg->flt_noise_lev_last = penc_cfg->flt_noise_lev;
			penc_cfg->flt3d_en			 = penc_cfg->flt3d_en_last;
			//_os_printf("h264 nr: %d %d\r\n", penc_cfg->flt3d_en, penc_cfg->flt_noise_lev);
		}
	}    

  //--- write cfg regs
  
  wdata = enc_ctl->frm_type | (1 << 3) | (enc_ctl->enc_mode << 4) | (penc_cfg->enc_bs_buf_size << 16);
  con               = wdata;
  h264_set_frame_base_cfg(p_h264,enc_ctl->frm_type,enc_ctl->enc_mode,penc_cfg->enc_bs_buf_size,1); 
  h264_set_phy_img_size(p_h264,enc_ctl->frm_width,enc_ctl->frm_height);

  if(penc_cfg->rc_en){
	  h264_set_frame_qp(p_h264,enc_ctl->frm_qp);
  }
  else{
	  h264_set_frame_qp(p_h264,penc_cfg->ini_qp);
  }
  
  //--- cfg reg not change(if frame x/y size change, may need change)
  h264_set_timeout_limit(p_h264,enc_ctl->timeout_limit);
  h264_set_len_limit(p_h264,enc_ctl->bs_byte_limit);
#if H264_I_ONLY  
  h264_set_ref_lu_addr(p_h264,0X40000000,0X40000000);
  h264_set_ref_chro_addr(p_h264,0X40000000,0X40000000);

  //h264_set_ref_lu_addr(p_h264,enc_ctl->ref_lu_base,enc_ctl->ref_lu_base+(IMAGE_W_H264*(IMAGE_H_H264+48))/2);
  //h264_set_ref_chro_addr(p_h264,enc_ctl->ref_lu_base,enc_ctl->ref_lu_base+(IMAGE_W_H264*(IMAGE_H_H264+48))/2);  
#else
  h264_set_ref_lu_addr(p_h264,enc_ctl->ref_lu_base,enc_ctl->ref_lu_end);
  h264_set_ref_chro_addr(p_h264,enc_ctl->ref_ch_base,enc_ctl->ref_ch_end);
#endif

  h264_set_frame_num(p_h264,enc_ctl->gop_frm_cnt);  
  h264_set_enc_cnt(p_h264,enc_ctl->gop_frm_cnt);
  h264_set_enc_frame_id(p_h264,enc_ctl->idrid);
  
  h264_f_p		= get_h264_new_frame_head(1,H264_DEV_0_ID,con&BIT(1)); 							  //预先分配第一frame，待帧结束的时候再分配下一frame 		  
  h264_module_p = h264_f_p;   
  h264_module_p = get_node(h264_module_p,&h264_free_tab);
  if(h264_module_p == NULL){
	  _os_printf("need more node for new h264 frame start1\r\n");
	  while(1);
  }
  addr = get_addr(h264_module_p);
  h264_set_buf_addr(p_h264,addr);
  h264_module_p = get_node(h264_module_p,&h264_free_tab);
  if(h264_module_p == NULL){
	  _os_printf("need more node for new h264 frame start2\r\n");
	  while(1);
  }  
  addr = get_addr(h264_module_p);   
  h264_set_buf_addr(p_h264,addr);

  hf = list_entry((struct list_head *)h264_f_p,h264_frame,list);
  //hf->h264_num = frm_num;
  hf->h264_num = penc_cfg->count;
  penc_cfg->count++;
  //Xil_Out32((H264_REG_BASE + 12*4), (enc_ctl->frm_luma_size) >> 8); //MB number of a frame
  //p_h264->FRM_MB_NUM = (enc_ctl->frm_luma_size) >> 8;
  h264_set_frame_mb_num(p_h264,enc_ctl->frm_luma_size);
  //--- ref/lpf buf base
  //--- cal lpf write base
  lpf_lu_base = h264_cal_ref_base(enc_ctl->ref_lu_base, enc_ctl->ref_lu_end, enc_ctl->last_lpf_lu_base, enc_ctl->frm_luma_size);
  lpf_ch_base = h264_cal_ref_base(enc_ctl->ref_ch_base, enc_ctl->ref_ch_end, enc_ctl->last_lpf_ch_base, (enc_ctl->frm_luma_size >> 1));

#if H264_I_ONLY   
  h264_set_ref_wb_addr(p_h264,0X40000000,0X40000000);
  h264_set_ref_rb_addr(p_h264,0X40000000,0X40000000);

  //h264_set_ref_wb_addr(p_h264,enc_ctl->ref_lu_base,enc_ctl->ref_lu_base);
  //h264_set_ref_rb_addr(p_h264,enc_ctl->ref_lu_base,enc_ctl->ref_lu_base);  
#else
  h264_set_ref_wb_addr(p_h264,lpf_lu_base,lpf_ch_base);
  h264_set_ref_rb_addr(p_h264,enc_ctl->last_lpf_lu_base,enc_ctl->last_lpf_ch_base);
#endif
  enc_ctl->last_lpf_lu_base = lpf_lu_base;
  enc_ctl->last_lpf_ch_base = lpf_ch_base;
  
  //--- rate contrl
  wdata = ((penc_cfg->rc_grp - 1)<<0) | (penc_cfg->rc_effort << 4) | (penc_cfg->rc_en <<7);
  //Xil_Out32((H264_REG_BASE + 16*4), wdata);
  //p_h264->RC_CTL   = wdata;
  h264_set_frame_rate_ctl(p_h264,penc_cfg->rc_grp,penc_cfg->rc_effort,penc_cfg->rc_en);

  
  
  if(penc_cfg->rc_en) {
    rc_grp_byte = h264_rc_cal(penc_cfg, enc_ctl, rc_ctl);    
    //p_h264->RC_BYTE   = rc_grp_byte;
    h264_set_rate_ctl_byte(p_h264,rc_grp_byte);
    if(penc_cfg->rc_effort == 2) {
      //p_h264->RC_RDCOST   = rc_ctl->frm_rdcost;
	  h264_set_rate_ctl_rdcost(p_h264,rc_ctl->frm_rdcost);
    } 
  }

  //--- 3DNR
  if(penc_cfg->flt3d_en) {
    rdata   = h264_get_flt_3dnr(p_h264);     //获取上一帧结果 
    wdata   = rdata & 0x0fffffff;
  	if(h264_dev_num == 2){
		if(penc_cfg == &enc_cfg){               //当前是主镜头，那表示上次获取到的是副镜头
			enc_2_cfg.r3dnr  = wdata;
			//os_printf("Y0:%08x cont:%d r:%d\r\n",wdata,penc_cfg->count,penc_cfg->run_gop_3dnr);
			penc_cfg->r3dnr  = enc_cfg.r3dnr;   //拿回主镜头的参数
		}else{								    //当前是副镜头，那表示上次获取到的是主镜头
			enc_cfg.r3dnr    = wdata;
			//os_printf("Y1:%08x cont:%d r:%d\r\n",wdata,penc_cfg->count,penc_cfg->run_gop_3dnr);
			penc_cfg->r3dnr  = enc_2_cfg.r3dnr; //拿回副镜头的参数
		}
	}else{
		penc_cfg->r3dnr  = wdata;
	}
	
    if(enc_ctl->enc_first_frm == 1){
		penc_cfg->r3dnr = penc_cfg->r3dnr; 		   //disable 3DNR for first frame	
	}
    else{
    	penc_cfg->r3dnr = penc_cfg->r3dnr | (3 << 28);//enable 3DNR   //结果保存下来
		
	}
	h264_set_flt_3dnr(p_h264,penc_cfg->r3dnr);
  }else{
	  penc_cfg->r3dnr = penc_cfg->r3dnr & 0x0fffffff;
	  h264_set_flt_3dnr(p_h264,penc_cfg->r3dnr);
  }

  //configure mb_pipe_cnt
  if((penc_cfg->flt3d_en == 0) && (enc_ctl->frm_type == 2))    //I frame and 3DNR disable
    wdata = ((460-2) << 16) | 460;
  else
    wdata = ((502-2) << 16) | 502; 

  //crop_en
  if((penc_cfg->frm_height != penc_cfg->wrap_height)){
	  	//p_h264->Y_CROP = BIT(31)|4;
	  	h264_set_y_crop(p_h264,1,penc_cfg->frm_height - penc_cfg->wrap_height);
  }
  else
  {
		h264_set_y_crop(p_h264,0,8);
  }

  penc_cfg->enc_runing = 1;

  //p_h264->MB_PIPE = wdata;
  h264_set_mb_pipe(p_h264,wdata);
  //configure ROI window
  //p_h264->WRAP_CON |= BIT(7);
  h264_set_sw_ready(p_h264);
//  if(con&BIT(1)){
//	  _os_printf("is iframe \r\n");
//  }else{
//	  _os_printf("is pframe \r\n");
//  }
//  ll_gpio_bit_set(GPIOD,BIT(9));
//  ll_gpio_bit_reset(GPIOD,BIT(9));
//  _os_printf("  [CON:%x ] ",con);
  //--- start encode a frame
  //enc_ctl->bs_buf_id = 0;
}

void h264_frame_done_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	h264_frame* hf;
	uint32 	  rdata;
	uint16 imb_mov_num;
	uint8_t 	drop = 0;
	uint8_t 	new_gop = 0;	//为了缩时录影,强行需要I帧
	//uint32 	dat_ofs=0;
	uint32     bw_cnt_wr,bw_cnt_rd,enc_cnt_cyc;
	struct h264_device *p_h264 = (struct h264_device *)irq_data;

	bw_cnt_wr = h264_get_bandwidth_wr(p_h264);
	bw_cnt_rd = h264_get_bandwidth_rd(p_h264);
	enc_cnt_cyc = h264_get_cyc_done_num(p_h264);
	
	rdata	 = h264_get_frame_len(p_h264);

	//如果超过某个size,就认为图片太大,就重新生成吧
	if(rdata*3/2 > (H264_NODE_LEN*H264_NODE_NUM))
	{
		h264_set_err(p_h264,1);
		os_printf(KERN_ERR"h264 size over:%d\n",rdata);
	}
//	dat_ofs = rdata%(16*1024);
//	if(dat_atbuf == 0)
//	{
		//ll_m2m_memcpy(M2M_DMA0,frame_cache+frame_offset,h264_dat_buf[0],dat_ofs,0);
//	}else{
		//ll_m2m_memcpy(M2M_DMA0,frame_cache+frame_offset,h264_dat_buf[1],dat_ofs,0);
//	}
	//帧OK
	if(penc_ctl->gop_frm_cnt != 0){
		if(penc_cfg->stilltomove == 0){
			penc_cfg->still_enc_bps = penc_cfg->enc_bps;
			penc_cfg->move_enc_bps = penc_cfg->enc_bps;
		}else{
			imb_mov_num = h264_get_imb_num(p_h264);
			if(((imb_mov_num*1000)/((penc_cfg->frm_width * penc_cfg->frm_height)/256)) > penc_cfg->stilltomove){
				//_os_printf("dev running ,cfg move enc_fps(%d)",h264_get_imb_num(p_h264));
				penc_cfg->move_remain_gop = penc_cfg->move_keep_gop;
			}
		}
	}
		
	hf = list_entry((struct list_head *)h264_f_p,h264_frame,list);
	hf->frame_len = rdata;
	hf->which = penc_cfg->src_from;
	hf->srcID = video_msg.video_type_cur + FRAMEBUFF_SOURCE_CAMERA0; 
	
	//因为有预分配机制，所以要先去掉最后一个节点
	//_os_printf("bw_rd:%d   bw_wr:%d\r\n",h264_get_bandwidth_rd(p_h264),h264_get_bandwidth_wr(p_h264));
	//os_printf("---H(%d  %d)",h264_dev_num,penc_cfg->src_from);

	if(h264_module_p)
	{
		put_node(&h264_free_tab,h264_module_p->prev);
	}
	
	if(h264_is_running(p_h264) == 1){
		hf->w = penc_cfg->wrap_width;
		hf->h = penc_cfg->wrap_height;
		set_frame_ready(hf);
	}
	
	penc_ctl->enc_bs_byte = rdata;
	h264_get_intr_status(p_h264,(struct	h264_cfg_t*)penc_cfg, (struct h264_ctl_t*)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
	h264_clr_intr(p_h264);
	
	//--- user add function to check the flags
	h264_enc_flag_chk(penc_ctl->enc_end_flags);
	
	if(penc_cfg->rc_en)
	  h264_rc_tune_eof(p_h264,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
	
	h264_enc_eof_update((struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);

	if(h264_is_running(p_h264) == 0){
		del_264_frame(h264_f_p);
		return;
	}

	if(param || h264_is_err(p_h264)){
		os_printf("isp ov,h264 frame drop\r\n");
		drop = 1;
		h264_set_err(p_h264,0);
		del_264_frame(h264_f_p);
		if(h264_dev_num == 2){
			if(penc_ctl == &enc_ctl){
				recfg_h264_new_grop[0] = 1; 
			}else{
				recfg_h264_new_grop[1] = 1;
			}
		}else{
			recfg_h264_new_grop[0] = 1; 	  //重新配置成I帧
		}
		os_printf("grop[0]:%d\tgrop[1]:%d\tfrom:%d\n",recfg_h264_new_grop[0],recfg_h264_new_grop[1],penc_cfg->src_from);
	}

///////////////////////////////////////////////////////
		
	//p_h264->WRAP_CON |= 0x01|0x10;
///////////////////////////////////////////////////////
	if(h264_dev_num == 2){
		//只有不丢帧的情况才能切换到副码流,仅仅适用主码流(vpp)+镜头副码流情况(不适合从外部其他来源gen420编码)
		if(penc_ctl == &enc_ctl && drop == 0 ){
			penc_ctl = &enc_2_ctl;
			penc_cfg = &enc_2_cfg;
			prc_ctl  = &rc_2_ctl; 

			if(recfg_h264_new_grop[1] == 1){
				recfg_h264_new_grop[1] = 0;
				penc_ctl->gop_frm_cnt = 0;
			}
			
			if(penc_ctl->gop_frm_cnt == 0){               //I帧再做调整，保证上个gop完成
				if(h264_cfg_modify((struct h264_cfg_t *)penc_cfg,2)){
					h264_ini_recfg((struct h264_cfg_t *)penc_cfg,(struct h264_ctl_t *)penc_ctl,(struct h264_rc_ctl_t *)prc_ctl);
				}
			}
		}else{
			penc_ctl = &enc_ctl;
			penc_cfg = &enc_cfg;
			prc_ctl  = &rc_ctl;

			if(recfg_h264_new_grop[0] == 1){
				recfg_h264_new_grop[0] = 0;
				penc_ctl->gop_frm_cnt = 0;
			}
			
			if(penc_ctl->gop_frm_cnt == 0){
				if(h264_cfg_modify((struct h264_cfg_t *)penc_cfg,1)){
					h264_ini_recfg((struct h264_cfg_t *)penc_cfg,(struct h264_ctl_t *)penc_ctl,(struct h264_rc_ctl_t *)prc_ctl);
				}
			}
		}
	}else{
		if(recfg_h264_new_grop[0] == 1){
			recfg_h264_new_grop[0] = 0;
			penc_ctl->gop_frm_cnt = 0;
			new_gop = 1;
		}

		if(penc_ctl->gop_frm_cnt == 0){
			if(h264_cfg_modify((struct h264_cfg_t *)penc_cfg,1)){
				h264_ini_recfg((struct h264_cfg_t *)penc_cfg,(struct h264_ctl_t *)penc_ctl,(struct h264_rc_ctl_t *)prc_ctl);
			}
		}
	}	

	h264_set_wrap_img_size(p_h264,penc_cfg->wrap_width,penc_cfg->wrap_height);
	
	penc_ctl->bs_buf_id = 0;	
	if(penc_cfg->src_from == GEN420_DATA)
	{
		//唤醒任务去kick gen420
		extern void *get_vpp_psram_buf();
		wake_up_gen420_queue(1,get_vpp_psram_buf());
	}else{
		if(!penc_cfg->timeLapse_en)
		{
			h264_cfg_srcdat(p_h264,penc_cfg->src_from);
			h264_start_enc_frm(p_h264,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
		}
		else
		{
			if(timeLapse_wk)
			{
				if(new_gop)
				{
					h264_cfg_srcdat(p_h264,penc_cfg->src_from);
					h264_start_enc_frm(p_h264,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
				}
				else
				{
					h264_cfg_srcdat(p_h264,SOFT_DATA);
					penc_cfg->timeLapse_ready_kick = 1;
					timeLapse_wk->last_kick_time += timeLapse_wk->timer;	//设置下一次kick的时间
					os_run_work(&timeLapse_wk->wk);
				}

			}

		}

	}	
	_os_printf(KERN_DEBUG"Z%d",penc_cfg->src_from);

}

void h264_frame_done_norekick_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	h264_frame* hf;
	uint32 	  rdata;
	uint16 imb_mov_num;
	//uint32 	dat_ofs=0;
	uint32     bw_cnt_wr,bw_cnt_rd,enc_cnt_cyc;
	struct h264_device *p_h264 = (struct h264_device *)irq_data;

	bw_cnt_wr = h264_get_bandwidth_wr(p_h264);
	bw_cnt_rd = h264_get_bandwidth_rd(p_h264);
	enc_cnt_cyc = h264_get_cyc_done_num(p_h264);
	
	rdata	 = h264_get_frame_len(p_h264);
//	dat_ofs = rdata%(16*1024);
//	if(dat_atbuf == 0)
//	{
		//ll_m2m_memcpy(M2M_DMA0,frame_cache+frame_offset,h264_dat_buf[0],dat_ofs,0);
//	}else{
		//ll_m2m_memcpy(M2M_DMA0,frame_cache+frame_offset,h264_dat_buf[1],dat_ofs,0);
//	}
	//帧OK
	if(penc_ctl->gop_frm_cnt != 0){
		if(penc_cfg->stilltomove == 0){
			penc_cfg->still_enc_bps = penc_cfg->enc_bps;
			penc_cfg->move_enc_bps = penc_cfg->enc_bps;
		}else{
			imb_mov_num = h264_get_imb_num(p_h264);
			if(((imb_mov_num*1000)/((penc_cfg->frm_width * penc_cfg->frm_height)/256)) > penc_cfg->stilltomove){
				//_os_printf("dev running ,cfg move enc_fps(%d)",h264_get_imb_num(p_h264));
				penc_cfg->move_remain_gop = penc_cfg->move_keep_gop;
			}
		}
	}
		
	hf = list_entry((struct list_head *)h264_f_p,h264_frame,list);
	hf->frame_len = rdata;
	hf->which = penc_cfg->src_from;
	hf->srcID = video_msg.video_type_cur + FRAMEBUFF_SOURCE_CAMERA0; 
	
	//因为有预分配机制，所以要先去掉最后一个节点
	//_os_printf("bw_rd:%d   bw_wr:%d\r\n",h264_get_bandwidth_rd(p_h264),h264_get_bandwidth_wr(p_h264));
	//os_printf("---H(%d  %d)",h264_dev_num,penc_cfg->src_from);

	put_node(&h264_free_tab,h264_module_p->prev);
	if(h264_is_running(p_h264) == 1){
		set_frame_ready(hf);
	}
	
	enc_ctl.enc_bs_byte = rdata;
	h264_get_intr_status(p_h264,(struct	h264_cfg_t*)penc_cfg, (struct h264_ctl_t*)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
	h264_clr_intr(p_h264);
	
	//--- user add function to check the flags
	h264_enc_flag_chk(penc_ctl->enc_end_flags);
	
	if(penc_cfg->rc_en)
	  h264_rc_tune_eof(p_h264,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
	
	h264_enc_eof_update((struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);

	if(h264_is_running(p_h264) == 0){
		del_264_frame(h264_f_p);
		h264_sema_up();
		return;
	}

	if(param){
		os_printf("isp ov,h264 frame drop\r\n");
		del_264_frame(h264_f_p);
		if(h264_dev_num == 2){
			if(penc_ctl == &enc_ctl){
				recfg_h264_new_grop[1] = 1; 
			}else{
				recfg_h264_new_grop[0] = 1;
			}
		}else{
			recfg_h264_new_grop[0] = 1; 	  //重新配置成I帧
		}
	}

	if(recfg_h264_new_grop[0] == 1){
		recfg_h264_new_grop[0] = 0;
		penc_ctl->gop_frm_cnt = 0;
	}
	
	penc_cfg->enc_runing = 0;
	os_printf(KERN_DEBUG"Z%d",penc_cfg->src_from);
	h264_sema_up();
}


void h264_sema_init()
{
	if(h264_sem.magic == 0){
		os_sema_init(&h264_sem,0);
	}
}

int32 h264_sema_down(int32 tmo_ms)
{
	int32 ret;
	ret = os_sema_down(&h264_sem,tmo_ms);
	return ret;
}

void h264_sema_up()
{
	os_sema_up(&h264_sem);
}

void h264_drv_init(){
	struct h264_device *p_h264;
	p_h264 = (struct h264_device *)dev_get(HG_H264_DEVID);

	h264_sema_init();
	h264_init(p_h264,H264_HARDWARE_CLK);
}


void h264_frame_dec_done_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	//struct h264_device *p_h264 = (struct h264_device *)irq_data;
	//frame_done = 1;
	h264_sema_up();
	//_os_printf("h264 dec end\r\n");
}


void h264_buf0_done_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	struct h264_device *p_h264 = (struct h264_device *)irq_data;
	uint32 addr;
	//_os_printf("B0");
	h264_module_p = get_node(h264_module_p,&h264_free_tab);
	if(h264_module_p == NULL){
		_os_printf("need more node for new h264 frame start\r\n");
		h264_set_err(p_h264,1);
		return ;
	}
	addr = get_addr(h264_module_p);
	h264_set_buf_addr(p_h264,addr);
	//_os_printf("B0");
	enc_ctl.bs_buf_id = (penc_ctl->bs_buf_id + 1) & 0x01;	
}

void h264_buf1_done_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	struct h264_device *p_h264 = (struct h264_device *)irq_data;
	uint32 addr;
	//_os_printf("B1");
	h264_module_p = get_node(h264_module_p,&h264_free_tab);
	if(h264_module_p == NULL){
		_os_printf("need more node for new h264 frame start\r\n");
		h264_set_err(p_h264,1);
		return ;
	}
	addr = get_addr(h264_module_p);
	h264_set_buf_addr(p_h264,addr);
	//_os_printf("B1");
	enc_ctl.bs_buf_id = (penc_ctl->bs_buf_id + 1) & 0x01;	
}

void h264_frame_fast_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	//struct h264_device *p_h264 = (struct h264_device *)irq_data;
	//_os_printf("********************************%s  %d\r\n",__func__,__LINE__);
	_os_printf(KERN_INFO"(F)");
}


void h264_pixel_fast_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
//	struct h264_device *p_h264 = (struct h264_device *)irq_data;
	
	printf(KERN_INFO"(P)");
//	printf("******************************** %s  %d\r\n",__func__,__LINE__);
//	h264_error = 1;
}

void h264_soft_slow_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	//struct h264_device *p_h264 = (struct h264_device *)irq_data;
	_os_printf(KERN_INFO"******************************** %s  %d\r\n",__func__,__LINE__);
}


void h264_pixel_done_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	//struct h264_device *p_h264 = (struct h264_device *)irq_data;
	//_os_printf("mbl_calc:%d   mb_calc_max:%d\r\n",h264_get_mbl_calc(p_h264),h264_get_mbl_calc_max(p_h264));

}

void h264_enc_timeout_isr(uint32 irq_flags, uint32 irq_data, uint32 param){
	//struct h264_device *p_h264 = (struct h264_device *)irq_data;
	//_os_printf("(ENC TIMOUT)");
	//_os_printf("mbl_calc:%d   mb_calc_max:%d\r\n",h264_get_mbl_calc(p_h264),h264_get_mbl_calc_max(p_h264));

}

void h264_isr_init(struct h264_device *p_h264){
	h264_request_irq(p_h264,H264_FRAME_DONE,(h264_irq_hdl )&h264_frame_done_isr,(uint32)p_h264);
	h264_request_irq(p_h264,H264_BUF0_FULL ,(h264_irq_hdl )&h264_buf0_done_isr,(uint32)p_h264);		
	h264_request_irq(p_h264,H264_BUF1_FULL ,(h264_irq_hdl )&h264_buf1_done_isr,(uint32)p_h264);	
	h264_request_irq(p_h264,H264_SOFT_SLOW ,(h264_irq_hdl )&h264_soft_slow_isr,(uint32)p_h264);
	h264_request_irq(p_h264,H264_FRAME_FAST,(h264_irq_hdl )&h264_frame_fast_isr,(uint32)p_h264);	
	h264_request_irq(p_h264,H264_PIXEL_FAST,(h264_irq_hdl )&h264_pixel_fast_isr,(uint32)p_h264);
	h264_request_irq(p_h264,H264_PIXEL_DONE,(h264_irq_hdl )&h264_pixel_done_isr,(uint32)p_h264);		
	h264_request_irq(p_h264,H264_ENC_TIME_OUT,(h264_irq_hdl )&h264_enc_timeout_isr,(uint32)p_h264);
}

#ifdef SYS_APP_WALKIE_TALKIE
void h264_main_sensor_cfg(struct h264_device *p_h264,uint32_t w,uint32_t h,uint8_t src_from){
	enc_cfg.enc_mode		= 1;	//0:dec, 1:enc
	enc_cfg.enc_bs_buf_size = 4;	//0:1KB; 1:2KB; 2:4KB; 3:8KB; 4:16KB
	enc_cfg.frm_width		= (w+0xf)&(~0xf);
	enc_cfg.frm_height		= (h+0xf)&(~0xf);
	enc_cfg.wrap_width      = w;
	enc_cfg.wrap_height     = h;
	enc_cfg.src_from        = src_from;
	enc_cfg.enc_bps 		= 200; //Kbit pre second
	
	enc_cfg.still_enc_bps   = 100;    //Kbit pre second
	enc_cfg.move_enc_bps    = 200;   //Kbit pre second	
	enc_cfg.stilltomove     = 100;    //permil for judgmemnt is move or still 
	enc_cfg.move_keep_gop   = 5;	
	enc_cfg.frm_rate		= 25;	//fps
#if H264_I_ONLY 
	enc_cfg.frm_gop 		= 1;	//IPPPP frame number of a gop
	enc_cfg.rc_en			= 0;	//enc rate control enable
#else
	enc_cfg.frm_gop 		= 25;	//IPPPP frame number of a gop
	enc_cfg.rc_en			= 1;	//enc rate control enable
#endif	
	enc_cfg.rc_grp			= 2;	//mb line number when RC change qp
	enc_cfg.rc_effort		= 2;	//0:low; 1: high; 2:relax;
	//still video: bigger frm_ip_rate; moving video: smaller frm_ip_rate;
	enc_cfg.frm_ip_rate 	= 10;	//initial (Intra MB line)/(Inter MB line) target bit rate times; not critical parameter.
	enc_cfg.frm_ip_rate_max = 15;
	enc_cfg.frm_ip_rate_min = 5;
	enc_cfg.flt3d_en		= 0;	//3D filter enable    对讲机一定要关掉
	enc_cfg.flt3d_en_last	= 1;	//3D filter enable
	enc_cfg.flt_noise_lev	= 2;	//0: very low nosie; 1: low; 2: medium; 3: high; 4: very high; naomal usage is: 2
    enc_cfg.flt_noise_lev_last = enc_cfg.flt_noise_lev;
	enc_cfg.ini_qp			= 26;	//initial QP for this sequence, not critical
	enc_cfg.roi_qp			= 22;	//QP used in ROI windows
	enc_cfg.gop_rst_3dnr    = 10;   //10个ip gop后，重新使能一下3dnr
	enc_cfg.auto_ctl_3dnr   = 0;    //需要打开vpp移动帧测，否则无效

	enc_cfg.run_gop_3dnr    = enc_cfg.gop_rst_3dnr;
	h264_ini_seting_cfg(p_h264,(struct h264_cfg_t *)&enc_cfg, (struct h264_ctl_t *)&enc_ctl, (struct h264_rc_ctl_t *)&rc_ctl,1);
	if(enc_cfg.flt3d_en) {
	  enc_cfg.r3dnr = h264_get_flt_3dnr(p_h264);
	  enc_cfg.r3dnr = enc_cfg.r3dnr & 0x0fffffff;
	  h264_3dnr_ini(p_h264,(struct h264_cfg_t *)&enc_cfg);
//	  os_printf("Z:%08x\r\n",enc_cfg.r3dnr);
	}
	
}
#else
void h264_main_sensor_cfg(struct h264_device *p_h264,uint32_t w,uint32_t h,uint8_t src_from){
	enc_cfg.enc_mode		= 1;	//0:dec, 1:enc
	enc_cfg.enc_bs_buf_size = 4;	//0:1KB; 1:2KB; 2:4KB; 3:8KB; 4:16KB
	enc_cfg.frm_width		= (w+0xf)&(~0xf);
	enc_cfg.frm_height		= (h+0xf)&(~0xf);
	enc_cfg.wrap_width      = w;
	enc_cfg.wrap_height     = h;
	enc_cfg.src_from        = src_from;
	enc_cfg.enc_bps 		= 4000; //Kbit pre second
	
	enc_cfg.still_enc_bps   = 600;    //Kbit pre second
	enc_cfg.move_enc_bps    = 4000;   //Kbit pre second	
	enc_cfg.stilltomove     = 0;    //permil for judgmemnt is move or still
	enc_cfg.move_keep_gop   = 5;
	enc_cfg.frm_rate		= 25;	//fps
#if H264_I_ONLY 
	enc_cfg.frm_gop 		= 1;	//IPPPP frame number of a gop
	enc_cfg.rc_en			= 0;	//enc rate control enable
#else
	enc_cfg.frm_gop 		= 25;	//IPPPP frame number of a gop
	enc_cfg.rc_en			= 1;	//enc rate control enable
#endif	
	enc_cfg.rc_grp			= 2;	//mb line number when RC change qp
	enc_cfg.cc_corect		= 0;	//0: no corection; 1: corection
	enc_cfg.rc_effort		= 2;	//0:low; 1: high; 2:relax;
	//still video: bigger frm_ip_rate; moving video: smaller frm_ip_rate;
	enc_cfg.frm_ip_rate 	= 10;	//initial (Intra MB line)/(Inter MB line) target bit rate times; not critical parameter.
	enc_cfg.frm_ip_rate_max = 15;
	enc_cfg.frm_ip_rate_min = 5;
	enc_cfg.flt3d_en		= 1;	//3D filter enable    对讲机一定要关掉
	enc_cfg.flt3d_en_last	= 1;	//3D filter enable
	enc_cfg.flt_noise_lev	= 2;	//0: very low nosie; 1: low; 2: medium; 3: high; 4: very high; naomal usage is: 2
    enc_cfg.flt_noise_lev_last = enc_cfg.flt_noise_lev;
	enc_cfg.ini_qp			= 26;	//initial QP for this sequence, not critical
	enc_cfg.roi_qp			= 22;	//QP used in ROI windows
	enc_cfg.gop_rst_3dnr    = 10;   //10个ip gop后，重新使能一下3dnr
	enc_cfg.auto_ctl_3dnr   = 1;    //需要打开vpp移动帧测，否则无效

	enc_cfg.run_gop_3dnr    = enc_cfg.gop_rst_3dnr;
	h264_ini_seting_cfg(p_h264,(struct h264_cfg_t *)&enc_cfg, (struct h264_ctl_t *)&enc_ctl, (struct h264_rc_ctl_t *)&rc_ctl,1);
	if(enc_cfg.flt3d_en) {
	  enc_cfg.r3dnr = h264_get_flt_3dnr(p_h264);
	  enc_cfg.r3dnr = enc_cfg.r3dnr & 0x0fffffff;
	  h264_3dnr_ini(p_h264,(struct h264_cfg_t *)&enc_cfg);
//	  os_printf("Z:%08x\r\n",enc_cfg.r3dnr);
	}
	
}
#endif

void h264_second_sensor_cfg(struct h264_device *p_h264,uint32_t w,uint32_t h,uint8_t src_from){

	enc_2_cfg.enc_mode		= 1;	//0:dec, 1:enc
	enc_2_cfg.enc_bs_buf_size = 4;	//0:1KB; 1:2KB; 2:4KB; 3:8KB; 4:16KB
	enc_2_cfg.frm_width		= (w+0xf)&(~0xf);//w;//
	enc_2_cfg.frm_height	= (h+0xf)&(~0xf);//h;//
	enc_2_cfg.wrap_width    = w;
	enc_2_cfg.wrap_height   = h;
	enc_2_cfg.src_from      = src_from;	
	enc_2_cfg.enc_bps 		= 1000; //Kbit pre second

	enc_2_cfg.still_enc_bps = 300;    //Kbit pre second
	enc_2_cfg.move_enc_bps  = 1000;   //Kbit pre second	
	enc_2_cfg.stilltomove   = 0;    //permil for judgmemnt is move or still
	enc_2_cfg.move_keep_gop = 5;
	enc_2_cfg.frm_rate		= 25;	//fps
#if H264_I_ONLY
	enc_2_cfg.frm_gop		= 1;	//IPPPP frame number of a gop
	enc_2_cfg.rc_en 		= 0;	//enc rate control enable
#else
	enc_2_cfg.frm_gop 		= 25;	//IPPPP frame number of a gop
	enc_2_cfg.rc_en			= 1;	//enc rate control enable
#endif	
	enc_2_cfg.rc_grp		= 2;	//mb line number when RC change qp
	enc_2_cfg.cc_corect		= 0;	//0: no corection; 1: corection
	enc_2_cfg.rc_effort		= 2;	//0:low; 1: high; 2:relax;
	//still video: bigger frm_ip_rate; moving video: smaller frm_ip_rate;
	enc_2_cfg.frm_ip_rate 	= 10;	//initial (Intra MB line)/(Inter MB line) target bit rate times; not critical parameter.
	enc_2_cfg.frm_ip_rate_max = 15;
	enc_2_cfg.frm_ip_rate_min = 5;
	enc_2_cfg.flt3d_en		= 1;	//3D filter enable
    enc_2_cfg.flt3d_en_last = 1;	
	enc_2_cfg.flt_noise_lev	= 2;	//0: very low nosie; 1: low; 2: medium; 3: high; 4: very high; naomal usage is: 2
    enc_2_cfg.flt_noise_lev_last = enc_2_cfg.flt_noise_lev;
	enc_2_cfg.ini_qp		= 26;	//initial QP for this sequence, not critical
	enc_2_cfg.roi_qp		= 22;	//QP used in ROI windows
	enc_2_cfg.gop_rst_3dnr	= 10;	//10个ip gop后，重新使能一下3dnr
	enc_2_cfg.auto_ctl_3dnr	= 1;   

	enc_2_cfg.run_gop_3dnr	= enc_2_cfg.gop_rst_3dnr;
	h264_ini_seting_cfg(p_h264,(struct h264_cfg_t *)&enc_2_cfg, (struct h264_ctl_t *)&enc_2_ctl, (struct h264_rc_ctl_t *)&rc_2_ctl,2);
	if(enc_2_cfg.flt3d_en) {
	  enc_2_cfg.r3dnr = h264_get_flt_3dnr(p_h264);
	  enc_2_cfg.r3dnr = enc_cfg.r3dnr & 0x0fffffff;
	  h264_3dnr_ini(p_h264,(struct h264_cfg_t *)&enc_2_cfg);
//	  os_printf("N:%08x\r\n",enc_2_cfg.r3dnr);
	}
	
}


//init就初始化,需要申请释放配合使用,否则内存泄漏
//暂时没有返回值
//申请空间需要16对齐
int h264_mem_init(uint8_t init,uint32_t drv1_w,uint32_t drv1_h,uint32_t drv2_w,uint32_t drv2_h)
{
	uint8_t err = 0;
	uint32_t lu_base_buf_size,ch_base_size,h264_room_size;
	if(init)
	{
		if(drv1_w && drv1_h)
		{
			drv1_w = (drv1_w+0xf)&(~0xf);
			drv1_h = (drv1_h+0xf)&(~0xf);
#if H264_I_ONLY
			lu_base_buf_size = 4096 + 4096;
			ch_base_size = 4096 + 4096;
#else
			lu_base_buf_size = (drv1_w*(drv1_h+48)) + 4096 + 4096;
			ch_base_size = (drv1_w*(drv1_h+48))/2  + 4096 + 4096;
#endif		
			h264_ref_lu_base_psram = H264_MALLOC(lu_base_buf_size);
			h264_ref_ch_base_psram = H264_MALLOC(ch_base_size);

			if(!h264_ref_lu_base_psram || !h264_ref_ch_base_psram)
			{
				err = 1;
				goto h264_mem_init_end;
			}
			else
			{
				sys_dcache_invalid_range((uint32_t *) h264_ref_lu_base_psram, lu_base_buf_size);
				sys_dcache_invalid_range((uint32_t *) h264_ref_ch_base_psram, ch_base_size);
			}
		}

		if(drv2_w && drv2_h)
		{
			drv2_w = (drv2_w+0xf)&(~0xf);
			drv2_h = (drv2_h+0xf)&(~0xf);
#if H264_I_ONLY
			lu_base_buf_size = 4096 + 4096;
			ch_base_size = 4096 + 4096;
#else
			lu_base_buf_size = (drv2_w*(drv2_h+48)) + 4096 + 4096;
			ch_base_size = (drv2_w*(drv2_h+48))/2  + 4096 + 4096;
#endif		
			h264_ref_lu_base_psram2 = H264_MALLOC(lu_base_buf_size);
			h264_ref_ch_base_psram2 = H264_MALLOC(ch_base_size);


			if(!h264_ref_lu_base_psram2 || !h264_ref_ch_base_psram2)
			{

				err = 1;
				goto h264_mem_init_end;
			}
			else
			{
				sys_dcache_invalid_range((uint32_t *) h264_ref_lu_base_psram2, lu_base_buf_size);
				sys_dcache_invalid_range((uint32_t *) h264_ref_ch_base_psram2, ch_base_size);
			}
		}

		h264_room_size = H264_NODE_NUM*H264_NODE_LEN + 1024;
		h264_room_psram = H264_MALLOC(h264_room_size);;
		if(!h264_room_psram)
		{
			err = 1;
			goto h264_mem_init_end;
		}
		else
		{
			sys_dcache_invalid_range((uint32_t *) h264_room_psram, h264_room_size);
		}
	}
	else
	{
		err = 2;
	}

	h264_mem_init_end:
	if(err)
	{
		if(timeLapse_wk)
		{
			os_work_cancle2(&timeLapse_wk->wk, 1);
			H264_LIB_FREE(timeLapse_wk);
			timeLapse_wk = NULL;
		}
		if(h264_ref_lu_base_psram)
		{
			H264_FREE(h264_ref_lu_base_psram);
			h264_ref_lu_base_psram = NULL;
		}

		if(h264_ref_ch_base_psram)
		{
			H264_FREE(h264_ref_ch_base_psram);
			h264_ref_ch_base_psram = NULL;
		}


		if(h264_ref_lu_base_psram2)
		{
			H264_FREE(h264_ref_lu_base_psram2);
			h264_ref_lu_base_psram2 = NULL;
		}

		if(h264_ref_ch_base_psram2)
		{
			H264_FREE(h264_ref_ch_base_psram2);
			h264_ref_ch_base_psram2 = NULL;
		}

		if(h264_room_psram)
		{
			H264_FREE(h264_room_psram);
			h264_room_psram = NULL;
		}
	}
	return err;

}

int h264_enc(uint32_t drv1_from,uint32_t drv1_w,uint32_t drv1_h,uint32_t drv2_from,uint32_t drv2_w,uint32_t drv2_h){
//	uint32_t 	cnt=0;
//	uint32 start_time;
//	uint32_t 	dat_ofs=0;
//	uint32_t 	yuv_offset=0;
//	uint32_t 	bs_offset=0;	  //BS file offset
//	uint32_t 	x, y;
	//uint32_t	  dma_cmd_base = DMA_CMD_BASE;
//	uint32_t 	null_dma_da  = 0xffff0000;	//no use, write to h264 core directly
	//--- h264 working mode config
	//struct	  h264_cfg_t  enc_cfg;
//	uint32_t 	  rdata;
//	uint32_t       room_ofset[2];
//	uint32_t 		  bs_size;
//	uint32_t 		  w_size = 0;
//	uint8_t			  frame_end;
//	uint32_t 		  temp;
//	uint32_t 		  w_dat = 0;

	struct h264_device *h264_dev;
	h264_dev = (struct h264_device *)dev_get(HG_H264_DEVID);	

	_os_printf("%s  %d  drv2_w:%d\r\n",__func__,__LINE__,drv2_w);
	
	if(drv2_w != 0){
		h264_dev_num = 2;
	}
	else{
		h264_dev_num = 1;

	
	}
	uint8_t err = h264_mem_init(1,drv1_w,drv1_h,drv2_w,drv2_h);
	if(err)
	{
		return err;
	}
	h264_room_init();
	h264_drv_init(h264_dev);
	h264_main_sensor_cfg(h264_dev,drv1_w,drv1_h,drv1_from);	
	if(h264_dev_num == 2)
		h264_second_sensor_cfg(h264_dev,drv2_w,drv2_h,drv2_from);
	
	h264_isr_init(h264_dev);
	//h264_wrap_init
	penc_ctl = &enc_ctl;
	penc_cfg = &enc_cfg;
	prc_ctl  = &rc_ctl;
	
	penc_cfg->timeLapse_en = 0;
	penc_ctl->bs_buf_id = 0;
	#if 0
	if(penc_cfg->frm_height == 1088){
		h264_set_wrap_img_size(h264_dev,penc_cfg->frm_width,(penc_cfg->frm_height-8));
	}else{
		h264_set_wrap_img_size(h264_dev,penc_cfg->frm_width,penc_cfg->frm_height);
	}
	#else
		h264_set_wrap_img_size(h264_dev,penc_cfg->wrap_width,penc_cfg->wrap_height);
	#endif


	h264_cfg_srcdat(h264_dev,penc_cfg->src_from);
	
	//p_h264->WRAP_CON |= 0x01|0x10|0x100;
	h264_set_vpp_vsync_delay(h264_dev,1);
	h264_set_hw_open(h264_dev,1);
	//h264_open(h264_dev);
	h264_start_enc_frm(h264_dev,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
#if 0	
	h264_open(h264_dev);
	os_sleep_ms(10000);
	h264_close(h264_dev);
	os_sleep_ms(10000);
	h264_open(h264_dev);
	os_sleep_ms(10000);
#endif	
	return 0;
}




//缩时录影外部调用kick接口(不能随时调用,需要结合模式去调用)
//没有考虑临界,比如外部要注意不要close又继续重新kick
int32_t h264_extern_kick()
{
	if(penc_cfg->timeLapse_en && penc_cfg->timeLapse_ready_kick)
	{
		//去启动kick
		struct h264_device *h264_dev;
		h264_dev = (struct h264_device *)dev_get(HG_H264_DEVID);
		extern void h264_cfg_srcdat(struct h264_device *p_h264,uint8_t mode);	
		h264_cfg_srcdat(h264_dev,penc_cfg->src_from);
		penc_cfg->timeLapse_ready_kick = 0;
		h264_start_enc_frm(h264_dev,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
		return 0;
	}
	return 1;
}


static int32 h264_timeLapse(struct os_work *work)
{
	struct timeLapse_work_t *timeLapse_wk = (struct timeLapse_work_t *)work;
	//如果计算时间大于0,代表还没有到kick的时间
	//如果小于0,则已经错过了,立刻去kick
	int32_t err_time = timeLapse_wk->last_kick_time - os_jiffies();
	if(err_time > 0 )
	{
		os_run_work_delay(&timeLapse_wk->wk,err_time);
	}
	else
	{
		h264_extern_kick();
	}
	
	return 0;
}
//h264,并且启动缩时录影功能,主要与原来模式不能共存,timer是定时的时间
int h264_enc_with_timeLapse(uint32_t drv1_from,uint32_t drv1_w,uint32_t drv1_h,uint32_t timer)
{
	struct h264_device *h264_dev;
	h264_dev = (struct h264_device *)dev_get(HG_H264_DEVID);	
	h264_dev_num = 1;
	uint8_t err = 0;
	//创建workqueue
	timeLapse_wk = (struct timeLapse_work_t *)H264_LIB_MALLOC(sizeof(struct timeLapse_work_t));
	if(!timeLapse_wk)
	{
		err = -1;
		goto h264_enc_with_timeLapse_end;
	}
	timeLapse_wk->timer = timer;
	err = h264_mem_init(1,drv1_w,drv1_h,0,0);
	if(err)
	{
		goto h264_enc_with_timeLapse_end;
	}
	timeLapse_wk->last_kick_time = os_jiffies();
	OS_WORK_INIT(&timeLapse_wk->wk, h264_timeLapse, 0);


	h264_room_init();
	h264_drv_init(h264_dev);
	h264_main_sensor_cfg(h264_dev,drv1_w,drv1_h,drv1_from);	
	h264_isr_init(h264_dev);
	//h264_wrap_init
	penc_ctl = &enc_ctl;
	penc_cfg = &enc_cfg;
	prc_ctl  = &rc_ctl;
	penc_ctl->bs_buf_id = 0;
	//启动缩时录影的模式
	penc_cfg->timeLapse_en = 1;
	h264_set_wrap_img_size(h264_dev,penc_cfg->wrap_width,penc_cfg->wrap_height);
	h264_cfg_srcdat(h264_dev,penc_cfg->src_from);
	h264_set_vpp_vsync_delay(h264_dev,1);
	h264_set_hw_open(h264_dev,1);
	h264_start_enc_frm(h264_dev,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
h264_enc_with_timeLapse_end:
	if(err && timeLapse_wk)
	{
		H264_LIB_FREE(timeLapse_wk);
		timeLapse_wk = NULL;
	}
	return err;
}



void h264_dec_intr_status(struct h264_device *p_h264,struct h264_ctl_t *dec_ctl) {
    uint32_t   rdata 	;
    uint32_t		hw_byte	;

	//decoder used bitstream length check
	hw_byte = h264_get_frame_len(p_h264);
	hw_byte += h264_get_dec_del(p_h264);
	if((hw_byte < (dec_ctl->bs_byte_limit - 0x10)) || (hw_byte > dec_ctl->bs_byte_limit)) {
		_os_printf("decoder stream length error.:%d  %d\n\r",hw_byte,dec_ctl->bs_byte_limit);
	}		

	rdata = h264_get_sta(p_h264);

	dec_ctl->enc_end_flags= rdata;
}

void h264_dec_clr_enc_funcs(struct h264_device *p_h264) {
  h264_set_enc_frame_rdcost(p_h264);
}


void h264_dec_refbuf_set(struct h264_device *p_h264,uint32_t      buf_base, struct h264_cfg_t *dec_cfg, struct h264_ctl_t *dec_ctl) {
  uint32_t   max_luma_size;
  max_luma_size = dec_cfg->frm_width * dec_cfg->frm_height;
  
  
  dec_ctl->ref_lu_base= buf_base;   //must be 4KB aligned
  dec_ctl->ref_lu_end = ((buf_base + max_luma_size + (48*dec_cfg->frm_width) + 4095) >> 12) << 12;  //4KB align
  dec_ctl->ref_ch_base= dec_ctl->ref_lu_end;
  dec_ctl->ref_ch_end = ((dec_ctl->ref_ch_base + (max_luma_size>>1) + (24*dec_cfg->frm_width) + 4095) >> 12) << 12;  //4KB align
  dec_ctl->last_lpf_lu_base = dec_ctl->ref_lu_base;
  dec_ctl->last_lpf_ch_base = dec_ctl->ref_ch_base;
  //p_h264->REF_LU_ST_ADDR   = dec_ctl->ref_lu_base >> 12;
  //p_h264->REF_LU_ED_ADDR   = dec_ctl->ref_lu_end  >> 12;
  //p_h264->REF_CHRO_ST_ADDR = dec_ctl->ref_ch_base >> 12;
  //p_h264->REF_CHRO_ED_ADDR = dec_ctl->ref_ch_end  >> 12; 

//  h264_set_ref_lu_addr(p_h264,dec_ctl->ref_lu_base,dec_ctl->ref_lu_end);
//  h264_set_ref_chro_addr(p_h264,dec_ctl->ref_ch_base,dec_ctl->ref_ch_end);

  
}

void h264_dec_src_room_set(struct h264_device *p_h264,uint32_t       buf_base, struct h264_cfg_t *dec_cfg,struct h264_ctl_t *dec_ctl){
	uint32_t   max_luma_size;
	max_luma_size = dec_cfg->frm_width * dec_cfg->frm_height;

	dec_ctl->ref_lu_base= buf_base;   //must be 4KB aligned
	dec_ctl->ref_lu_end = ((buf_base + max_luma_size + (48*dec_cfg->frm_width) + 4095) >> 12) << 12;  //4KB align
	dec_ctl->ref_ch_base= dec_ctl->ref_lu_end;
	dec_ctl->ref_ch_end = ((dec_ctl->ref_ch_base + (max_luma_size>>1) + (24*dec_cfg->frm_width) + 4095) >> 12) << 12;  //4KB align
//	_os_printf("[%08x]h264_lu:%08x-%08x  ch:%08x-%08x\r\n",dec_cfg,dec_ctl->ref_lu_base,dec_ctl->ref_lu_end,dec_ctl->ref_ch_base,dec_ctl->ref_ch_end);
	h264_set_ref_lu_addr(p_h264,dec_ctl->ref_lu_base,dec_ctl->ref_lu_end);
	h264_set_ref_chro_addr(p_h264,dec_ctl->ref_ch_base,dec_ctl->ref_ch_end);
}

void h264_dec_a_frame(struct h264_device *p_h264,uint32_t nal_length, struct h264_ctl_t *dec_ctl, struct h264_header *head, struct str_info *str,uint32 dataroom) {
      uint32_t wdata;
      uint32_t base_tmp;
	  uint32_t base_tmp2;
  
      wdata = dec_ctl->frm_type | (0 << 4);
	  //p_h264->CON  = wdata;
	  h264_set_frame_base_cfg(p_h264,dec_ctl->frm_type,0,0,0);
      
	  //p_h264->IMG_WIDTH  = dec_ctl->frm_width;
	  //p_h264->IMG_HEIGH  = dec_ctl->frm_height;
	  h264_set_phy_img_size(p_h264,dec_ctl->frm_width,dec_ctl->frm_height);
	  
	  //p_h264->FRM_QP     = head->pic_qp;
	  h264_set_frame_qp(p_h264,head->pic_qp);

	  
      //ref read base
//	  p_h264->REF_LU_RB_ADDR    = dec_ctl->last_lpf_lu_base >> 12;
//	  p_h264->REF_CHRO_RB_ADDR  = dec_ctl->last_lpf_ch_base >> 12;
	  h264_set_ref_rb_addr(p_h264,dec_ctl->last_lpf_lu_base,dec_ctl->last_lpf_ch_base);
      //lpf write base
      //lpf luma base
      base_tmp = h264_cal_ref_base(dec_ctl->ref_lu_base, dec_ctl->ref_lu_end, dec_ctl->last_lpf_lu_base, dec_ctl->frm_luma_size);
      //Xil_Out32((H264_REG_BASE + 84*4), base_tmp >> 12);
      //p_h264->REF_LU_WB_ADDR    = base_tmp >> 12;
      dec_ctl->last_lpf_lu_base = base_tmp;
      
      //lpf chroma base
      base_tmp2 = h264_cal_ref_base(dec_ctl->ref_ch_base, dec_ctl->ref_ch_end, dec_ctl->last_lpf_ch_base, (dec_ctl->frm_luma_size >> 1));
      //Xil_Out32((H264_REG_BASE + 85*4), base_tmp >> 12);
      //p_h264->REF_CHRO_WB_ADDR   = base_tmp2 >> 12;
      dec_ctl->last_lpf_ch_base = base_tmp2;

	  h264_set_ref_wb_addr(p_h264,base_tmp,base_tmp2);

//      p_h264->LEN_LIMIT   = (nal_length+4);
	  h264_set_len_limit(p_h264,nal_length+4);
      dec_ctl->bs_byte_limit = nal_length+4;
	  
      //p_h264->DMA_BS_ADDR0 = ((uint32_t)&frame_cache>>10);    
	  h264_set_buf_addr(p_h264,dataroom);
	  //p_h264->FRM_MB_NUM = (dec_ctl->frm_luma_size >> 8);
	  h264_set_frame_mb_num(p_h264,dec_ctl->frm_luma_size);
      //p_h264->DEC_HEADB_NUM = str->used_bits;
	  h264_set_dec_headb_num(p_h264,str->used_bits);
}

struct	str_info	h264_str[3]; 
struct	h264_header h264_head[3];
struct	h264_cfg_t	dec_cfg[3];  
struct	h264_ctl_t	dec_ctl[3];

//__psram_data uint8_t h264_1_room[100*1024] __aligned(4096);
uint8_t *h264_1_room;

void h264_dec_room_init(uint8_t devnum,uint16_t drv2_w,uint16_t drv2_h){
	uint8_t i = 0;
	for(i = 0;i < devnum;i++){
		h264_ref_memory_base[i] = H264_MALLOC((drv2_w*(drv2_h+48))+(drv2_w*(drv2_h+48))/2 + 3*4096);
		h264_ref_memory_base[i] = (uint8_t*)(((uint32_t)h264_ref_memory_base[i] + 0xfff) & (~0xfff)); 
		//h264_ref_memory_base[i] = 0X40000000;
	}
}

void get_h264_stream_w_h(uint16_t* w,uint16_t* h,uint8_t *h264data){
	struct	str_info	h264_str; 
	struct	h264_header h264_head;

	h264_str.ptr = (uint8_t *)h264data;
	nal_parse(&h264_str, &h264_head);	
	*w = h264_head.sps_pic_width;
	*h = h264_head.sps_pic_height;
	return;
}

extern uint8_t h264_dec_sps_src_param(uint32 w, uint32 h, uint8_t *buf);
void h264_dec_src_264(uint8 *src_file,uint32 file_size,uint32 w,uint32 h,uint32_t devid){
	//--- platform initial 
#if VIDEO_YUV_RANGE_TYPE
	uint8_t spsbuf[20];
	uint8_t spslen;
#endif
	uint8_t onlysps = 0;
	int32 ret;
	uint8_t *psram_room;
	uint8_t* 	mbs_ptr; //main bs ptr
	
	struct h264_device *p_h264;
	p_h264 = (struct h264_device *)dev_get(HG_H264_DEVID);

	//file_size = file_size-4;
	//_os_printf("fs(%d)",file_size);
    mbs_ptr = src_file;   //文件地址	
	//decoder reference frame addr setting

	dec_cfg[devid].enc_mode  = 0;	  //0:dec, 1:enc  
	dec_cfg[devid].frm_width = w; //maximal support x-pixel
	dec_cfg[devid].frm_height= h;  //maximal support y-pixel

	if(src_file[4] == 0x67){
		if(file_size > 50){      //单sps不可能大于50字节的,此时肯定是带上sps+pps+I帧的数据帧
			onlysps = 0;
		}else{
			onlysps = 1;
		}
	}
	psram_room = (uint8_t*)H264_MALLOC(file_size + 4096);
	h264_1_room = (uint8_t*)(((uint32_t)psram_room + 0xfff) & (~0xfff)); 
	h264_request_irq(p_h264,H264_FRAME_DONE,(h264_irq_hdl )&h264_frame_dec_done_isr,(uint32)p_h264);
	while(1){
		
	    uint8_t      nal_type  ;
	    uint32_t     nal_start   ; //nal bitstream start addr
	    uint32_t     nal_length  ; //nal byte length
	    
		
		if(onlysps == 0){
			if((mbs_ptr[4] == 0x67) ||(mbs_ptr[4] == 0x68)){                   //SPS
				mbs_ptr   = find_start_code(mbs_ptr); //find first 0x0000_0001	  
				nal_start = (uint32_t) mbs_ptr - 4; 	   //return the 4byte "00000001"
				mbs_ptr   = find_start_code(mbs_ptr); //find second 0x0000_0001
				mbs_ptr   -= 4;
				nal_length = (uint32_t) mbs_ptr - nal_start;
				//file_size = file_size-nal_length;
			}else{
				mbs_ptr   = find_start_code(mbs_ptr); 
				nal_start = (uint32_t) mbs_ptr - 4;
				nal_length = file_size;
				
			}
		}else{
			nal_start   = (uint32_t)src_file;
			nal_length	= file_size;
		}
		
//		if((mbs_ptr - src_file) > file_size-30000){
//			break;
//		}
		
	    //--- copy bitstream to BS buffer for decode
	    //_os_printf("%08x  %08x  %d\r\n",h264_1_room,nal_start,nal_length);
		hw_memcpy((void*) h264_1_room,(const void*) nal_start,nal_length);
		sys_dcache_clean_range((uint32_t*)h264_1_room,nal_length);
#if VIDEO_YUV_RANGE_TYPE		
		if(h264_1_room[4] == 0x67){
			spslen = h264_dec_sps_src_param( w, h,(uint8_t*)spsbuf);
			memcpy((void*) h264_1_room,(const void*)spsbuf,spslen);
		}
#endif	
	
		h264_str[devid].ptr = (uint8_t *)h264_1_room;
		
	    //decoder nal header
	    nal_type = nal_parse(&h264_str[devid], &h264_head[devid]);
	    
	    if(nal_type == sps) {
	      //frame size check      
	      if((h264_head[devid].sps_pic_width > dec_cfg[devid].frm_width) || (h264_head[devid].sps_pic_height > dec_cfg[devid].frm_height)) {
	        _os_printf("frame x/y pixel size is too big.(%d  %d  === > %d  %d)\n\r",h264_head[devid].sps_pic_width,h264_head[devid].sps_pic_height,dec_cfg[devid].frm_width,dec_cfg[devid].frm_height);
	        return ;
	      }
	      
	      dec_ctl[devid].frm_width = h264_head[devid].sps_pic_width;   //should be 16*N
	      dec_ctl[devid].frm_height= h264_head[devid].sps_pic_height;  //should be 16*N
	      dec_ctl[devid].frm_luma_size   = dec_ctl[devid].frm_width * dec_ctl[devid].frm_height;
	          
	      dec_ctl[devid].timeout_limit   = (dec_ctl[devid].frm_luma_size >> 8) * 512 * 2;     

		  
		  //_os_printf("h264_ref:%08x\r\n",h264_ref_memory_base[devid]);
		  h264_dec_refbuf_set(p_h264,((uint32_t)h264_ref_memory_base[devid] + 0xfff) & (~0xfff), (struct h264_cfg_t *)&dec_cfg[devid], (struct h264_ctl_t *)&dec_ctl[devid]);
		  
		  h264_dec_clr_enc_funcs(p_h264);
		  h264_set_mb_pipe(p_h264,((502-2) << 16) | 502);

		  h264_set_timeout_limit(p_h264,(dec_ctl[devid].timeout_limit) >> 10);
	    } else if(nal_type == pps) {
	    
	    } else if(nal_type == pic_idr) {
	      
	    }     

		h264_dec_src_room_set(p_h264,((uint32_t)h264_ref_memory_base[devid] + 0xfff) & (~0xfff), (struct h264_cfg_t *)&dec_cfg[devid], (struct h264_ctl_t *)&dec_ctl[devid]);
		
	    //there is a frame need decode
	    if((nal_type == pic_idr) || (nal_type == pic_data)) {
	      //decode a picture
	      if(nal_type == pic_idr)
	        dec_ctl[devid].frm_type = 2;
	      else
	        dec_ctl[devid].frm_type = 0;
	  
	      h264_dec_a_frame(p_h264,nal_length, &dec_ctl[devid], &h264_head[devid], &h264_str[devid],(uint32_t)h264_1_room);
		  h264_decode_start(p_h264);

		  ret = h264_sema_down(100);
	      h264_dec_intr_status(p_h264,&dec_ctl[devid]);
	      //-- clear the frm end flag
	      h264_clr_intr(p_h264);
	      h264_dec_flag_chk(dec_ctl[devid].enc_end_flags);	

		}
		file_size -= nal_length;
		
		if(file_size == 0)   //sps+pps
		{
			H264_FREE(psram_room); 
			return;
		}
			
	}
}

void h264_dec_nal_264(uint8 *src_file,uint32 file_size,uint32 w,uint32 h,uint32_t devid){
	struct h264_device *p_h264;
	p_h264 = (struct h264_device *)dev_get(HG_H264_DEVID);
	
	dec_cfg[devid].enc_mode  = 0;	  //0:dec, 1:enc  
	dec_cfg[devid].frm_width = w; //maximal support x-pixel
	dec_cfg[devid].frm_height= h;  //maximal support y-pixel
}

void h264_frame_gen420_kick_run(struct h264_device *p_h264,uint32 addr,uint16_t w,uint16_t h){
	if(recfg_h264_new_grop[0] == 1){
		recfg_h264_new_grop[0] = 0;
		penc_ctl->gop_frm_cnt = 0;
	}
	//os_printf("w:%d   h:%d\r\n",w,h);
	penc_cfg->wrap_width  = w;
	penc_cfg->wrap_height = h;
	penc_cfg->frm_width	  = (w+0xf)&(~0xf);
	penc_cfg->frm_height  = (h+0xf)&(~0xf);	
	h264_init(p_h264,H264_HARDWARE_CLK);
	
	if(penc_ctl->gop_frm_cnt == 0){
		if(h264_cfg_modify((struct h264_cfg_t *)penc_cfg,1)){
			h264_ini_recfg((struct h264_cfg_t *)penc_cfg,(struct h264_ctl_t *)penc_ctl,(struct h264_rc_ctl_t *)prc_ctl);
			h264_ini_seting_cfg(p_h264,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl,1);
		}
	}

	h264_request_irq(p_h264,H264_FRAME_DONE,  (h264_irq_hdl )&h264_frame_done_norekick_isr,(uint32)p_h264);
	h264_request_irq(p_h264,H264_BUF0_FULL ,  (h264_irq_hdl )&h264_buf0_done_isr,(uint32)p_h264);		
	h264_request_irq(p_h264,H264_BUF1_FULL ,  (h264_irq_hdl )&h264_buf1_done_isr,(uint32)p_h264);	
	h264_request_irq(p_h264,H264_SOFT_SLOW ,  (h264_irq_hdl )&h264_soft_slow_isr,(uint32)p_h264);
	h264_request_irq(p_h264,H264_FRAME_FAST,  (h264_irq_hdl )&h264_frame_fast_isr,(uint32)p_h264);	
	h264_request_irq(p_h264,H264_PIXEL_FAST,  (h264_irq_hdl )&h264_pixel_fast_isr,(uint32)p_h264);
	h264_request_irq(p_h264,H264_PIXEL_DONE,  (h264_irq_hdl )&h264_pixel_done_isr,(uint32)p_h264);		
	h264_request_irq(p_h264,H264_ENC_TIME_OUT,(h264_irq_hdl )&h264_enc_timeout_isr,(uint32)p_h264);

	h264_set_oe_select(p_h264, 0, 0);
	h264_set_wrap_img_size(p_h264,penc_cfg->wrap_width,penc_cfg->wrap_height);
	h264_cfg_srcdat(p_h264,penc_cfg->src_from);
	h264_set_vpp_vsync_delay(p_h264,1);
	h264_set_hw_open(p_h264,1);
	//h264_start_enc_frm(p_h264,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
	enc_ctl.bs_buf_id = 0;	
	h264_open(p_h264);

	wake_up_gen420_queue(1,(uint8_t*)addr);
	

}

struct h264_hardware_s
{
    struct msi *msi;
    struct h264_device *h264_dev;
    os_msgqueue_t msgq;
    struct os_event evt;
    struct os_task task;
};

//一个回调函数,私有结构,以及一些固定参数
struct h264_msg_s
{
	struct list_head list;		  //h264 queue hand	
    void *fn_data;                //函数的私有结构
	uint8_t type;                 //0: h264 enc  1:h264 dec   
    uint32_t data;
	uint32_t len;
    uint16_t w;
    uint16_t h;
	uint8_t sta;			      //0:idle    1:data ready
	
};




int put_h264msg_to_queue(uint8_t type,uint32_t w,uint32_t h,uint32 data,uint32 len){
	struct h264_msg_s *wq;
	uint32_t flags;	
	wq = malloc(sizeof(struct h264_msg_s));
	wq->type   = type;
	wq->w      = w;
	wq->h      = h;
	wq->sta    = 0;
	wq->data   = data;
	wq->len    = len;
	
	flags = disable_irq();
	INIT_LIST_HEAD(&wq->list);
	list_add_tail(&wq->list,(struct list_head*)&h264_queue_head); 
	enable_irq(flags);
	
	h264wq_sema_up();
	return (int)&wq->list;
}

uint8_t h264msg_queue_done(uint32 list){
	struct list_head *dlist;
	uint32_t flags;	
	flags = disable_irq();
	dlist = (struct list_head *)&h264_queue_head;
	while(dlist->next != &h264_queue_head){
		if(dlist->next == (struct list_head *)list){
			enable_irq(flags);
			return 0;
		}
		dlist = dlist->next;
	}
	enable_irq(flags);
	return 1;
}


extern int scale2_cfg_run(uint8_t streamfrom,uint8_t id);
extern volatile uint8_t scaler2_dev_id;
void h264_wq_thread(){
	int32 ret;
	uint32_t flags;
	struct list_head *dlist;
	struct h264_msg_s* h264dev;	
	struct h264_device *p_h264;

	p_h264 = (struct h264_device *)dev_get(HG_H264_DEVID);	
	while(1){
		h264wq_sema_down(-1);
		flags = disable_irq();
		if(list_empty((struct list_head *)&h264_queue_head) != TRUE){
			enable_irq(flags);
			do{
				flags = disable_irq();
				dlist = (struct list_head *)&h264_queue_head;
				dlist = dlist->next;
				if(dlist == &h264_queue_head){
					enable_irq(flags);
					break;
					//return -1;
				}else{
					h264dev = list_entry((struct list_head *)dlist,struct h264_msg_s,list);
					enable_irq(flags);
					if(h264dev->type == 0){				//h264 enc
						h264_frame_gen420_kick_run(p_h264,h264dev->data,h264dev->w,h264dev->h);
						ret = h264_sema_down(100);
						if(ret == 0){
							os_printf("enc error..\r\n");
						}
					}else{	
						//_os_printf("%s	%d\r\n",__func__,__LINE__);
						int32 ret = scale2_cfg_run(H264_DEC,scaler2_dev_id);
						if(ret == 0) {
						h264_dec_src_264((uint8_t*)h264dev->data,h264dev->len,h264dev->w,16*((h264dev->h + 15)/16) ,0);
						}
						
						//scale2_cfg_run(MJPEG_DEC,scaler2_dev_id);
						//void jpg_decode_run(uint32_t addr);						
						//jpg_decode_run(h264_1_room);
						
					}
					flags = disable_irq();
					list_del(&h264dev->list);
					enable_irq(flags);
					free(h264dev);
				}
			}while(1);
		}else{
			enable_irq(flags);
		}
	
	}
}

extern struct msi *h264_msi_init_with_mode_for_264wq(uint32_t drv1_from, uint16_t drv1_w, uint16_t drv1_h);
void h264wq_queue_init(uint16_t w,uint16_t h){
	//h264_drv_init();
	h264wq_sema_init();
	INIT_LIST_HEAD((struct list_head *)&h264_queue_head);
	h264_msi_init_with_mode_for_264wq(GEN420_DATA,w,h);
	h264_dec_room_init(1,w,16*((h+15)/16));
	os_task_create("h264_thread", h264_wq_thread, NULL, OS_TASK_PRIORITY_HIGH, 0, NULL, 1024);
}





//gen420编码的接口
int32_t h264_gen420_kick()
{
	struct h264_device *h264_dev;
	h264_dev = (struct h264_device *)dev_get(HG_H264_DEVID);
	extern void h264_cfg_srcdat(struct h264_device *p_h264,uint8_t mode);	
	h264_cfg_srcdat(h264_dev,GEN420_DATA);
	h264_start_enc_frm(h264_dev,(struct h264_cfg_t *)penc_cfg, (struct h264_ctl_t *)penc_ctl, (struct h264_rc_ctl_t *)prc_ctl);
	return 0;
}




//解码封装的接口
void sps_setting(struct str_info *str, struct h264_header *head, uint32_t w, uint32_t h)
{
    uint8_t spsbuf[20];
    uint8_t spslen;
    spslen   = h264_dec_sps_src_param(w, h, spsbuf);
    str->ptr = spsbuf;
    nal_parse(str, head);
}

void pps_setting(struct str_info *str, struct h264_header *head, uint8_t *pps, uint8_t len)
{
    uint8_t ppsbuf[20];
    ppsbuf[0] = 0x00;
    ppsbuf[1] = 0x00;
    ppsbuf[2] = 0x00;
    ppsbuf[3] = 0x01;
    memcpy((void *) ppsbuf + 4, (const void *) pps, len);
    str->ptr = ppsbuf;
    nal_parse(str, head);
}

void cfg_setting(struct h264_device *p_h264, struct h264_header *head, struct h264_cfg_t *cfg, struct h264_ctl_t *ctl)
{
    if ((head->sps_pic_width > cfg->frm_width) || (head->sps_pic_height > cfg->frm_height))
    {
        _os_printf("frame x/y pixel size is too big.(%d  %d  === > %d  %d)\n\r", head->sps_pic_width, head->sps_pic_height, cfg->frm_width, cfg->frm_height);
    }
    ctl->frm_width     = head->sps_pic_width;  // should be 16*N
    ctl->frm_height    = head->sps_pic_height; // should be 16*N
    ctl->frm_luma_size = ctl->frm_width * ctl->frm_height;

    ctl->timeout_limit = (ctl->frm_luma_size >> 8) * 512 * 2;
    h264_dec_clr_enc_funcs(p_h264);
    h264_set_mb_pipe(p_h264, ((502 - 2) << 16) | 502);

    h264_set_timeout_limit(p_h264, (ctl->timeout_limit) >> 10);
}

void h264_decode_I_P_setting(struct str_info *str, struct h264_header *head, uint8_t *rom_ptr)
{
    str->ptr = rom_ptr;
    nal_parse(str, head);
}

void h264_rom_memcpy(uint8_t *rom_ptr, uint8_t *data, uint32_t len)
{
    rom_ptr[0] = 0x00;
    rom_ptr[1] = 0x00;
    rom_ptr[2] = 0x00;
    rom_ptr[3] = 0x01;
    hw_memcpy((void *) rom_ptr + 4, (const void *) data, len);
    sys_dcache_clean_range((uint32_t *) rom_ptr, len + 4);
}