#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include "hdal.h"
#include "hd_debug.h"
#include <kwrap/examsys.h>
#include "math.h"
#include "vendor_md.h"
#include "libmd.h"
#include <kwrap/perf.h>

#if defined(__LINUX)
#include <pthread.h>			//for pthread API
#define MAIN(argc, argv) 		int main(int argc, char** argv)
#else
#include <FreeRTOS_POSIX.h>
#include <FreeRTOS_POSIX/pthread.h> //for pthread API
#include <kwrap/task.h>
#include <kwrap/util.h>		//for sleep API
#define sleep(x)    vos_task_delay_ms(1000*x)
#define msleep(x)   vos_task_delay_ms(x)
#define usleep(x)   vos_task_delay_us(x)
#define MAIN(argc, argv) 		EXAMFUNC_ENTRY(alg_md_sample, argc, argv)
#endif

//#define IMG_WIDTH         640//160
//#define IMG_HEIGHT        480//120
//#define IMG_BUF_SIZE      (IMG_WIDTH * IMG_HEIGHT)
#define MDBC_ALIGN(a, b) (((a) + ((b) - 1)) / (b) * (b))
#define OUTPUT_BMP 		0
#define DEBUG_FILE		0
#define SHARE_MEM_NUM	8
#define SUBREGION_NUM   2
#define CROSSREGION_NUM 2
UINT32 IMG_WIDTH;
UINT32 IMG_HEIGHT;
UINT32 IMG_BUF_SIZE;

typedef struct _MEM_RANGE {
	UINT32               va;        ///< Memory buffer starting address
	UINT32               addr;      ///< Memory buffer starting address
	UINT32               size;      ///< Memory buffer size
	HD_COMMON_MEM_VB_BLK blk;
} MEM_RANGE, *PMEM_RANGE;

typedef enum {
	LOW_SENSI         = 0,
	MED_SENSI         = 1,
	HIGH_SENSI        = 2,
	ENUM_DUMMY4WORD(MDBC_PARA_SENSI)
} MDBC_PARA_SENSI;

#pragma pack(2)
struct BmpFileHeader {
    UINT16 bfType;
    UINT32 bfSize;
    UINT16 bfReserved1;
    UINT16 bfReserved2;
    UINT32 bfOffBits;
};
struct BmpInfoHeader {
    UINT32 biSize;
    UINT32 biWidth;
    UINT32 biHeight;
    UINT16 biPlanes; // 1=defeaul, 0=custom
    UINT16 biBitCount;
    UINT32 biCompression;
    UINT32 biSizeImage;
    UINT32 biXPelsPerMeter; // 72dpi=2835, 96dpi=3780
    UINT32 biYPelsPerMeter; // 120dpi=4724, 300dpi=11811
    UINT32 biClrUsed;
    UINT32 biClrImportant;
};
#pragma pack()

static UINT32 g_sensi = HIGH_SENSI;

static INT32 share_memory_init(MEM_RANGE *p_share_mem)
{
	HD_COMMON_MEM_VB_BLK blk;
	UINT8 i;
	UINT32 pa, va;
	UINT32 blk_size = IMG_BUF_SIZE;
	HD_COMMON_MEM_DDR_ID ddr_id = DDR_ID0;
	HD_RESULT ret = HD_OK;

	for(i=0;i<SHARE_MEM_NUM;i++){
		p_share_mem[i].addr = 0x00;
		p_share_mem[i].va   = 0x00;
		p_share_mem[i].size = 0x00;
		p_share_mem[i].blk  = HD_COMMON_MEM_VB_INVALID_BLK;
	}
	for(i=0;i<SHARE_MEM_NUM;i++){
		if(i==0)blk_size = IMG_BUF_SIZE;
		else if(i==1 || i==2)blk_size = IMG_BUF_SIZE/2;
		else if(i==3)blk_size = IMG_BUF_SIZE*40;
		else if(i==4)blk_size = IMG_BUF_SIZE*13/2;
		else if(i==5)blk_size = ((IMG_BUF_SIZE+15)/16)*16*12;
		else if(i==6)blk_size = ((IMG_BUF_SIZE+7)/8);
		else if(i==7)blk_size = IMG_BUF_SIZE; // result transform
		blk = hd_common_mem_get_block(HD_COMMON_MEM_GLOBAL_MD_POOL, blk_size, ddr_id);
		if (blk == HD_COMMON_MEM_VB_INVALID_BLK) {
			printf("err:get block fail\r\n", blk);
			ret =  HD_ERR_NG;
			return ret;
		}
		pa = hd_common_mem_blk2pa(blk);
		if (pa == 0) {
			printf("err:blk2pa fail, blk = 0x%x\r\n", blk);
			goto blk2pa_err;
		}
		//printf("pa = 0x%x\r\n", pa);
		if (pa > 0) {
			va = (UINT32)hd_common_mem_mmap(HD_COMMON_MEM_MEM_TYPE_CACHE, pa, blk_size);
			if (va == 0) {
				goto map_err;
			}
		}
		p_share_mem[i].addr = pa;
		p_share_mem[i].va   = va;
		p_share_mem[i].size = blk_size;
		p_share_mem[i].blk  = blk;
		printf("share_mem[%d] pa = 0x%x, va=0x%x, size =0x%x\r\n",i, p_share_mem[i].addr, p_share_mem[i].va, p_share_mem[i].size);
	}
	return ret;
blk2pa_err:
map_err:
	for (; i > 0 ;) {
		i -= 1;
		ret = hd_common_mem_release_block(p_share_mem[i].blk);
		if (HD_OK != ret) {
			printf("err:release blk fail %d\r\n", ret);
			ret =  HD_ERR_NG;
			return ret;
		}
	}
	return ret;
}

static INT32 share_memory_exit(MEM_RANGE *p_share_mem)
{
	UINT8 i;
	HD_RESULT ret = HD_OK;
	for(i=0;i<SHARE_MEM_NUM;i++){
		if (p_share_mem[i].va != 0) {
			hd_common_mem_munmap((void *)p_share_mem[i].va, p_share_mem[i].size);
		}
		if (p_share_mem[i].blk != HD_COMMON_MEM_VB_INVALID_BLK) {
			ret = hd_common_mem_release_block(p_share_mem[i].blk);
			if (HD_OK != ret) {
				printf("err:release blk fail %d\r\n", ret);
				ret =  HD_ERR_NG;
				return ret;
			}
		}
		p_share_mem[i].addr = 0x00;
		p_share_mem[i].va   = 0x00;
		p_share_mem[i].size = 0x00;
		p_share_mem[i].blk  = HD_COMMON_MEM_VB_INVALID_BLK;
	}
	return HD_OK;
}

