static int pmem_remove(struct platform_device *pdev)
{
struct pmem_device *pmem = platform_get_drvdata(pdev);
pmem_free(pmem);
return 0;
}
static inline void
free_fmem(int width, int height, MCVENC_FMEM_INFO_T *fmem)
{
int mem_x, mem_y;
void *Ypic_vaddr, *Cpic_vaddr;
mem_x = ((width + 15) / 16) * 16;
mem_y = ((height + 15) / 16) * 16;
if (fmem->Ypic_addr) {
Ypic_vaddr = uio_phys_to_virt(fmem->Ypic_addr);
if (Ypic_vaddr)
pmem_free(Ypic_vaddr, mem_x * mem_y);
}
if (fmem->Cpic_addr) {
Cpic_vaddr = uio_phys_to_virt(fmem->Cpic_addr);
if (Cpic_vaddr)
pmem_free(Cpic_vaddr, mem_x * mem_y / 2);
}
return;
}
unsigned long
shvpu5_load_firmware(char *filename, size_t *size)
{
void *vaddr;
unsigned char *p;
unsigned long paddr;
int fd;
size_t len;
ssize_t ret;
fd = open(filename, O_RDONLY);
if (fd < 0) {
perror("firmware open");
goto fail_open;
}
len = lseek(fd, 0, SEEK_END);
logd("size of %s = %x\n", filename, len);
*size = len;
vaddr = p = pmem_alloc(len, 32, &paddr);
if (vaddr == NULL) {
fprintf(stderr, "pmem alloc failed.\n");
goto fail_pmem_alloc;
}
lseek(fd, 0, SEEK_SET);
do {
ret = read(fd, p, len);
if (ret <= 0) {
perror("firmware read");
goto fail_read;
}
len -= ret;
p += ret;
} while (len > 0);
close(fd);
return paddr;
fail_read:
pmem_free(vaddr, lseek(fd, 0, SEEK_END));
fail_pmem_alloc:
close(fd);
fail_open:
return -1;
}
static inline int
alloc_fmem(int width, int height, MCVENC_FMEM_INFO_T *fmem)
{
int mem_x, mem_y;
void *Ypic_vaddr, *Cpic_vaddr;
mem_x = ((width + 15) / 16) * 16;
mem_y = ((height + 15) / 16) * 16;
Ypic_vaddr = pmem_alloc(mem_x * mem_y, 32, &fmem->Ypic_addr);
if (Ypic_vaddr == NULL)
return -1;
Cpic_vaddr = pmem_alloc(mem_x * mem_y / 2, 32, &fmem->Cpic_addr);
if (Cpic_vaddr == NULL) {
pmem_free(Ypic_vaddr, mem_x * mem_y);
return -1;
}
return 0;
}
Vdec_ReturnType vdec_close(struct VDecoder *dec)
{
VDEC_ERROR err;
VideoDecoder* pDec = (VideoDecoder*)(dec->core);
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: vdec_close()\n");
#ifdef PROFILE_DECODER
usecs_t time_taken_by_arm = QPERF_TERMINATE(arm_decode);
float avArmTime = (float)time_taken_by_arm/(qperf_total_frame_cnt*1000);
usecs_t frame_data_time = QPERF_TERMINATE(frame_data);
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"===========================================================\n");
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL," Arm Statistics \n");
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"===========================================================\n");
QTV_PERF_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"Total number of frames decoded = %ld\n",qperf_total_frame_cnt);
QTV_PERF_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"Average Arm time/frame(ms) = %f\n",avArmTime);
QTV_PERF_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"Frames Arm Decoded/sec = %f\n",1000/avArmTime);
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"===========================================================\n");
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL," Frame Done Statistics \n");
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"===========================================================\n");
QTV_PERF_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"Frame done cumulative time = %lld\n",frame_data_time);
QTV_PERF_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"Frames Done per second = %f\n",(float)(qperf_total_frame_cnt-1)*1000000/frame_data_time);
QTV_PERF_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_FATAL,"===========================================================\n");
#endif
#ifdef LOG_YUV_FRAMES
if (pYUVFile)
{
fclose (pYUVFile);
pYUVFile = NULL;
}
#endif
#ifdef LOG_INPUT_BUFFERS
if (pInputFile)
{
fclose (pInputFile);
}
#endif
vdec_output_frame_index = 0;
#if NEED_VDEC_LP
if (vdec->fake)
{
//jlk - adsp_close() calls adsp_disable right now. Calling adsp_disable() twice causes problems
//Renable this line when we fix the kernel driver
//adsp_disable((adsp_module*)vdec->fake);
adsp_close((adsp_module*)vdec->fake);
}
else
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: adsp modules is NULL\n");
}
#endif
nFrameDoneCnt = 0;
nGoodFrameCnt = 0;
if (dec->core)
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: calling Suspend");
err = pDec->Suspend( );
if (VDEC_ERR_EVERYTHING_FINE != err)
{
QTV_MSG_PRIO1(QTVDIAG_GENERAL,QTVDIAG_PRIO_ERROR,"vdec: Suspend returned error: %d\n", (int)err);
}
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_LOW,"vdec: calling vdec_destroy");
QTV_Delete( (VideoDecoder*)(dec->core) );
}
else
{
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_HIGH,"vdec: core is NULL");
}
pmem_free(&dec->arena);
free(dec);
QTV_MSG_PRIO(QTVDIAG_GENERAL,QTVDIAG_PRIO_MED,"vdec: closed\n");
return VDEC_SUCCESS;
}
void cbuf_done(void) {
if (!g_cbufs.data)
return;
pmem_free(g_cbufs.data);
g_cbufs.data = 0;
}
int main()
{
JpgDecHal* jpgDecoder = new JpgDecHal();
if(!jpgDecoder->lock())
{
xlog("can't lock resource");
return -1;
}
FILE *fp;
int src_fd;
unsigned long index;
unsigned char *src_va;
src_va = (unsigned char *)pmem_alloc(BUFFER_SIZE , &src_fd);
if(src_va == NULL)
{
xlog("Can not allocate memory\n");
return -1;
}
fp = fopen("/data/422.jpg", "r");
fread(src_va , 1 , BUFFER_SIZE , fp);
fclose(fp);
jpgDecoder->setSrcAddr(src_va);
// jpgDecoder->setSrcAddr(jpg_file);
jpgDecoder->setSrcSize(BUFFER_SIZE);
jpgDecoder->parse();
unsigned int w = jpgDecoder->getJpgWidth();
unsigned int h = jpgDecoder->getJpgHeight();
xlog("file width/height : %d %d", w, h);
jpgDecoder->setOutWidth(w);
jpgDecoder->setOutHeight(h);
jpgDecoder->setOutFormat(JpgDecHal::kRGB_565_Format);
int dst_size = w * h * 2;
unsigned char *dst_buffer = (unsigned char *)malloc(dst_size);
jpgDecoder->setDstAddr((unsigned char*) dst_buffer);
jpgDecoder->setDstSize((unsigned int)dst_size);
if(jpgDecoder->start())
{
FILE *fp;
fp = fopen("/data/ttt.raw", "w");
int index;
for(index = 0 ; index < dst_size ; index++)
{
fprintf(fp, "%c", dst_buffer[index]);
}
fclose(fp);
}
else
{
xlog("decode failed~~~");
}
pmem_free(src_va , BUFFER_SIZE , src_fd);
jpgDecoder->unlock();
delete jpgDecoder;
return 0;
}
long
decode_init(shvpu_decode_PrivateType *shvpu_decode_Private)
{
extern const MCVDEC_API_T avcdec_api_tbl;
shvpu_decode_codec_t *pCodec;
MCVDEC_CONTEXT_T *pContext;
long ret;
unsigned long ce_firmware_addr;
struct codec_init_ops *cops;
int num_views;
/*** allocate memory ***/
pCodec = (shvpu_decode_codec_t *)
calloc(1, sizeof(shvpu_decode_codec_t));
if (pCodec == NULL)
return -1L;
memset((void *)pCodec, 0, sizeof(shvpu_decode_codec_t));
/*** initialize driver ***/
ret = shvpu_driver_init(&pCodec->pDriver);
if (ret != MCIPH_NML_END)
return ret;
extern unsigned long uio_virt_to_phys(void *, long, unsigned long);
extern long notify_buffering(MCVDEC_CONTEXT_T *, long);
extern long notify_userdata(MCVDEC_CONTEXT_T *,
MCVDEC_USERDATA_T *, long);
static const MCVDEC_CMN_PROPERTY_T _cprop_def = {
.max_slice_cnt = 16,
.fmem_alloc_mode = MCVDEC_ALLOC_FRAME_OR_FIELD,
.output_unit = MCVDEC_UNIT_FRAME,
.fmem_notice_mode = MCVDEC_FMEM_INDEX_ENABLE,
.first_hdr_enable = MCVDEC_OFF,
.ec_mode = MCVDEC_ECMODE_TYPE1,
.max_imd_ratio_10 = 80,
.func_userdata_callback = notify_userdata,
.func_imd_buffering_ready = notify_buffering,
.virt_to_phys_func = uio_virt_to_phys,
#if defined(VPU5HA_SERIES)
.buffering_pic_cnt = BUFFERING_COUNT,
.ce_config = MCVDEC_2CE,
.num_views = 1,
#endif
};
pCodec->cprop = _cprop_def;
switch(shvpu_decode_Private->video_coding_type) {
case OMX_VIDEO_CodingAVC:
pCodec->cprop.stream_type = MCVDEC_H264,
avcCodec_init(&pCodec->vpu_codec_params, shvpu_decode_Private);
break;
case OMX_VIDEO_CodingMPEG4:
pCodec->cprop.stream_type = MCVDEC_MPEG4,
pCodec->cprop.max_slice_cnt = 1,
mpegCodec_init(&pCodec->vpu_codec_params, shvpu_decode_Private);
break;
default:
goto free_pcodec;
};
cops = pCodec->vpu_codec_params.ops;
pCodec->cprop.func_get_intrinsic_header = cops->intrinsic_func_callback;
pCodec->wbuf_dec.work_area_size = pCodec->vpu_codec_params.wbuf_size;
pCodec->wbuf_dec.work_area_addr =
calloc(1, pCodec->wbuf_dec.work_area_size);
logd("work_area_addr = %p\n",
pCodec->wbuf_dec.work_area_addr);
ce_firmware_addr =
shvpu5_load_firmware(pCodec->vpu_codec_params.ce_firmware_name,
&pCodec->fw_size.ce_firmware_size);
logd("ce_firmware_addr = %lx\n", ce_firmware_addr);
pCodec->fw.vlc_firmware_addr =
shvpu5_load_firmware(pCodec->vpu_codec_params.vlc_firmware_name,
&pCodec->fw_size.vlc_firmware_size);
logd("vlc_firmware_addr = %lx\n",
pCodec->fw.vlc_firmware_addr);
#if defined(VPU_VERSION_5)
pCodec->fw.ce_firmware_addr = ce_firmware_addr;
num_views = 1;
#elif defined(VPU5HA_SERIES)
pCodec->fw.ce_firmware_addr[0] = ce_firmware_addr;
num_views = pCodec->cprop.num_views;
#endif
pCodec->cprop.codec_params = pCodec->vpu_codec_params.codec_params;
cops->init_intrinsic_array(&shvpu_decode_Private->intrinsic);
logd("----- invoke mcvdec_init_decoder() -----\n");
ret = mcvdec_init_decoder(pCodec->vpu_codec_params.api_tbl,
&pCodec->cprop,
&pCodec->wbuf_dec,
&pCodec->fw, shvpu_decode_Private->intrinsic,
pCodec->pDriver->pDrvInfo, &pContext);
logd("----- resume from mcvdec_init_decoder() -----\n");
if (ret != MCIPH_NML_END)
return ret;
/*** initialize work area ***/
void *vaddr;
unsigned long paddr;
cops->calc_buf_sizes(num_views,
shvpu_decode_Private,
pCodec,
&pCodec->imd_info.imd_buff_size,
&pCodec->ir_info.ir_info_size,
&pCodec->mv_info.mv_info_size);
pCodec->imd_info.imd_buff_mode = MCVDEC_MODE_NOMAL;
vaddr = pmem_alloc(pCodec->imd_info.imd_buff_size,
512, &pCodec->imd_info.imd_buff_addr);
logd("imd_info.imd_buff_addr = %lx\n",
pCodec->imd_info.imd_buff_addr);
if (!vaddr)
return -1;
pCodec->ir_info.ir_info_addr = (unsigned long)
pmem_alloc(pCodec->ir_info.ir_info_size, 512, &paddr);
logd("ir_info.ir_info_addr = %lx\n", pCodec->ir_info.ir_info_addr);
if (!pCodec->ir_info.ir_info_addr)
return -1;
vaddr = pmem_alloc(pCodec->mv_info.mv_info_size,
512, &pCodec->mv_info.mv_info_addr);
logd("mv_info.mv_info_addr = %lx\n", pCodec->mv_info.mv_info_addr);
if (!vaddr)
return -1;
logd("----- invoke mcvdec_set_vpu5_work_area() -----\n");
ret = mcvdec_set_vpu5_work_area(pContext, &pCodec->imd_info,
&pCodec->ir_info,
&pCodec->mv_info);
logd("----- resume from mcvdec_set_vpu5_work_area() -----\n");
if (ret != MCIPH_NML_END)
return ret;
/*** set play mode ***/
logd("----- invoke mcvdec_set_play_mode() -----\n");
ret = mcvdec_set_play_mode(pContext, MCVDEC_PLAY_FORWARD, 0, 0);
logd("----- resume from mcvdec_set_play_mode() -----\n");
pCodec->frameCount = pCodec->bufferingCount = 0;
if (shvpu_decode_Private->enable_sync) {
pCodec->codecMode = MCVDEC_MODE_SYNC;
pCodec->outMode = MCVDEC_OUTMODE_PULL;
} else {
pCodec->codecMode = MCVDEC_MODE_BUFFERING;
pCodec->outMode = MCVDEC_OUTMODE_PUSH;
}
pCodec->pSIQueue = calloc(1, sizeof(queue_t));
shvpu_queue_init(pCodec->pSIQueue);
pCodec->enoughHeaders = pCodec->enoughPreprocess = OMX_FALSE;
pthread_cond_init(&pCodec->cond_buffering, NULL);
pthread_mutex_init(&pCodec->mutex_buffering, NULL);
pContext->user_info = (void *)shvpu_decode_Private;
shvpu_decode_Private->avCodec = pCodec;
shvpu_decode_Private->avCodecContext = pContext;
return ret;
free_pcodec:
free(pCodec);
return -1;
}
void
decode_deinit(shvpu_decode_PrivateType *shvpu_decode_Private) {
if (shvpu_decode_Private) {
shvpu_decode_codec_t *pCodec = shvpu_decode_Private->avCodec;
decode_finalize(shvpu_decode_Private->avCodecContext);
if (shvpu_decode_Private->intrinsic)
pCodec->vpu_codec_params.ops->deinit_intrinsic_array
(shvpu_decode_Private->intrinsic);
#ifdef MERAM_ENABLE
close_meram(&shvpu_decode_Private->meram_data);
#endif
if (!pCodec)
return;
if (shvpu_decode_Private->avCodec->fmem) {
int i, bufs = shvpu_decode_Private->avCodec->fmem_size;
shvpu_fmem_data *outbuf = shvpu_decode_Private->avCodec->fmem;
for (i = 0 ; i < bufs; i++) {
phys_pmem_free(outbuf->fmem_start,
outbuf->fmem_len);
pthread_mutex_destroy(&outbuf->filled);
outbuf++;
}
free(shvpu_decode_Private->avCodec->fmem);
shvpu_decode_Private->avCodec->fmem = NULL;
}
free(shvpu_decode_Private->avCodec->fmem_info);
phys_pmem_free(pCodec->mv_info.mv_info_addr,
pCodec->mv_info.mv_info_size);
pmem_free((void *)pCodec->ir_info.ir_info_addr,
pCodec->ir_info.ir_info_size);
phys_pmem_free(pCodec->imd_info.imd_buff_addr,
pCodec->imd_info.imd_buff_size);
#if defined(VPU_VERSION_5)
phys_pmem_free(pCodec->fw.ce_firmware_addr,
pCodec->fw_size.ce_firmware_size);
#elif defined(VPU5HA_SERIES)
phys_pmem_free(pCodec->fw.ce_firmware_addr[0],
pCodec->fw_size.ce_firmware_size);
#endif
phys_pmem_free(pCodec->fw.vlc_firmware_addr,
pCodec->fw_size.vlc_firmware_size);
pCodec->vpu_codec_params.ops->deinit_codec
(&shvpu_decode_Private->avCodec->vpu_codec_params);
free_remaining_streams(pCodec->pSIQueue);
free(pCodec->pSIQueue);
free(pCodec->wbuf_dec.work_area_addr);
free(pCodec);
shvpu_decode_Private->avCodec = NULL;
}
}
int
decode_finalize(void *context)
{
int ret;
logd("----- invoke mcvdec_end_decoder() -----\n");
ret = mcvdec_end_decoder(context);
logd("----- resume from mcvdec_end_decoder() -----\n");
return ret;
}
int main()
{
printf("enter m4u test main()! \n");
// 1. alloc memory
unsigned char *pSrc = NULL;
unsigned char *pDst = NULL;
unsigned int srcsize = SRC_W*SRC_H*SRC_BPP;
unsigned int dstsize = DST_W*DST_H*DST_BPP;
#ifdef __USE_M4U__
pSrc = new unsigned char[SRC_W*SRC_H*SRC_BPP];
pDst = new unsigned char[DST_W*DST_H*DST_BPP];
unsigned int srcPa = 0;
unsigned int dstPa = 0;
// alloc MVA ...
MTKM4UDrv CM4u;
CM4u.m4u_enable_m4u_func(M4U_CLNTMOD_ROT);
CM4u.m4u_enable_m4u_func(M4U_CLNTMOD_WDMA);
///> --------------------4. config LCD port
// config port
M4U_PORT_STRUCT M4uPort;
M4uPort.ePortID = M4U_PORT_ROT_EXT;
M4uPort.Virtuality = 1;
M4uPort.Security = 0;
M4uPort.domain = 0;
M4uPort.Distance = 1;
M4uPort.Direction = 0;
CM4u.m4u_config_port(&M4uPort);
M4uPort.ePortID = M4U_PORT_WDMA0;
M4uPort.Virtuality = 1;
M4uPort.Security = 0;
M4uPort.domain = 0;
M4uPort.Distance = 1;
M4uPort.Direction = 0;
CM4u.m4u_config_port(&M4uPort);
// allocate MVA buffer for m4u module
CM4u.m4u_alloc_mva(M4U_CLNTMOD_ROT, // Module ID
(unsigned int)pSrc, // buffer virtual start address
srcsize, // buffer size
0,
cache_coherent,
&srcPa); // return MVA address
CM4u.m4u_dump_info(M4U_CLNTMOD_ROT);
CM4u.m4u_insert_tlb_range(M4U_CLNTMOD_ROT,
srcPa, srcPa+srcsize-1, SEQ_RANGE_LOW_PRIORITY, 1);
CM4u.m4u_alloc_mva(M4U_CLNTMOD_WDMA, // Module ID
(unsigned int)pDst, // buffer virtual start address
dstsize, // buffer size
0,
cache_coherent,
&dstPa); // return MVA address
CM4u.m4u_dump_info(M4U_CLNTMOD_WDMA);
CM4u.m4u_insert_tlb_range(M4U_CLNTMOD_WDMA,
dstPa, dstPa+dstsize-1, SEQ_RANGE_LOW_PRIORITY, 1);
//srcPa = 0x5000;
//dstPa = 0x2000;
printf("psrc=0x%x, srcPa=0x%x, pDst=0x%x, disPa=0x%x\n", pSrc, srcPa, pDst, dstPa);
#else
unsigned int srcPa = 0;
unsigned int dstPa = 0;
int src_ID, dst_ID;
pSrc = (unsigned char *) pmem_alloc(SRC_W*SRC_H*SRC_BPP , &src_ID);
srcPa = (unsigned int)pmem_get_phys(src_ID);
pDst = (unsigned char *) pmem_alloc(DST_W*DST_H*DST_BPP , &dst_ID);
dstPa = (unsigned int)pmem_get_phys(dst_ID);
printf("psrc=0x%x, srcPa=0x%x, pDst=0x%x, disPa=0x%x\n", pSrc, srcPa, pDst, dstPa);
#endif
CM4u.m4u_monitor_start(M4U_PORT_ROT_EXT);
if(pSrc==NULL || pDst==NULL)
{
printf("error: alloc mem fail! \n");
return 0;
}
memcpy(pSrc, rgb565_256x256, SRC_W*SRC_H*SRC_BPP);
memset(pDst, 0, DST_W*DST_H*DST_BPP);
printf("copy done\n");
int m4u_fd = open("/dev/M4U_device", O_RDWR);
unsigned int regbase;
regbase = (unsigned int)mmap((void*)0x50000000, 0x14000, (PROT_READ | PROT_WRITE | PROT_EXEC), MAP_SHARED, m4u_fd, 0x14000000);
if(regbase != 0x50000000)
{
printf("error to mmap register!! 0x%x\n", regbase);
printf("\n");
//while(1);
}
printf("mapped regbase = 0x%x, fd=%d\n", regbase, m4u_fd);
#ifdef __USE_M4U__
if(!cache_coherent)
{
//CM4u.m4u_cache_flush_all(M4U_CLNTMOD_ROT);
CM4u.m4u_cache_sync(M4U_CLNTMOD_ROT, M4U_CACHE_FLUSH_BEFORE_HW_READ_MEM,
(unsigned int)pSrc, srcsize);
CM4u.m4u_cache_sync(M4U_CLNTMOD_WDMA, M4U_CACHE_FLUSH_BEFORE_HW_WRITE_MEM,
(unsigned int)pDst, dstsize);
}
#endif
disp_subsys_reg_base_init(regbase);
printf("-1\n");
// config path
int module_list[] = {DISP_ROT, DISP_SCL, DISP_WDMA0};
// get mutex
disp_mutex_lock(0, module_list, 3, SINGLE_MODE);
printf("0\n");
// set path
disp_set_path(module_list, 3);
printf("1\n");
DpConfiguration dc;
DpCommandRecorder cr;
dc.w = SRC_W;
dc.h = SRC_H;
dc.scalingW = DST_W;
dc.scalingH = DST_H;
dc.roi.x = 0;
dc.roi.y = 0;
dc.roi.w = SRC_W;
dc.roi.h = SRC_H;
dc.enDither = false;
dc.enTTD = false;
dc.enBLS = false;
dc.addr[0] = srcPa;
//dc.addr[1] = 0;
//dc.addr[2] = 0;
dc.inFormat = SRC_FORMAT;
dc.outFormat = eFMT_YUV_444_1P;//DST_FORMAT;
dc.enSrcPitch = false;
dc.srcPitch = 0;
dc.enDstPitch = false;
dc.dstPitch = 0;
dc.rot = ROT_DEGREE_0;
dc.flip = ROT_FLIP_DISABLE;
dc.interlaced = false;
dc.fieldID = 0;
printf("2\n");
// 2. define DDP engines
//DpEngine *pRot = DpEngine::Factory(tROT);
DpEngine_ROT *pRot = new DpEngine_ROT;
DpEngine_SCL *pScl = new DpEngine_SCL;
DpEngine_WDMA *pWdma0 = new DpEngine_WDMA(0);
printf("3\n");
// 3. config DDP engines
DpCommandRecorder cmdRecord;
pRot->onReset(cmdRecord);
pRot->onConfig(dc,cmdRecord);
pRot->onEnable(cmdRecord);
dc.inFormat = eFMT_YUV_444_1P;
dc.outFormat = eFMT_YUV_444_1P;//DST_FORMAT;
pScl->onReset(cmdRecord);
pScl->onConfig(dc,cmdRecord);
pScl->onEnable(cmdRecord);
printf("4\n");
dc.addr[0] = dstPa;
dc.inFormat = eFMT_YUV_444_1P;
dc.outFormat = DST_FORMAT;//DST_FORMAT;
pWdma0->onReset(cmdRecord);
pWdma0->onConfig(dc,cmdRecord);
pWdma0->onEnable(cmdRecord);
printf("5\n");
disp_mutex_unlock(0);
pWdma0->onWaitDone();
printf("engine finished\n");
#ifdef __USE_M4U__
CM4u.m4u_monitor_stop(M4U_PORT_ROT_EXT);
CM4u.m4u_invalid_tlb_range(M4U_CLNTMOD_WDMA,
dstPa, dstPa+dstsize-1);
CM4u.m4u_invalid_tlb_range(M4U_CLNTMOD_ROT,
srcPa, srcPa+srcsize-1);
CM4u.m4u_dealloc_mva(M4U_CLNTMOD_ROT, (unsigned int)pSrc, (unsigned int)srcsize, srcPa);
CM4u.m4u_dealloc_mva(M4U_CLNTMOD_WDMA, (unsigned int)pDst, (unsigned int)dstsize, dstPa);
#else
pmem_free(pSrc, srcsize, src_ID);
pmem_free(pDst, dstsize, dst_ID);
#endif
}
int main()
{
mHalBltParam_t stParam;
mHalImgPostProcess_t stImgPostParam;
unsigned int dst_size;
unsigned char *src_va;
unsigned char *dst_va;
int src_ID;
int dst_ID;
unsigned long src_pa;
unsigned long dst_pa;
//PMEM
// src_va = (unsigned char *) pmem_alloc_sync(BUFFER_SIZE , &src_ID);
// src_pa = (unsigned long)pmem_get_phys(src_ID);
src_va = (unsigned char *)malloc(BUFFER_SIZE);
xlog("Source VA is : %d\n" , src_va);
if(src_va == NULL)
{
xlog("Can not allocate memory\n");
return -1;
}
dst_size = (OUTW*OUTH*4);
// dst_va = (unsigned char *) pmem_alloc_sync(dst_size , &dst_ID);
// dst_pa = (unsigned long)pmem_get_phys(dst_ID);
dst_va = (unsigned char *)malloc(dst_size);
xlog("Dest VA is : %d\n" , dst_va);
memset(dst_va , 0 , dst_size);
FILE *fp;
unsigned long index;
fp = fopen("/data/Before.raw", "r");
fread(src_va , 1 , BUFFER_SIZE , fp);
fclose(fp);
//
//memset(src_va , 0 , BUFFER_SIZE);
memset(&stParam, 0, sizeof(stParam));
stParam.srcX = 0;
stParam.srcY = 0;
stParam.srcW = 720; //106
stParam.srcWStride = 720; //112
stParam.srcH = 480; //200
stParam.srcHStride = 480; //208
stParam.srcAddr = (MUINT32)(src_va);//TODO
stParam.srcFormat = MHAL_FORMAT_ARGB_8888;
stParam.dstW = 720;//479
stParam.dstH = 480;//254
stParam.dstAddr = (MUINT32)dst_va;
stParam.dstFormat = MHAL_FORMAT_ARGB_8888;//TODO
stParam.pitch = 720;// 479
stParam.orientation = 0;// 1
stImgPostParam.srcX = 0;
stImgPostParam.srcY = 0;
stImgPostParam.srcW = 3200;
stImgPostParam.srcWStride = 3200;
stImgPostParam.srcH = 2400;
stImgPostParam.srcHStride = 2400;
stImgPostParam.srcAddr = (unsigned long)src_va;
stImgPostParam.srcFormat = MHAL_FORMAT_YUY2;
stImgPostParam.dstX = 0;
stImgPostParam.dstY = 0;
stImgPostParam.dstW = 3200;
stImgPostParam.dstWStride = 3200;
stImgPostParam.dstH = 2400;
stImgPostParam.dstAddr = (unsigned long)dst_va;
stImgPostParam.dstFormat = MHAL_FORMAT_YUY2;
stImgPostParam.orientation = 0;
struct timeval t1 , t2;
gettimeofday(&t1,NULL);
if(MHAL_NO_ERROR != mHalBitblt((void *)&stParam))
// if(MHAL_NO_ERROR != mHal_ImagePostProcess(&stImgPostParam))
{
xlog("Test failed!!");
}
else
{
gettimeofday(&t2,NULL);
xlog("Time cost : %d" , (t2.tv_sec - t1.tv_sec)*1000000 + (t2.tv_usec - t1.tv_usec));
xlog("Test success!!");
}
//Save
#if 1
//sprintf(filename , "/data/ttt%d.raw" , index2);
// fp = fopen(filename, "w");
fp = fopen("/data/ttt.raw", "w");
for(index = 0 ; index < dst_size ; index++)
{
fprintf(fp, "%c", dst_va[index]);
}
fclose(fp);
#endif
// free(src_va);
// free(dst_va);
pmem_free(src_va , BUFFER_SIZE , src_ID);
pmem_free(dst_va , dst_size , dst_ID);
return 0;
}