static HD_RESULT mem_init(void)
{
	HD_RESULT ret;
	HD_COMMON_MEM_INIT_CONFIG mem_cfg = {0};

	mem_cfg.pool_info[0].type = HD_COMMON_MEM_GLOBAL_MD_POOL;
	mem_cfg.pool_info[0].blk_size = IMG_BUF_SIZE;
	mem_cfg.pool_info[0].blk_cnt = 2;
	mem_cfg.pool_info[0].ddr_id = DDR_ID0;

	mem_cfg.pool_info[1].type = HD_COMMON_MEM_GLOBAL_MD_POOL;
	mem_cfg.pool_info[1].blk_size = IMG_BUF_SIZE/2;
	mem_cfg.pool_info[1].blk_cnt = 2;
	mem_cfg.pool_info[1].ddr_id = DDR_ID0;

	mem_cfg.pool_info[2].type = HD_COMMON_MEM_GLOBAL_MD_POOL;
	mem_cfg.pool_info[2].blk_size = IMG_BUF_SIZE*40;
	mem_cfg.pool_info[2].blk_cnt = 1;
	mem_cfg.pool_info[2].ddr_id = DDR_ID0;

	mem_cfg.pool_info[3].type = HD_COMMON_MEM_GLOBAL_MD_POOL;
	mem_cfg.pool_info[3].blk_size = IMG_BUF_SIZE*13/2;
	mem_cfg.pool_info[3].blk_cnt = 1;
	mem_cfg.pool_info[3].ddr_id = DDR_ID0;

	mem_cfg.pool_info[4].type = HD_COMMON_MEM_GLOBAL_MD_POOL;
	mem_cfg.pool_info[4].blk_size = ((IMG_BUF_SIZE+15)/16)*16*12;
	mem_cfg.pool_info[4].blk_cnt = 1;
	mem_cfg.pool_info[4].ddr_id = DDR_ID0;

	mem_cfg.pool_info[5].type = HD_COMMON_MEM_GLOBAL_MD_POOL;
	mem_cfg.pool_info[5].blk_size = ((IMG_BUF_SIZE+7)/8);
	mem_cfg.pool_info[5].blk_cnt = 1;
	mem_cfg.pool_info[5].ddr_id = DDR_ID0;

	ret = hd_common_mem_init(&mem_cfg);
	if (HD_OK != ret) {
		printf("err:hd_common_mem_init err: %d\r\n", ret);
	}
	return ret;
}

static HD_RESULT mem_exit(void)
{
	HD_RESULT ret = HD_OK;
	hd_common_mem_uninit();
	return ret;
}

static void bc_reorgS1(UINT8* inputS, UINT8* outputS,UINT32 width, UINT32 height)
{
	UINT32 i,j,count,size;
	count=0;
	size = width*height;
	for(j = 0; j < MDBC_ALIGN(size,8)/8; j++) {
		UINT8 c = inputS[j];
        for(i = 0; i < 8; i++) {
			if(count<size)
			{
				outputS[count] = c & 0x1;
				c = c>>1;
				count++;
			}
        }
    }
}
#if OUTPUT_BMP
static void bc_writebmpfile(char* name, UINT8* raw_img,
    int width, int height, UINT16 bits)
{
    if(!(name && raw_img)) {
        printf("Error bmpWrite.");
        return;
    }
	int i,j;//,length;
    // FileHeader
    struct BmpFileHeader file_h = {
        .bfType=0x4d42,
        .bfSize=0,
        .bfReserved1=0,
        .bfReserved2=0,
        .bfOffBits=54,
    };
    file_h.bfSize = file_h.bfOffBits + width*height * bits/8;
    if(bits==8) {file_h.bfSize += 1024, file_h.bfOffBits += 1024;}
    // BmpInfoHeader
    struct BmpInfoHeader info_h = {
        .biSize=40,
        .biWidth=0,
        .biHeight=0,
        .biPlanes=1,
        .biBitCount=0,
        .biCompression=0,
        .biSizeImage=0,
        .biXPelsPerMeter=0,
        .biYPelsPerMeter=0,
        .biClrUsed=0,
        .biClrImportant=0,
    };
    info_h.biWidth = width;
    info_h.biHeight = height;
    info_h.biBitCount = bits;
    info_h.biSizeImage = width*height * bits/8;
    if(bits == 8) {
        info_h.biClrUsed=256;
        info_h.biClrImportant=256;
    }
    // Write Header
	/*
	INT32 FileHandleStatus = 0;
	FST_FILE filehdl = NULL;
	filehdl = FileSys_OpenFile(name, FST_OPEN_WRITE | FST_CREATE_ALWAYS);
	if (!filehdl) {
		emu_msg(("^ROpen file fail - %s...\r\n", name));
	}
	length = sizeof(file_h);
	FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&file_h, &length, 0, NULL);
	length = sizeof(info_h);
	FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&info_h, &length, 0, NULL);
	*/
    FILE *pFile = fopen(name,"wb+");
    if(!pFile) {
        printf("Error opening file.");
        return;
    }
    fwrite((char*)&file_h, sizeof(char), sizeof(file_h), pFile);
    fwrite((char*)&info_h, sizeof(char), sizeof(info_h), pFile);

	//length = 1;
	// Write colormap
	//printf("Write colormap...\r\n");
    if(bits == 8) {
        for(i = 0; i < 256; ++i) {
            UINT8 c = i;
			//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
			//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
			//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
			//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
            fwrite((char*)&c, sizeof(char), sizeof(UINT8), pFile);
            fwrite((char*)&c, sizeof(char), sizeof(UINT8), pFile);
            fwrite((char*)&c, sizeof(char), sizeof(UINT8), pFile);
            fwrite("", sizeof(char), sizeof(UINT8), pFile);
        }
    }
    // Write raw img
	//printf("Write raw img...\r\n");
    UINT8 alig = ((width*bits/8)*3) % 4;
    for(j = height-1; j >= 0; --j) {
		//printf("j : %d\r\n",j);
        for(i = 0; i < width; ++i) {
			UINT8 c;
            if(bits == 24) {
				//c = raw_img[(j*width+i)*3 + 2];
				//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
				//c = raw_img[(j*width+i)*3 + 1];
				//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
				//c = raw_img[(j*width+i)*3 + 0];
				//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
                fwrite((char*)&raw_img[(j*width+i)*3 + 2], sizeof(char), sizeof(UINT8), pFile);
                fwrite((char*)&raw_img[(j*width+i)*3 + 1], sizeof(char), sizeof(UINT8), pFile);
                fwrite((char*)&raw_img[(j*width+i)*3 + 0], sizeof(char), sizeof(UINT8), pFile);
            } else if(bits == 8) {
				if(raw_img[j*width+i]==1){ c = 255;}
				else if(raw_img[j*width+i]==0){ c = 0;}
				else{
					printf("raw_img[j*width+i] = %d, (%d,%d)\n",raw_img[j*width+i],i,j);
					c = 0;
				}
				//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
                fwrite((char*)&c, sizeof(char), sizeof(UINT8), pFile);
            }
        }
        // 4byte align
        for(i = 0; i < alig; ++i) {
			//UINT8 c = 0;
			//FileHandleStatus = FileSys_WriteFile(filehdl, (UINT8 *)&c, &length, 0, NULL);
            fwrite("", sizeof(char), sizeof(UINT8), pFile);
        }
    }
	//FileHandleStatus = FileSys_CloseFile(filehdl);
	//if (FileHandleStatus != FST_STA_OK) {
	//	emu_msg(("^RClose file fail - %s...\r\n", name));
	//}
    fclose(pFile);
}
#endif
static UINT32 md_load_file(CHAR *p_filename, UINT32 va)
{
	FILE  *fd;
	UINT32 file_size = 0, read_size = 0;
	const UINT32 addr = va;
	//printf("addr = %08x\r\n", (int)addr);

	fd = fopen(p_filename, "rb");
	if (!fd) {
		printf("cannot read %s\r\n", p_filename);
		return 0;
	}

	fseek ( fd, 0, SEEK_END );
	file_size = ALIGN_CEIL_4( ftell(fd) );
	fseek ( fd, 0, SEEK_SET );

	read_size = fread ((void *)addr, 1, file_size, fd);
	if (read_size != file_size) {
		printf("size mismatch, real = %d, idea = %d\r\n", (int)read_size, (int)file_size);
	}
	fclose(fd);
	return read_size;
}

static void md_set_para_high_sensitivity(VENDOR_MD_PARAM *mdbc_parm)
{
	mdbc_parm->MdmatchPara.lbsp_th    = 0x0;
	mdbc_parm->MdmatchPara.d_colour   = 8;
	mdbc_parm->MdmatchPara.r_colour   = 8;
	mdbc_parm->MdmatchPara.d_lbsp     = 3;
	mdbc_parm->MdmatchPara.r_lbsp     = 5;
	mdbc_parm->MdmatchPara.model_num  = 0x8;
	mdbc_parm->MdmatchPara.t_alpha    = 0x33;
	mdbc_parm->MdmatchPara.dw_shift   = 0x4;
	mdbc_parm->MdmatchPara.dlast_alpha= 0x28;
	mdbc_parm->MdmatchPara.min_match  = 2;
	mdbc_parm->MdmatchPara.dlt_alpha  = 0xa;
	mdbc_parm->MdmatchPara.dst_alpha  = 0x28;
	mdbc_parm->MdmatchPara.uv_thres   = 8;
	mdbc_parm->MdmatchPara.s_alpha    = 100;
	mdbc_parm->MdmatchPara.dbg_lumDiff= 0x0;
	mdbc_parm->MdmatchPara.dbg_lumDiff_en = 0x0;

	mdbc_parm->MorPara.mor_th0 	  = 0x4;
	mdbc_parm->MorPara.mor_th1    = 0x0;
	mdbc_parm->MorPara.mor_th2    = 0x8;
	mdbc_parm->MorPara.mor_th3    = 0x0;
	mdbc_parm->MorPara.mor_th_dil = 0x0;
	mdbc_parm->MorPara.mor_sel0   = 0x1;
	mdbc_parm->MorPara.mor_sel1   = 0x1;
	mdbc_parm->MorPara.mor_sel2   = 0x1;
	mdbc_parm->MorPara.mor_sel3   = 0x0;

	mdbc_parm->UpdPara.minT           = 12;
	mdbc_parm->UpdPara.maxT           = 24;
	mdbc_parm->UpdPara.maxFgFrm       = 0x80;
	mdbc_parm->UpdPara.deghost_dth    = 50;
	mdbc_parm->UpdPara.deghost_sth    = 205;
	mdbc_parm->UpdPara.stable_frm     = 0x78;
	mdbc_parm->UpdPara.update_dyn     = 0x80;
	mdbc_parm->UpdPara.va_distth      = 32;
	mdbc_parm->UpdPara.t_distth       = 24;
	mdbc_parm->UpdPara.dbg_frmID      = 0x0;
	mdbc_parm->UpdPara.dbg_frmID_en   = 0x0;
	mdbc_parm->UpdPara.dbg_rnd        = 0x0;
	mdbc_parm->UpdPara.dbg_rnd_en     = 0x0;
}

static void md_set_para_medium_sensitivity(VENDOR_MD_PARAM *mdbc_parm)
{
	mdbc_parm->MdmatchPara.lbsp_th    = 0x0;
	mdbc_parm->MdmatchPara.d_colour   = 10;
	mdbc_parm->MdmatchPara.r_colour   = 16;
	mdbc_parm->MdmatchPara.d_lbsp     = 4;
	mdbc_parm->MdmatchPara.r_lbsp     = 8;
	mdbc_parm->MdmatchPara.model_num  = 0x8;
	mdbc_parm->MdmatchPara.t_alpha    = 25;
	mdbc_parm->MdmatchPara.dw_shift   = 0x4;
	mdbc_parm->MdmatchPara.dlast_alpha= 100;
	mdbc_parm->MdmatchPara.min_match  = 2;
	mdbc_parm->MdmatchPara.dlt_alpha  = 0xa;
	mdbc_parm->MdmatchPara.dst_alpha  = 0x28;
	mdbc_parm->MdmatchPara.uv_thres   = 10;
	mdbc_parm->MdmatchPara.s_alpha    = 100;
	mdbc_parm->MdmatchPara.dbg_lumDiff= 0x0;
	mdbc_parm->MdmatchPara.dbg_lumDiff_en = 0x0;

	mdbc_parm->MorPara.mor_th0 	  = 0x4;
	mdbc_parm->MorPara.mor_th1    = 0x0;
	mdbc_parm->MorPara.mor_th2    = 0x8;
	mdbc_parm->MorPara.mor_th3    = 0x0;
	mdbc_parm->MorPara.mor_th_dil = 0x0;
	mdbc_parm->MorPara.mor_sel0   = 0x1;
	mdbc_parm->MorPara.mor_sel1   = 0x1;
	mdbc_parm->MorPara.mor_sel2   = 0x1;
	mdbc_parm->MorPara.mor_sel3   = 0x0;

	mdbc_parm->UpdPara.minT           = 6;
	mdbc_parm->UpdPara.maxT           = 12;
	mdbc_parm->UpdPara.maxFgFrm       = 0x80;
	mdbc_parm->UpdPara.deghost_dth    = 50;
	mdbc_parm->UpdPara.deghost_sth    = 205;
	mdbc_parm->UpdPara.stable_frm     = 0x78;
	mdbc_parm->UpdPara.update_dyn     = 0x80;
	mdbc_parm->UpdPara.va_distth      = 32;
	mdbc_parm->UpdPara.t_distth       = 24;
	mdbc_parm->UpdPara.dbg_frmID      = 0x0;
	mdbc_parm->UpdPara.dbg_frmID_en   = 0x0;
	mdbc_parm->UpdPara.dbg_rnd        = 0x0;
	mdbc_parm->UpdPara.dbg_rnd_en     = 0x0;
}

static void md_set_para_low_sensitivity(VENDOR_MD_PARAM *mdbc_parm)
{
	mdbc_parm->MdmatchPara.lbsp_th    = 0x0;
	mdbc_parm->MdmatchPara.d_colour   = 12;
	mdbc_parm->MdmatchPara.r_colour   = 18;
	mdbc_parm->MdmatchPara.d_lbsp     = 5;
	mdbc_parm->MdmatchPara.r_lbsp     = 10;
	mdbc_parm->MdmatchPara.model_num  = 0x8;
	mdbc_parm->MdmatchPara.t_alpha    = 25;
	mdbc_parm->MdmatchPara.dw_shift   = 0x4;
	mdbc_parm->MdmatchPara.dlast_alpha= 100;
	mdbc_parm->MdmatchPara.min_match  = 1;
	mdbc_parm->MdmatchPara.dlt_alpha  = 0xa;
	mdbc_parm->MdmatchPara.dst_alpha  = 0x28;
	mdbc_parm->MdmatchPara.uv_thres   = 16;
	mdbc_parm->MdmatchPara.s_alpha    = 100;
	mdbc_parm->MdmatchPara.dbg_lumDiff= 0x0;
	mdbc_parm->MdmatchPara.dbg_lumDiff_en = 0x0;

	mdbc_parm->MorPara.mor_th0 	  = 0x4;
	mdbc_parm->MorPara.mor_th1    = 0x0;
	mdbc_parm->MorPara.mor_th2    = 0x8;
	mdbc_parm->MorPara.mor_th3    = 0x0;
	mdbc_parm->MorPara.mor_th_dil = 0x0;
	mdbc_parm->MorPara.mor_sel0   = 0x1;
	mdbc_parm->MorPara.mor_sel1   = 0x1;
	mdbc_parm->MorPara.mor_sel2   = 0x1;
	mdbc_parm->MorPara.mor_sel3   = 0x0;

	mdbc_parm->UpdPara.minT           = 3;
	mdbc_parm->UpdPara.maxT           = 6;
	mdbc_parm->UpdPara.maxFgFrm       = 0x80;
	mdbc_parm->UpdPara.deghost_dth    = 50;
	mdbc_parm->UpdPara.deghost_sth    = 205;
	mdbc_parm->UpdPara.stable_frm     = 0x78;
	mdbc_parm->UpdPara.update_dyn     = 0x80;
	mdbc_parm->UpdPara.va_distth      = 32;
	mdbc_parm->UpdPara.t_distth       = 24;
	mdbc_parm->UpdPara.dbg_frmID      = 0x0;
	mdbc_parm->UpdPara.dbg_frmID_en   = 0x0;
	mdbc_parm->UpdPara.dbg_rnd        = 0x0;
	mdbc_parm->UpdPara.dbg_rnd_en     = 0x0;
}

static HD_RESULT md_set_para(MEM_RANGE *p_share_mem, UINT32 mode, UINT32 sensi)
{
	VENDOR_MD_PARAM 		   mdbc_parm;
	HD_RESULT ret = HD_OK;

	mdbc_parm.mode = mode;
	mdbc_parm.controlEn.update_nei_en = 1;
	mdbc_parm.controlEn.deghost_en    = 1;
	mdbc_parm.controlEn.roi_en0       = 0;
	mdbc_parm.controlEn.roi_en1       = 0;
	mdbc_parm.controlEn.roi_en2       = 0;
	mdbc_parm.controlEn.roi_en3       = 0;
	mdbc_parm.controlEn.roi_en4       = 0;
	mdbc_parm.controlEn.roi_en5       = 0;
	mdbc_parm.controlEn.roi_en6       = 0;
	mdbc_parm.controlEn.roi_en7       = 0;
	mdbc_parm.controlEn.chksum_en     = 0;
	mdbc_parm.controlEn.bgmw_save_bw_en = 1;
	mdbc_parm.controlEn.bc_y_only_en 	= 0;
#if 0
	if(ping_pong_id == 0)
	{
		mdbc_parm.InInfo.uiInAddr0 = p_share_mem[0].addr;
		mdbc_parm.InInfo.uiInAddr1 = p_share_mem[1].addr;
		mdbc_parm.InInfo.uiInAddr2 = p_share_mem[2].addr;
		mdbc_parm.InInfo.uiInAddr3 = p_share_mem[3].addr;
		mdbc_parm.InInfo.uiInAddr4 = p_share_mem[4].addr;
		mdbc_parm.InInfo.uiInAddr5 = p_share_mem[5].addr;
		mdbc_parm.OutInfo.uiOutAddr0 = p_share_mem[6].addr;
		mdbc_parm.OutInfo.uiOutAddr1 = p_share_mem[7].addr;
		mdbc_parm.OutInfo.uiOutAddr2 = p_share_mem[8].addr;
		mdbc_parm.OutInfo.uiOutAddr3 = p_share_mem[9].addr;
	} else {
		mdbc_parm.InInfo.uiInAddr0 = p_share_mem[0].addr;
		mdbc_parm.InInfo.uiInAddr1 = p_share_mem[1].addr;
		mdbc_parm.InInfo.uiInAddr2 = p_share_mem[2].addr;
		mdbc_parm.InInfo.uiInAddr3 = p_share_mem[7].addr;
		mdbc_parm.InInfo.uiInAddr4 = p_share_mem[8].addr;
		mdbc_parm.InInfo.uiInAddr5 = p_share_mem[9].addr;
		mdbc_parm.OutInfo.uiOutAddr0 = p_share_mem[6].addr;
		mdbc_parm.OutInfo.uiOutAddr1 = p_share_mem[3].addr;
		mdbc_parm.OutInfo.uiOutAddr2 = p_share_mem[4].addr;
		mdbc_parm.OutInfo.uiOutAddr3 = p_share_mem[5].addr;
	}
#endif
	mdbc_parm.InInfo.uiInAddr0 = p_share_mem[0].addr;
	mdbc_parm.InInfo.uiInAddr1 = p_share_mem[1].addr;
	mdbc_parm.InInfo.uiInAddr2 = p_share_mem[2].addr;
	mdbc_parm.InInfo.uiInAddr3 = p_share_mem[3].addr;
	mdbc_parm.InInfo.uiInAddr4 = p_share_mem[4].addr;
	mdbc_parm.InInfo.uiInAddr5 = p_share_mem[5].addr;
	mdbc_parm.OutInfo.uiOutAddr0 = p_share_mem[6].addr;
	mdbc_parm.OutInfo.uiOutAddr1 = p_share_mem[3].addr;
	mdbc_parm.OutInfo.uiOutAddr2 = p_share_mem[4].addr;
	mdbc_parm.OutInfo.uiOutAddr3 = p_share_mem[5].addr;
	
	mdbc_parm.uiLLAddr          = 0x0;
	mdbc_parm.InInfo.uiLofs0    = MDBC_ALIGN(IMG_WIDTH,4);//160;
	mdbc_parm.InInfo.uiLofs1    = MDBC_ALIGN(IMG_WIDTH,4);//160;
	mdbc_parm.Size.uiMdbcWidth  = IMG_WIDTH;
	mdbc_parm.Size.uiMdbcHeight = IMG_HEIGHT;

	switch (sensi) {
	case LOW_SENSI:
		md_set_para_low_sensitivity(&mdbc_parm);
		break;
	case MED_SENSI:
		md_set_para_medium_sensitivity(&mdbc_parm);
		break;
	case HIGH_SENSI:
		md_set_para_high_sensitivity(&mdbc_parm);
		break;
	default:
		md_set_para_high_sensitivity(&mdbc_parm);
		break;
	}

	ret = vendor_md_set(VENDOR_MD_PARAM_ALL, &mdbc_parm);
	if (HD_OK != ret) {
		printf("set img fail, error code = %d\r\n", ret);
	}
	return ret;
}

MAIN(argc, argv)
{
	VOS_TICK    hw_tick_begin, hw_tick_end;
	VOS_TICK    sw_tick_begin, sw_tick_end;
    HD_RESULT ret;
	MEM_RANGE share_mem[SHARE_MEM_NUM] = {0};
	int frmidx = 0,idx;
	UINT32 pattern_start_id = 0;
	UINT32 pattern_end_id = 100;
	UINT32 is_Init=0;
	VENDOR_MD_TRIGGER_PARAM md_trig_param;
	LIB_MD_MDT_LIB_INFO 	mdt_lib_param = {0};
	LIB_MD_AP_SUBREGION 	stSubParam[SUBREGION_NUM] = {0};
	LIB_MD_AP_CROSS_REGION 	stCrossRegion[CROSSREGION_NUM] = {0};
	LIB_MD_AP_REGION_POINT	stLine[4] = {0};
	LIB_MD_AP_REGION_POINT	stPt0[5] = {0};
	LIB_MD_AP_REGION_POINT	stPt1[8] = {0};
	LIB_MD_MDT_RESULT_INFO 	lib_md_rst = {0};
	UINT8        			u8Sub_motion_alarm[SUBREGION_NUM] = {0}; 
	UINT8        			u8Cross_rst[LIB_MD_MAX_OBJ_NUM][CROSSREGION_NUM] = {0}; 
	UINT32 reg_id = 0;
	UINT32 obj_counter = 0;
	int g_scene_change_alarm_th = 50;
	int i = 0;
	UINT32 file_size = 0;
	char in_file1[64];
	char in_file2[64];
#if DEBUG_FILE
	int base_id = 3051;
	char out_file1[64];
	char out_file2[64];
	char out_file3[64];
	char out_file4[64];
	FILE  *fd;
#endif

#if OUTPUT_BMP
	char ImgFilePath[64];
#endif

	if(argc > 3){
		idx = 1;
		if (argc > idx) {
			sscanf(argv[idx++], "%lu", &IMG_WIDTH);
		}
		if (argc > idx) {
			sscanf(argv[idx++], "%lu", &IMG_HEIGHT);
		}
		if (argc > idx) {
			sscanf(argv[idx++], "%lu", &pattern_start_id);
		}
		if (argc > idx) {
			sscanf(argv[idx++], "%lu", &pattern_end_id);
		}
	}else{
		IMG_WIDTH = 160;
		IMG_HEIGHT = 120;
		pattern_start_id = 121;
		pattern_end_id = 130;
	}
	printf("IMG_WIDTH = %lu,IMG_HEIGHT = %lu,pattern_start_id = %lu,pattern_end_id = %lu\r\n", IMG_WIDTH,IMG_HEIGHT,pattern_start_id,pattern_end_id);
	IMG_BUF_SIZE = (IMG_WIDTH * IMG_HEIGHT);
	printf("IMG_BUF_SIZE = %lu\r\n", IMG_BUF_SIZE);

	/* init common module */
	ret = hd_common_init(0);
    if(ret != HD_OK) {
        printf("init fail=%d\n", ret);
        goto comm_init_fail;
    }
	/* init memory */
	ret = mem_init();
    if(ret != HD_OK) {
        printf("init fail=%d\n", ret);
        goto mem_init_fail;
    }
	/* init share memory */
	ret = share_memory_init(share_mem);
	if (ret != HD_OK) {
		printf("mem_init fail=%d\n", ret);
		goto exit;
	}

	/* init gfx for scale*/
	ret = hd_gfx_init();
    if (HD_OK != ret) {
        printf("hd_gfx_init fail\r\n");
        goto exit;
    }

	ret = vendor_md_init();
	if (HD_OK != ret) {
		printf("init fail, error code = %d\r\n", ret);
		goto exit;
	}

	md_trig_param.is_nonblock = 0;
	md_trig_param.time_out_ms = 0;
	// LibMD motion detection info
	mdt_lib_param.mdt_info.libmd_enabled = 1;
	mdt_lib_param.mdt_info.phy_md_x_num = IMG_WIDTH;
	mdt_lib_param.mdt_info.phy_md_y_num = IMG_HEIGHT;
	mdt_lib_param.mdt_info.phy_md_rst.p_md_bitmap = (UINT8*)share_mem[7].va;
	mdt_lib_param.mdt_info.phy_md_rst.md_bitmap_sz = IMG_WIDTH * IMG_HEIGHT;
	if ((ret = lib_md_set(0, LIB_MD_MOTION_DETECT_INFO, &mdt_lib_param.mdt_info)) != HD_OK) {
		printf("lib_md_set enable fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}
	// LibMD init (must after lib_md_set LIB_MD_MOTION_DETECT_INFO)
	ret = lib_md_init(0);
	if (HD_OK != ret) {
		printf("lib_md_init fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}
	// LibMD function enable
	mdt_lib_param.mdt_enable.globel_md_alarm_detect_en = 1;
	mdt_lib_param.mdt_enable.subregion_md_alarm_detect_en = 1;
	mdt_lib_param.mdt_enable.scene_change_alarm_detect_en = 0;
	mdt_lib_param.mdt_enable.md_obj_detect_en = 1;
	mdt_lib_param.mdt_enable.md_obj_cross_en = 1;
	if ((ret = lib_md_set(0, LIB_MD_AP_ENABLE_PARAM, &mdt_lib_param.mdt_enable)) != HD_OK) {
		printf("lib_md_set enable fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}
	// LibMD global motion alarm
	mdt_lib_param.mdt_global_param.motion_alarm_th = 50;
	if ((ret = lib_md_set(0, LIB_MD_AP_GLOBAL_MOTION_ALARM_PARAM, &mdt_lib_param.mdt_global_param)) != HD_OK) {
		printf("lib_md_set global motion alarm param fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}
	
	// LibMD sub-region motion alarm
	stSubParam[0].enabled = 1;
	stSubParam[0].x_start = 55;
	stSubParam[0].y_start = 60;
	stSubParam[0].x_end = 80;
	stSubParam[0].y_end = 70;
	stSubParam[0].alarm_th = 50;
	stSubParam[1].enabled = 1;
	stSubParam[1].x_start = 120;
	stSubParam[1].y_start = 10;
	stSubParam[1].x_end = 130;
	stSubParam[1].y_end = 15;
	stSubParam[1].alarm_th = 20;
	mdt_lib_param.mdt_subregion_param.sub_region_num = SUBREGION_NUM;
	mdt_lib_param.mdt_subregion_param.pstSubParam = stSubParam;
	if ((ret = lib_md_set(0, LIB_MD_AP_SUBREGION_MOTION_ALARM_PARAM, &mdt_lib_param.mdt_subregion_param)) != HD_OK) {
		printf("lib_md_set sub-region motion alarm param fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}
	// LibMD scene change alarm
	mdt_lib_param.mdt_scene_change_param.scene_change_alarm_th = g_scene_change_alarm_th;
	if ((ret = lib_md_set(0, LIB_MD_AP_SCENE_CHANGE_ALARM_PARAM, &mdt_lib_param.mdt_scene_change_param)) != HD_OK) {
		printf("lib_md_set scene change alarm param fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}
	// LibMD Obj detect
	mdt_lib_param.mdt_obj.obj_size_th = IMG_WIDTH * IMG_HEIGHT / 1000;
	if ((ret = lib_md_set(0, LIB_MD_AP_OBJ_PARAM, &mdt_lib_param.mdt_obj)) != HD_OK) {
		printf("lib_md_set obj threshold param fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}

	// LibMD Cross param
	mdt_lib_param.mdt_cross_param.cross_type = 2;         //  none:0 cross_line:1 cross_region:2  
	mdt_lib_param.mdt_cross_param.overlap_th = 1;         //  object overlapping threshold  
	if(mdt_lib_param.mdt_cross_param.cross_type==1){//cross_line
		stCrossRegion[0].point_num = 4; // must set 4 in cross_line mode
		stLine[0].x = 0;
		stLine[0].y = 30;
		stLine[1].x = IMG_WIDTH;
		stLine[1].y = 35;
		stLine[2].x = IMG_WIDTH;
		stLine[2].y = 45;
		stLine[3].x = 0;
		stLine[3].y = 40;
		stCrossRegion[0].pstPt = stLine;
		mdt_lib_param.mdt_cross_param.pstCrossRegion = stCrossRegion;
	}else{//cross_region
		mdt_lib_param.mdt_cross_param.region_num = CROSSREGION_NUM;
		stCrossRegion[0].point_num = 5;
		stPt0[0].x = 50;
		stPt0[0].y = 60;
		stPt0[1].x = 60;
		stPt0[1].y = 70;
		stPt0[2].x = 55;
		stPt0[2].y = 80;
		stPt0[3].x = 40;
		stPt0[3].y = 75;
		stPt0[4].x = 35;
		stPt0[4].y = 65;
		stCrossRegion[0].pstPt = stPt0;
		stCrossRegion[1].point_num = 8;
		stPt1[0].x = 95;
		stPt1[0].y = 20;
		stPt1[1].x = 105;
		stPt1[1].y = 12;
		stPt1[2].x = 115;
		stPt1[2].y = 12;
		stPt1[3].x = 120;
		stPt1[3].y = 20;
		stPt1[4].x = 115;
		stPt1[4].y = 45;
		stPt1[5].x = 100;
		stPt1[5].y = 50;
		stPt1[6].x = 85;
		stPt1[6].y = 45;
		stPt1[7].x = 80;
		stPt1[7].y = 35;
		stCrossRegion[1].pstPt = stPt1;
		mdt_lib_param.mdt_cross_param.pstCrossRegion = stCrossRegion;
	}
	if ((ret = lib_md_set(0, LIB_MD_AP_CROSS_PARAM, &mdt_lib_param.mdt_cross_param)) != HD_OK) {
		printf("lib_md_set cross param fail, error code = %d\r\n", ret);
		goto libmd_init_fail;
	}

	for(frmidx = (int)pattern_start_id; frmidx <= (int)pattern_end_id; frmidx++)
	{
		printf("------------ frmidx = %d ------------\r\n", frmidx);

		/// load file
#if defined(__FREERTOS)
		snprintf(in_file1, 64, "A:\\MDBCP\\DI\\pic_%04d\\dram_in_y.bin", frmidx);
#else
		snprintf(in_file1, 64, "//mnt//sd//MDBCP//DI//pic_%04d//dram_in_y.bin", frmidx);
#endif
		file_size = md_load_file(in_file1, share_mem[0].va);
		if (file_size == 0) {
			printf("[ERR]load dram_in_y.bin : %s\r\n", in_file1);
		}

#if defined(__FREERTOS)
		snprintf(in_file2, 64, "A:\\MDBCP\\DI\\pic_%04d\\dram_in_uv.bin", frmidx);
#else
		snprintf(in_file2, 64, "//mnt//sd//MDBCP//DI//pic_%04d//dram_in_uv.bin", frmidx);
#endif
		file_size = md_load_file(in_file2, share_mem[1].va);
		if (file_size == 0) {
			printf("[ERR]load dram_in_uv.bin : %s\r\n", in_file2);
		}
/*
		if(mdbc_parm.mode == 1){
			snprintf(in_file3, 64, "//mnt//sd//MDBCP//DI//pic_%04d//dram_in_uv_pre.bin", frmidx);
			file_size = md_load_file(in_file3, share_mem[2].va);
			if (file_size == 0) {
				printf("[ERR]load dram_in_uv_pre.bin : %s\r\n", in_file3);
			}
			snprintf(in_file4, 64, "//mnt//sd//MDBCP//DI//pic_%04d//dram_in_bgYUV.bin", frmidx);
			file_size = md_load_file(in_file4, share_mem[3].va);
			if (file_size == 0) {
				printf("[ERR]load dram_in_bgYUV.bin : %s\r\n", in_file4);
			}
			snprintf(in_file5, 64, "//mnt//sd//MDBCP//DI//pic_%04d//dram_in_var1.bin", frmidx);
			file_size = md_load_file(in_file5, share_mem[4].va);
			if (file_size == 0) {
				printf("[ERR]load dram_in_var1.bin : %s\r\n", in_file5);
			}
			snprintf(in_file6, 64, "//mnt//sd//MDBCP//DI//pic_%04d//dram_in_var2.bin", frmidx);
			file_size = md_load_file(in_file6, share_mem[5].va);
			if (file_size == 0) {
				printf("[ERR]load dram_in_var2.bin : %s\r\n", in_file6);
			}
		}
*/

		/// set to engine
		md_set_para(share_mem, is_Init,g_sensi);
		/// engine fire
		vos_perf_mark(&hw_tick_begin);
		ret = vendor_md_trigger(&md_trig_param);
		if (HD_OK != ret) {
			printf("trigger fail, error code = %d\r\n", ret);
			break;
		}
		vos_perf_mark(&hw_tick_end);
		//printf("vendor_md_trigger time = %d\r\n", vos_perf_duration(hw_tick_begin, hw_tick_end));

		memcpy((UINT32 *)share_mem[2].va , (UINT32 *)share_mem[1].va , IMG_BUF_SIZE/2);

		if(is_Init == 1) {
			hd_common_mem_flush_cache((VOID *)share_mem[6].va, ((IMG_BUF_SIZE+7)/8));
			bc_reorgS1((UINT8*)share_mem[6].va,(UINT8*)share_mem[7].va, IMG_WIDTH, IMG_HEIGHT);
#if OUTPUT_BMP
#if defined(__FREERTOS)
			snprintf(ImgFilePath, 64, "A:\\MDBCP\\Debug\\output_bmp\\output_%04d.bmp", frmidx);
#else
			snprintf(ImgFilePath, 64, "//mnt//sd//MDBCP//Debug//output_bmp//output_%04d.bmp", frmidx);
#endif
			bc_writebmpfile(ImgFilePath, (UINT8*)share_mem[7].va, IMG_WIDTH, IMG_HEIGHT, 8);
#endif

#if DEBUG_FILE
#if defined(__FREERTOS)
			snprintf(out_file1, 64, "A:\\MDBCP\\DO\\pic_%04d\\dram_out_s1.bin", base_id+frmidx);
#else
			snprintf(out_file1, 64, "//mnt//sd//MDBCP//DO//pic_%04d//dram_out_s1.bin", base_id+frmidx);
#endif
			fd = fopen(out_file1, "wb");
			if (!fd) {
				printf("cannot read %s\r\n", out_file1);
			} else {
    			file_size = fwrite((const void *)share_mem[6].va,1,((IMG_BUF_SIZE+7)/8),fd);
    			if (file_size == 0) {
    				printf("load dram_out_s1.bin : %s\r\n", out_file1);
    			}
    			fclose(fd);
			}

			hd_common_mem_flush_cache((VOID *)share_mem[3].va, IMG_BUF_SIZE*40);
#if defined(__FREERTOS)
			snprintf(out_file2, 64, "A:\\MDBCP\\DO\\pic_%04d\\dram_out_bgYUV.bin", base_id+frmidx);
#else
			snprintf(out_file2, 64, "//mnt//sd//MDBCP//DO//pic_%04d//dram_out_bgYUV.bin", base_id+frmidx);
#endif
			fd = fopen(out_file2, "wb");
			if (!fd) {
				printf("cannot read %s\r\n", out_file2);
			} else {
				file_size = fwrite((const void *)share_mem[3].va,1,IMG_BUF_SIZE*40,fd);
    			if (file_size == 0) {
    				printf("load dram_out_bgYUV.bin : %s\r\n", out_file2);
    			}
    			fclose(fd);
			}
#endif
			
			memset((void *)&lib_md_rst, 0, sizeof(LIB_MD_MDT_RESULT_INFO));
			lib_md_rst.sub_motion_alarm = u8Sub_motion_alarm;
			for(obj_counter=0;obj_counter<LIB_MD_MAX_OBJ_NUM;obj_counter++){
				lib_md_rst.obj[obj_counter].cross_rst = u8Cross_rst[obj_counter];
			}

			vos_perf_mark(&sw_tick_begin);
			if ((ret = lib_md_get(0, LIB_MD_RESULT_INFO, &lib_md_rst)) != HD_OK) {
				printf("LIB_MD_RESULT_INFO fail\n");
			}
			vos_perf_mark(&sw_tick_end);
			//printf("lib_md_get time = %d\r\n", vos_perf_duration(sw_tick_begin, sw_tick_end));
			//printf("lib_md %d ms.\n", t);

			if (lib_md_rst.global_motion_alarm == 1) {
				printf("[WRN] global motion alarm\n");
			}
			for (reg_id = 0; reg_id < mdt_lib_param.mdt_subregion_param.sub_region_num; reg_id++) {
				if (lib_md_rst.sub_motion_alarm[reg_id] == 1) {
					printf("[WRN] sub_region[%d] motion alarm\n", (int)reg_id);
				}
			}
			if (lib_md_rst.scene_change_alarm == 1) {
				printf("[WRN] scene change alarm\n");
			}
			if (lib_md_rst.obj_num > 0) {
				for (obj_counter = 1; obj_counter <= lib_md_rst.obj_num; obj_counter++) {
					if(mdt_lib_param.mdt_enable.md_obj_cross_en == 1) {
						if(mdt_lib_param.mdt_cross_param.cross_type==2){
							for(i=0;i<CROSSREGION_NUM;i++){
								if(lib_md_rst.obj[obj_counter].cross_rst[i])
								printf("[WRN] OBJ %d in region %d alarm: x0=%d,x1=%d,y0=%d,y1=%d,cross_rst=%d\r\n", obj_counter,i,
									lib_md_rst.obj[obj_counter].start_x, lib_md_rst.obj[obj_counter].end_x,
									lib_md_rst.obj[obj_counter].start_y, lib_md_rst.obj[obj_counter].end_y, lib_md_rst.obj[obj_counter].cross_rst[i]);
							}
						}else{
							if(lib_md_rst.obj[obj_counter].cross_rst[0]==1){
								printf("[WRN] OBJ %d crossline(IN_TO_OUT) alarm: x0=%d,x1=%d,y0=%d,y1=%d,cross_rst=%d\r\n", obj_counter,
									lib_md_rst.obj[obj_counter].start_x, lib_md_rst.obj[obj_counter].end_x,
									lib_md_rst.obj[obj_counter].start_y, lib_md_rst.obj[obj_counter].end_y, lib_md_rst.obj[obj_counter].cross_rst[0]);
							}else if(lib_md_rst.obj[obj_counter].cross_rst[0]==2){
								printf("[WRN] OBJ %d crossline(OUT_TO_IN) alarm: x0=%d,x1=%d,y0=%d,y1=%d,cross_rst=%d\r\n", obj_counter,
									lib_md_rst.obj[obj_counter].start_x, lib_md_rst.obj[obj_counter].end_x,
									lib_md_rst.obj[obj_counter].start_y, lib_md_rst.obj[obj_counter].end_y, lib_md_rst.obj[obj_counter].cross_rst[0]);
							}
						}
					} else {
						printf("[OBJ %d]: x0=%d,x1=%d,y0=%d,y1=%d\r\n", obj_counter,
							lib_md_rst.obj[obj_counter].start_x, lib_md_rst.obj[obj_counter].end_x,
							lib_md_rst.obj[obj_counter].start_y, lib_md_rst.obj[obj_counter].end_y);
					}
				}
			}
		}
#if DEBUG_FILE
		hd_common_mem_flush_cache((VOID *)share_mem[4].va, IMG_BUF_SIZE*13/2);
#if defined(__FREERTOS)
		snprintf(out_file3, 64, "A:\\MDBCP\\DO\\pic_%04d\\dram_out_var1.bin", base_id+frmidx);
#else
		snprintf(out_file3, 64, "//mnt//sd//MDBCP//DO//pic_%04d//dram_out_var1.bin", base_id+frmidx);
#endif
		fd = fopen(out_file3, "wb");
		if (!fd) {
			printf("cannot read %s\r\n", out_file3);
		} else {
    		file_size = fwrite((const void *)share_mem[4].va,1,IMG_BUF_SIZE*13/2,fd);
    		if (file_size == 0) {
    			printf("load dram_out_var1.bin : %s\r\n", out_file3);
    		}
    		fclose(fd);
		}

		hd_common_mem_flush_cache((VOID *)share_mem[5].va, ((IMG_BUF_SIZE+15)/16)*16*12);
#if defined(__FREERTOS)
		snprintf(out_file4, 64, "A:\\MDBCP\\DO\\pic_%04d\\dram_out_var2.bin", base_id+frmidx);
#else
		snprintf(out_file4, 64, "//mnt//sd//MDBCP//DO//pic_%04d//dram_out_var2.bin", base_id+frmidx);
#endif
		fd = fopen(out_file4, "wb");
		if (!fd) {
			printf("cannot read %s\r\n", out_file4);
		} else {
    		file_size = fwrite((const void *)share_mem[5].va,1,((IMG_BUF_SIZE+15)/16)*16*12,fd);
    		if (file_size == 0) {
    			printf("load dram_out_var2.bin : %s\r\n", out_file4);
    		}
    		fclose(fd);
		}
#endif
		//ping_pong_id = (ping_pong_id+1)%2;
		if(is_Init==0)is_Init=1;
	}

libmd_init_fail:
	ret = lib_md_uninit(0);
	if (HD_OK != ret) {
		printf("lib_md_uninit fail, error code = %d\r\n", ret);
	}
	ret = vendor_md_uninit();
	if (HD_OK != ret)
		printf("uninit fail, error code = %d\r\n", ret);


exit:
	ret = hd_gfx_uninit();
	if (HD_OK != ret) {
		printf("hd_gfx_uninit fail\r\n");
	}

	ret = share_memory_exit(share_mem);
	if (ret != HD_OK) {
		printf("mem_uninit fail=%d\n", ret);
	}

	ret = mem_exit();
	if (ret != HD_OK) {
		printf("mem fail=%d\n", ret);
	}

mem_init_fail:
	ret = hd_common_uninit();
    if(ret != HD_OK) {
        printf("uninit fail=%d\n", ret);
    }
comm_init_fail:
	return 0;
}