/* ARGSUSED - this line tells the compiler not to warn about unused args. */
IRES_Status IRES_ALGORITHM_initResources(IALG_Handle handle,
IRES_ResourceDescriptor * resourceDescriptor, IRES_YieldFxn yieldFxn,
IRES_YieldArgs yieldArgs)
{
Int i = 0;
Int j = 0;
unsigned int addr;
unsigned int numBufs;
IRES_VICP2_Handle res;
DUMRES_TI_Handle algHandle = (DUMRES_TI_Handle)handle;
#ifdef xdc_target__os_Linux
unsigned int tempAddr = 0x0;
CMEM_init();
#endif
/* Store information about resources received in the alg handle */
for (i = 0; i < NUM_RESOURCES; i++) {
res = ((IRES_VICP2_Handle)resourceDescriptor[i].handle);
algHandle->resourceState[i] = 0;
algHandle->resourceHandles[i] = res;
for (j = 0; j < IRES_VICP2_NUMBUFFERS; j++) {
addr = res->assignedIMCOPBuffers[j];
/* An address of 0xFFFFFFFF is equivalent to a buffer not granted */
if (addr != 0xFFFFFFFF) {
printf("Resource #%d: VICP2 Buffer #%d: Addr 0x%x\n",i,j,addr);
#ifdef xdc_target__os_Linux
tempAddr = (unsigned long)CMEM_getPhys((void *)addr);
printf("Resource #%d: VICP2 Buffer #%d: PHY Addr 0x%x\n",i,j,
tempAddr);
#endif
}
}
numBufs = res->numMemBufs;
for (j = 0; j < numBufs; j++) {
printf("Resource #%d: Mem Buffer #%d: Addr 0x%x Size 0x%x\n", i, j,
res->assignedMemAddrs[j], res->assignedMemSizes[j]);
#ifdef xdc_target__os_Linux
tempAddr = (unsigned long) CMEM_getPhys((void *)
(res->assignedMemAddrs[j]));
printf("Resource #%d: VICP2 Buffer #%d: PHY Addr 0x%x\n",
i,j, tempAddr);
#endif
}
}
#ifdef xdc_target__os_Linux
CMEM_exit();
#endif
return (IRES_OK);
}
/*******************************************************************************
* allocate_user_buffers() allocate buffer using CMEM
******************************************************************************/
int allocate_user_buffers(void)
{
void *pool;
int i;
CMEM_AllocParams alloc_params;
printf("calling cmem utilities for allocating frame buffers\n");
CMEM_init();
alloc_params.type = CMEM_POOL;
alloc_params.flags = CMEM_NONCACHED;
alloc_params.alignment = 32;
pool = CMEM_allocPool(0, &alloc_params);
if (NULL == pool) {
printf("Failed to allocate cmem pool\n");
return -1;
}
printf("Allocating capture buffers :buf size = %d \n", buf_size);
for (i=0; i < APP_NUM_BUFS/2; i++) {
capture_buffers[i].user_addr = CMEM_alloc(buf_size, &alloc_params);
if (capture_buffers[i].user_addr) {
capture_buffers[i].phy_addr = CMEM_getPhys(capture_buffers[i].user_addr);
if (0 == capture_buffers[i].phy_addr) {
printf("Failed to get phy cmem buffer address\n");
return -1;
}
} else {
printf("Failed to allocate cmem buffer\n");
return -1;
}
printf("Got %p from CMEM, phy = %p\n", capture_buffers[i].user_addr,
(void *)capture_buffers[i].phy_addr);
}
printf("Allocating display buffers :buf size = %d \n", buf_size);
for (i=0; i < APP_NUM_BUFS/2; i++) {
display_buffers[i].user_addr = CMEM_alloc(buf_size, &alloc_params);
if (display_buffers[i].user_addr) {
display_buffers[i].phy_addr = CMEM_getPhys(display_buffers[i].user_addr);
if (0 == display_buffers[i].phy_addr) {
printf("Failed to get phy cmem buffer address\n");
return -1;
}
} else {
printf("Failed to allocate cmem buffer\n");
return -1;
}
printf("Got %p from CMEM, phy = %p\n", display_buffers[i].user_addr,
(void *)display_buffers[i].phy_addr);
}
return 0;
}
/**
* @brief Memory manager initialization
* @param "MEM_MNG_INFO *pInfo"
* @return 0 : success ; -1 : fail
*/
int MemMng_Init( MEM_MNG_INFO *pInfo )
{
int mem_layout = pInfo->mem_layout;
memset( pInfo, 0 , sizeof(MEM_MNG_INFO) );
pInfo->totalsize = MemMng_Mem_layout(mem_layout);
pInfo->start_addr = (unsigned long)STREAM_CMEM_ALLOC(pInfo->totalsize, 32);
if( pInfo->start_addr == 0 )
goto MEM_INIT_FAIL;
pInfo->start_phyAddr = CMEM_getPhys((void *)pInfo->start_addr);
if(pInfo->start_phyAddr == 0)
fprintf(stderr, "Failed to get physical address of %#x\n",
(unsigned int) pInfo->start_phyAddr);
pInfo->freesize = pInfo->totalsize;
pInfo->offset = 0;
pInfo->video_info_nums = 0;
if(Video_Mem_Malloc( pInfo )==0)
__D(" MEM_INIT Success \n");
else
return -1;
MemMng_memcpy_open();
return 0;
MEM_INIT_FAIL:
__E(" MEM_INIT_FAIL \n");
return -1;
}
/* ARGSUSED - this line tells the compiler not to warn about unused args. */
Int DUMALG_TI_useHDVICP(IDUMALG_Handle handle, unsigned int Id)
{
Int i;
DUMALG_TI_Obj * dumalg = (DUMALG_TI_Handle)handle;
IRES_HDVICP_Handle hdvicp = NULL;
if (dumalg->yieldFlag) {
for (i = 0; i < NUM_RESOURCES; i++) {
GT_2trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS,
"_DUMALG_TI_useHDVICP> Task #%d: Yielding HDVICP resource "
"%d\n", Id, (Int)(dumalg->hdvicp[i]));
}
/* Yield resource now */
dumalg->yieldFxn((IRES_YieldResourceType)IRES_ALL,&dumalg->yieldContext,
dumalg->yieldArgs);
for (i = 0; i < NUM_RESOURCES; i++) {
GT_2trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS,
"_DUMALG_TI_useHDVICP> Task #%d: HDVICP resource %d "
"re-acquired\n", Id, (Int)(dumalg->hdvicp[i]));
}
}
else {
/* Alg doesn't yield the resource */
#ifdef xdc_target__os_Linux
CMEM_init();
#endif
for (i = 0; i < NUM_RESOURCES; i++) {
hdvicp = dumalg->resourceHandles[i];
GT_2trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS,
"_DUMALG_TI_useHDVICP> Task #%d: Not yielding HDVICP "
"resource %d\n", Id, (Int)(hdvicp->id));
#ifdef xdc_target__os_Linux
GT_3trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS,
"_DUMALG_TI_useHDVICP> Register space address 0x%x, Memory "
"base address 0x%x, Phy register base address 0x%x\n",
(unsigned int)(hdvicp->registerBaseAddress),
(unsigned int)(hdvicp->memoryBaseAddress),
(void *) CMEM_getPhys((void *)
(hdvicp->registerBaseAddress)));
#endif
}
#ifdef xdc_target__os_Linux
CMEM_exit();
#endif
}
return 0;
}
/*
* ======== SCPY_configure ========
* Configure a transfer on the SDMA handle
*/
void SCPY_configure(IRES_SDMA_Handle handle, SCPY_Params * params)
{
/* SCPY_configure should be called with only one logicalChannel */
int logicalChannel = handle->channel->chanNum;
unsigned int dmaAddr = (unsigned int)(handle->channel->addr);
CMEM_init();
omap_set_dma_transfer_params(logicalChannel, dmaAddr,
params->transfer->dataType, params->transfer->elemCount,
params->transfer->frameCount);
omap_set_dma_src_params(logicalChannel, dmaAddr,
params->src->addr_mode, CMEM_getPhys((void *)(params->src->addr)),
params->src->elem_index, params->src->frame_index);
omap_set_dma_dest_params(logicalChannel, dmaAddr,
params->dst->addr_mode, CMEM_getPhys((void *)(params->dst->addr)),
params->dst->elem_index, params->dst->frame_index);
CMEM_exit();
}
int DM365MM_memcpy (void *dst, void *src, unsigned int srcwidth,unsigned int width,
unsigned int height, unsigned int dstwidth)
{
edma_params edmaparams;
// printf("CPY");
if (dm365mm_fd == -1)
{
__E ("memcpy: You must initialize DM365MM before making API calls.\n");
return -1;
}
// printf("src = %x,dst = %x srcwidth= %d src height= %d dstwidth= %d\n",src,dst,srcwidth,height,dstwidth);
edmaparams.srcmode = 0; //INC mode
edmaparams.srcfifowidth = 0; //Don't care
edmaparams.srcbidx = srcwidth;
edmaparams.srccidx = srcwidth * height;
edmaparams.dstmode = 0; //INC mode
edmaparams.dstfifowidth = 0; //Don't care
edmaparams.dstbidx = dstwidth;
edmaparams.dstcidx = dstwidth * height;
edmaparams.src = CMEM_getPhys (src);
edmaparams.dst = CMEM_getPhys (dst);
// edmaparams.src = Memory_getBufferPhysicalAddress (src,srcwidth * height);
// edmaparams.dst = Memory_getBufferPhysicalAddress (dst,dstwidth * height);
edmaparams.acnt = width;// Anand 1215 srcwidth;
edmaparams.bcnt = height;
edmaparams.ccnt = 1;
edmaparams.bcntrld = height; //important setting
edmaparams.syncmode = 1; //AB-Sync
if (ioctl (dm365mm_fd, DM365MMAP_IOCMEMCPY, &edmaparams) == -1)
{
__E ("memcpy: Failed to do memcpy\n");
return -1;
}
return 0;
}
void common_create_native_pixmap(
unsigned long pixmapFormat,
unsigned long pixmapwidth,
unsigned long pixmapHeight,
NATIVE_PIXMAP_STRUCT **pNativePixmapPtr
)
{
#ifdef _ENABLE_CMEM
//The cmem module should be inserted before running this application
//Create a contiguous buffer of required size for texture, and get userspace address
*pNativePixmapPtr = (NATIVE_PIXMAP_STRUCT*)malloc(sizeof(NATIVE_PIXMAP_STRUCT));
if(pixmapFormat == SGXPERF_RGB565)
(*pNativePixmapPtr)->ePixelFormat = 0;
else if(pixmapFormat == SGXPERF_ARGB8888)
(*pNativePixmapPtr)->ePixelFormat = 2;
else
{
SGXPERF_ERR_printf("Invalid pixmap format type %ld\n", pixmapFormat);
exit(-1);
}
(*pNativePixmapPtr)->eRotation = 0;
(*pNativePixmapPtr)->lWidth = pixmapwidth;//480;
(*pNativePixmapPtr)->lHeight = pixmapHeight;//640;
if(pixmapFormat == SGXPERF_RGB565)
(*pNativePixmapPtr)->lStride = (*pNativePixmapPtr)->lWidth* 16/8; //bitwidth/8
else if(pixmapFormat == SGXPERF_ARGB8888)
(*pNativePixmapPtr)->lStride = (*pNativePixmapPtr)->lWidth* 32/8; //bitwidth/8
(*pNativePixmapPtr)->lSizeInBytes = (*pNativePixmapPtr)->lHeight * (*pNativePixmapPtr)->lStride;
(*pNativePixmapPtr)->lAddress = (long) CMEM_alloc((*pNativePixmapPtr)->lSizeInBytes, NULL);
if(!(*pNativePixmapPtr)->lAddress)
{
SGXPERF_ERR_printf("CMEM_alloc returned NULL\n");
exit(-1);
}
//Get the physical page corresponding to the above cmem buffer
(*pNativePixmapPtr)->pvAddress = CMEM_getPhys((void*)(*pNativePixmapPtr)->lAddress);
SGXPERF_printf("Physical address = %x\n", (*pNativePixmapPtr)->pvAddress);
if((*pNativePixmapPtr)->pvAddress & 0xFFF)
SGXPERF_printf("PVR2DMemWrap may have issues with this non-aligned address!\n");
#endif
}
/*
* ======== MEMUTILS_getPhysicalAddr ========
* Converts user virtual address to physical address,
* Returns 0 on failure, physical address on success.
*/
Void * MEMUTILS_getPhysicalAddr(Ptr addr)
{
UInt32 physicalAddress = 0;
if (!regInit) {
addModule();
}
CMEM_init();
physicalAddress = CMEM_getPhys(addr);
Log_print2(Diags_USER1, "[+1] MEMUTILS_getPhysicalAddr> "
"CMEM_getPhys(0x%x) = 0x%x.", (IArg)addr, (IArg)physicalAddress);
Log_print1(Diags_ENTRY, "[+E] MEMUTILS_getPhysicalAddr> return (0x%x)",
(IArg)physicalAddress);
CMEM_exit();
return ((Void *)physicalAddress);
}
/**
* @brief Memory manager initialization
* @param "MEM_MNG_INFO *pInfo"
* @return 0 : success ; -1 : fail
*/
int MemMng_Init( MEM_MNG_INFO *pInfo )
{
#ifdef VANLINK_DVR_DM365_DEBUG //add by sxh
OSA_printf("----vl MemMng_Init Enter!!\n");
#endif
int mem_layout = pInfo->mem_layout;
memset( pInfo, 0 , sizeof(MEM_MNG_INFO) );
pInfo->totalsize = MemMng_Mem_layout(mem_layout);
pInfo->start_addr = (unsigned long)OSA_cmemAlloc( pInfo->totalsize, 32);
if( pInfo->start_addr == 0 )
goto MEM_INIT_FAIL;
pInfo->start_phyAddr = CMEM_getPhys((void *)pInfo->start_addr);
if(pInfo->start_phyAddr == 0)
fprintf(stderr, "Failed to get physical address of %#x\n",
(unsigned int) pInfo->start_phyAddr);
pInfo->freesize = pInfo->totalsize;
pInfo->offset = 0;
pInfo->video_info_nums = 0;
if(Video_Mem_Malloc( pInfo )==0)
__D(" MEM_INIT Success \n");
else
return -1;
MemMng_memcpy_open();
#ifdef VANLINK_DVR_DM365_DEBUG //add by sxh
OSA_printf("----vl MemMng_Init Enter!!\n");
#endif
return 0;
MEM_INIT_FAIL:
__E(" MEM_INIT_FAIL \n");
return -1;
}
main()
{
void *pool;
int i;
CMEM_AllocParams alloc_params;
printf("calling cmem utilities\n");
CMEM_init();
alloc_params.type = CMEM_POOL;
alloc_params.flags = CMEM_NONCACHED;
alloc_params.alignment = 32;
pool = CMEM_allocPool(0, &alloc_params);
if (NULL == pool) {
printf("Failed to allocate cmem pool\n");
exit(1);
}
for (i=0; i < NUM_BUFFERS; i++) {
buffers[i].user_addr = CMEM_alloc(BUF_SIZE, &alloc_params);
if (buffers[i].user_addr) {
buffers[i].phy_addr = CMEM_getPhys(buffers[i].user_addr);
if (0 == buffers[i].phy_addr) {
printf("Failed to get phy cmem buffer address\n");
exit(1);
}
} else {
printf("Failed to allocate cmem buffer\n");
exit(1);
}
printf("Got %p from CMEM, phy = %p\n", buffers[i].user_addr,
(void *)buffers[i].phy_addr);
}
printf("exiting \n");
}
/*******************************************************************************
* allocate_user_buffers() allocate buffer using CMEM
******************************************************************************/
int allocate_user_buffers(void)
{
void *pool;
int i;
CMEM_AllocParams alloc_params;
printf("calling cmem utilities for allocating frame buffers\n");
CMEM_init();
alloc_params.type = CMEM_POOL;
alloc_params.flags = CMEM_NONCACHED;
alloc_params.alignment = 32;
pool = CMEM_allocPool(0, &alloc_params);
if (NULL == pool) {
printf("Failed to allocate cmem pool\n");
return -1;
}
printf("the buf size = %d \n", buf_size);
for (i=0; i < MIN_BUFFERS; i++) {
user_io_buffers[i].user_addr = CMEM_alloc(buf_size, &alloc_params);
if (user_io_buffers[i].user_addr) {
user_io_buffers[i].phy_addr = CMEM_getPhys(user_io_buffers[i].user_addr);
if (0 == user_io_buffers[i].phy_addr) {
printf("Failed to get phy cmem buffer address\n");
return -1;
}
} else {
printf("Failed to allocate cmem buffer\n");
return -1;
}
printf("Got %p from CMEM, phy = %p\n", user_io_buffers[i].user_addr,
(void *)user_io_buffers[i].phy_addr);
}
return 0;
}
/*
* ======== MEMUTILS_getPhysicalAddr ========
* Converts user virtual address to physical address,
* Returns 0 on failure, physical address on success.
*/
Void * MEMUTILS_getPhysicalAddr(Ptr addr)
{
UInt32 physicalAddress = 0;
#if GT_TRACE
if (!(gtInit)) {
GT_init();
GT_create(&curTrace, "ti.sdo.fc.memutils");
gtInit = 1;
}
#endif
CMEM_init();
physicalAddress = CMEM_getPhys(addr);
GT_2trace(curTrace, GT_1CLASS, "MEMUTILS_getPhysicalAddr> "
"CMEM_getPhys(0x%x) = 0x%x.\n", addr, physicalAddress);
GT_1trace(curTrace, GT_ENTER, "MEMUTILS_getPhysicalAddr> "
"return (0x%x)\n", physicalAddress);
CMEM_exit();
return ((Void *)physicalAddress);
}
Capture_Handle Capture_init(CaptureAttr *attr)
{
Capture_Handle phandle = NULL;
CaptureBuffer *capBufs = NULL;
struct v4l2_capability cap;
struct v4l2_format fmt;
struct v4l2_fmtdesc fmtdesc;
struct v4l2_streamparm setfps;
struct v4l2_requestbuffers req;
struct v4l2_buffer *v4l2buf = NULL;
struct v4l2_input input;
struct v4l2_standard std;
v4l2_std_id id;
enum v4l2_buf_type type;
int BufNum;
int userAlloc;
int ret = 0;
int index;
int queryinput = 0;
unsigned int bufindex = 0;
unsigned int failCount = 0;
if(attr == NULL)
{
SYS_WARNING("The CaptureAttr is null, use default attr.\r\n");
SYS_WARNING("BufNum is %d, userAlloc is %s.\r\n", CAP_BUF_NUM, "false");
BufNum = CAP_BUF_NUM;
userAlloc = 0;
}
else
{
if(attr->bufNum <=0 || attr->bufNum >=10)
{
SYS_ERROR("attr->bufNum %d is not legal, use default attr\r\n",attr->bufNum);
BufNum = CAP_BUF_NUM;
userAlloc = attr->userAlloc;
}
else
{
BufNum = attr->bufNum;
userAlloc = attr->userAlloc;
}
}
phandle = malloc(sizeof(Capture_Object));
if(phandle == NULL)
{
SYS_ERROR("malloc Capture_Object failed.\r\n");
goto error;
}
phandle->capture_fd = open(VIDEO_DEVICE, O_RDWR);
if (phandle->capture_fd <= 0)
{
SYS_ERROR("open device /dev/video0 failed.\r\n");
goto error;
}
if (ioctl(phandle->capture_fd, VIDIOC_G_INPUT, &index) < 0)
{
SYS_ERROR("VIDIOC_G_INPUT failed.\r\n");
goto error;
}
//SYS_INFO("VIdeoc_G_Input index = %d.\r\n", index);
for (index=0;; index++) {
input.index = index;
if (ioctl(phandle->capture_fd, VIDIOC_ENUMINPUT, &input) < 0) {
//SYS_ERROR("VIDIOC_ENUMINPUT failed\r\n");
break;
}
//SYS_INFO(" name=%s, index = %d\n", input.name, index);
}
#if 0
index = 0;
if (ioctl(phandle->capture_fd, VIDIOC_S_INPUT, &index) < 0) {
SYS_ERROR("Failed VIDIOC_S_INPUT to index %d \n",
index);
goto error;
}
#endif
for (index=0;; index++) {
std.frameperiod.numerator = 1;
std.frameperiod.denominator = 0;
std.index = index;
if (ioctl(phandle->capture_fd, VIDIOC_ENUMSTD, &std) < 0) {
break;
}
//SYS_INFO(" name=%s, fps=%d/%d\n", std.name,
//std.frameperiod.denominator, std.frameperiod.numerator);
}
/* Detect the standard in the input detected */
#if 0
if (ioctl(phandle->capture_fd, VIDIOC_QUERYSTD, &id) < 0) {
SYS_ERROR("VIDIOC_QUERYSTD failed\r\n");
goto error;
}
#endif
/* Get current video standard */
if (ioctl(phandle->capture_fd, VIDIOC_G_STD, &id) < 0) {
SYS_ERROR("Failed VIDIOC_G_STD\n");
goto error;
}
if (id & V4L2_STD_NTSC) {
//SYS_INFO("in ntsc................\r\n");
}
else if (id & V4L2_STD_PAL) {
//SYS_INFO("in pal................\r\n");
}
else if (id & V4L2_STD_525_60) {
//SYS_INFO("Found 525_60 std input\n");
}
else if (id & V4L2_STD_625_50) {
//SYS_INFO("Found 625_50 std input\n");
}
else {
SYS_ERROR("Unknown video standard on capture device \n");
}
if(ioctl(phandle->capture_fd, VIDIOC_QUERYCAP, &cap) == -1)
{
SYS_ERROR("Error opening device %s: unable to query device.\r\n", VIDEO_DEVICE);
goto error;
}
else
{
//SYS_INFO("driver:\t\t%s\n",cap.driver);
//SYS_INFO("card:\t\t%s\n",cap.card);
//SYS_INFO("bus_info:\t%s\n",cap.bus_info);
//SYS_INFO("version:\t%d\n",cap.version);
//SYS_INFO("capabilities:\t%x\n",cap.capabilities);
if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == V4L2_CAP_VIDEO_CAPTURE)
{
//SYS_INFO("Device %s: supports capture.\n",VIDEO_DEVICE);
}
if ((cap.capabilities & V4L2_CAP_STREAMING) == V4L2_CAP_STREAMING)
{
//SYS_INFO("Device %s: supports streaming.\n",VIDEO_DEVICE);
}
}
#if 0
//emu all support fmt
fmtdesc.index = 0;
fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
//SYS_INFO("Support format:\n");
while(ioctl(phandle->capture_fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
{
//SYS_INFO("\t%d.%s\n",fmtdesc.index+1,fmtdesc.description);
fmtdesc.index++;
}
#endif
//set fmt
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
fmt.fmt.pix.height = HEIGHT;
fmt.fmt.pix.width = WIDTH;
fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
fmt.fmt.pix.bytesperline = WIDTH * 2;
if(ioctl(phandle->capture_fd, VIDIOC_S_FMT, &fmt) == -1)
{
SYS_ERROR("Unable to set format.1\n");
goto error;
}
if(ioctl(phandle->capture_fd, VIDIOC_G_FMT, &fmt) == -1)
{
SYS_ERROR("Unable to get format\n");
goto error;
}
{
//SYS_INFO("fmt.type:\t\t%d\n",fmt.type);
//SYS_INFO("pix.pixelformat:\t%c%c%c%c\n",fmt.fmt.pix.pixelformat & 0xFF, (fmt.fmt.pix.pixelformat >> 8) & 0xFF,(fmt.fmt.pix.pixelformat >> 16) & 0xFF, (fmt.fmt.pix.pixelformat >> 24) & 0xFF);
//SYS_INFO("..........pix.height:\t\t%d\n",fmt.fmt.pix.height);
//SYS_INFO("............pix.width:\t\t%d\n",fmt.fmt.pix.width);
//SYS_INFO("..........pix.field:\t\t%d\n",fmt.fmt.pix.field);
}
//set fps
setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
setfps.parm.capture.timeperframe.numerator = 10;
setfps.parm.capture.timeperframe.denominator = 10;
//SYS_INFO("init %s \t[OK]\n",VIDEO_DEVICE);
if(!userAlloc)
{
//SYS_INFO("Driver alloc the capture buffer. BufNum = %d\r\n", BufNum);
phandle->userAlloc = 0;
memset(&req, 0x00, sizeof(req));
req.count = BufNum;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
if (ioctl(phandle->capture_fd, VIDIOC_REQBUFS, &req) < 0 )
{
SYS_ERROR("VIDIOC_REQDQBUFS failed.\r\n");
goto error;
}
if (req.count < BufNum)
{
if(!req.count)
{
SYS_ERROR("req.count is 0.\r\n", req.count);
goto error;
}
else
{
SYS_WARNING("req.count = %d < %d\r\n", req.count, BufNum);
}
}
capBufs = calloc(req.count, sizeof(CaptureBuffer));
v4l2buf = calloc(req.count, sizeof(struct v4l2_buffer));
if (capBufs == NULL || v4l2buf == NULL)
{
SYS_ERROR("malloc capbufs failed.\r\n");
goto error;
}
for(bufindex = 0; bufindex < req.count; bufindex++)
{
memset(&v4l2buf[bufindex], 0x00, sizeof(struct v4l2_buffer));
v4l2buf[bufindex].type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
v4l2buf[bufindex].memory = V4L2_MEMORY_MMAP;
v4l2buf[bufindex].index = bufindex;
if (ioctl(phandle->capture_fd, VIDIOC_QUERYBUF, &v4l2buf[bufindex]) < 0)
{
SYS_ERROR("VIDIOC_QUERYBUF failed. index = %d.\r\n", bufindex);
goto error;
}
capBufs[bufindex].length = v4l2buf[bufindex].length;
capBufs[bufindex].physaddr = v4l2buf[bufindex].m.offset;
capBufs[bufindex].index = bufindex;
capBufs[bufindex].virtaddr = mmap(NULL, v4l2buf[bufindex].length, PROT_READ|PROT_WRITE, MAP_SHARED, phandle->capture_fd, v4l2buf[bufindex].m.offset);
//SYS_INFO("index %d length %d physaddr %x virtaddr %x.\r\n",
//bufindex,v4l2buf[bufindex].length, v4l2buf[bufindex].m.offset, capBufs[bufindex].virtaddr);
memset(capBufs[bufindex].virtaddr, 0x55, 720*480 );
if (capBufs[bufindex].virtaddr == MAP_FAILED)
{
SYS_ERROR("mmap failed. index = %d.\r\n", bufindex);
goto error;
}
if (ioctl(phandle->capture_fd, VIDIOC_QBUF, &v4l2buf[bufindex]) < 0 )
{
SYS_ERROR("VIDIOC_QBUF failed.\r\n");
goto error;
}
}
}
else
{
if(ioctl(phandle->capture_fd, VIDIOC_G_FMT, &fmt) == -1)
{
SYS_ERROR("Unable to get format\n");
goto error;
}
//SYS_INFO("User alloc the capture buffer.\r\n");
phandle->userAlloc = 1;
if(CMEM_init() < 0)
{
SYS_ERROR("CMEM_init error.\r\n");
goto error;
}
memset(&req, 0x00, sizeof(req));
req.count = BufNum;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_USERPTR;
if (ioctl(phandle->capture_fd, VIDIOC_REQBUFS, &req) < 0 )
{
SYS_ERROR("VIDIOC_REQDQBUFS failed.\r\n");
goto error;
}
if (req.count < BufNum)
{
if(!req.count)
{
SYS_ERROR("req.count is 0.\r\n", req.count);
goto error;
}
else
{
SYS_WARNING("req.count = %d < %d\r\n", req.count, BufNum);
}
}
capBufs = calloc(req.count, sizeof(CaptureBuffer));
v4l2buf = calloc(req.count, sizeof(struct v4l2_buffer));
if (capBufs == NULL || v4l2buf == NULL)
{
SYS_ERROR("malloc capbufs failed.\r\n");
goto error;
}
for(bufindex = 0; bufindex < req.count; bufindex++)
{
memset(&v4l2buf[bufindex], 0x00, sizeof(struct v4l2_buffer));
//char *data = CMEM_alloc((720*480*2 + 4*1024) & (~0xFFF), &cmem_param);
char *data = CMEM_alloc(831488, &cap_cmem_param);
if(data == NULL)
{
SYS_ERROR("CMEM_alloc error.");
goto error;
}
v4l2buf[bufindex].index = bufindex;
v4l2buf[bufindex].type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
v4l2buf[bufindex].memory = V4L2_MEMORY_USERPTR;
v4l2buf[bufindex].m.userptr = (int)data;
//v4l2buf[bufindex].length = (720*480*2 + 4*1024) & (~0xFFF);
v4l2buf[bufindex].length = 831488;
//int len = (720*480*2 + 4*1024) & (~0xFFF);
capBufs[bufindex].length = v4l2buf[bufindex].length;
capBufs[bufindex].physaddr = CMEM_getPhys(data);
capBufs[bufindex].index = v4l2buf[bufindex].index;
capBufs[bufindex].virtaddr = (void*)v4l2buf[bufindex].m.userptr;
////SYS_INFO("len %d\r\n",len);
//SYS_INFO("index %d length %d physaddr %x virtaddr %x.\r\n",
// bufindex,v4l2buf[bufindex].length, v4l2buf[bufindex].m.offset, capBufs[bufindex].virtaddr);
if (ioctl(phandle->capture_fd, VIDIOC_QBUF, &v4l2buf[bufindex]) < 0 )
{
SYS_ERROR("VIDIOC_QBUF failed.\r\n");
goto error;
}
}
}
type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
#if 1
if (ioctl(phandle->capture_fd, VIDIOC_STREAMON, &type) < 0 )
{
SYS_ERROR("stream on failed.\r\n");
goto error;
}
#endif
phandle->capBufsPtr = capBufs;
phandle->v4l2buf = v4l2buf;
phandle->capBufsNum = req.count;
return phandle;
error:
SYS_ERROR("Capture_init error.\r\n");
if(phandle != NULL)
{
if(phandle->capture_fd > 0)
{
close(phandle->capture_fd);
}
free(phandle);
}
if(capBufs != NULL)
{
free(capBufs);
}
return NULL;
}
bool GLPowerVRWidget::loadNewTexture(int vidIx)
{
bool texLoaded = false;
unsigned long currentVidBufferAddress = (unsigned long)CMEM_getPhys(this->m_vidPipelines[vidIx]->bufToVidDataStart(this->m_vidTextures[vidIx].buffer));
LOG(LOG_GL, Logger::Debug2, "vid %d, CMEM phys=%lx", vidIx, currentVidBufferAddress);
if(m_vidBufferAddressesSet.contains(false))
{
bool gotThisBuffer = false;
QVector<bc_buf_ptr_t>::iterator bufPtr;
for(bufPtr = m_vidBufferAddresses[vidIx].begin(); bufPtr != m_vidBufferAddresses[vidIx].end(); ++bufPtr)
{
if(bufPtr->pa == currentVidBufferAddress)
{
// Already recorded this buffer address
LOG(LOG_GL, Logger::Debug2, "vid %d, already saved phys addr %lx", vidIx, currentVidBufferAddress);
gotThisBuffer = true;
// If we've got the same buffer a second time,
// assume that means we have all the buffer addresses
m_vidBufferAddressesSet[vidIx] = true;
}
}
if(!gotThisBuffer)
{
// A new buffer has come through, record the details:
bc_buf_ptr_t bc_buf;
bc_buf.index = totalVidBuffers(); // Multiple buffers per possibly multiple videos
// Size parameter isn't actually used in the driver just yet but fill in anyway for
// future proofing:
switch(this->m_vidTextures[vidIx].colourFormat)
{
case ColFmt_I420:
bc_buf.size = this->m_vidTextures[vidIx].width * this->m_vidTextures[vidIx].height * 1.5f;
break;
case ColFmt_UYVY:
default:
bc_buf.size = this->m_vidTextures[vidIx].width * this->m_vidTextures[vidIx].height * 2;
break;
}
bc_buf.pa = currentVidBufferAddress;
LOG(LOG_GL, Logger::Debug1, "vid %d, saving bc_buf_ptr_t: index=%d, size=%d, pa=%lx",
vidIx, bc_buf.index, bc_buf.size, bc_buf.pa);
m_vidBufferAddresses[vidIx].push_back(bc_buf);
}
// Have we got all the buffer addresses we are waiting for, for all videos?
if(!m_vidBufferAddressesSet.contains(false))
{
LOG(LOG_GL, Logger::Debug1, "got all the bc_buf_ptr_t entries for all vids");
for(int currentVidIx = 0; currentVidIx < m_vidPipelines.size(); currentVidIx++)
{
// We now definitely have the size information needed to prep the driver:
bc_buf_params_t bufParams;
bufParams.count = m_vidBufferAddresses[currentVidIx].size();
bufParams.width = this->m_vidTextures[currentVidIx].width;
bufParams.height = this->m_vidTextures[currentVidIx].height;
bufParams.fourcc = COLFMT_TO_BC_FOURCC(this->m_vidPipelines[currentVidIx]->getColourFormat());
bufParams.type = BC_MEMORY_USERPTR;
LOG(LOG_GL, Logger::Debug1, "vid %d, calling BCIOREQ_BUFFERS, count=%d, fourCC=0x%08X, width=%d, height=%d, type=%d",
currentVidIx, bufParams.count, bufParams.fourcc, bufParams.width, bufParams.height, bufParams.type);
int retVal;
if((retVal = ioctl(m_bcFds[currentVidIx], BCIOREQ_BUFFERS, &bufParams)) != 0)
{
LOG(LOG_GL, Logger::Error, "ERROR: BCIOREQ_BUFFERS on fd %d failed, retVal=%d, errno=%d:%s",
m_bcFds[currentVidIx], retVal, errno, strerror(errno));
return false;
}
LOG(LOG_GL, Logger::Debug1, "vid %d, calling BCIOGET_BUFFERCOUNT", currentVidIx);
BCIO_package ioctlVar;
if (ioctl(m_bcFds[currentVidIx], BCIOGET_BUFFERCOUNT, &ioctlVar) != 0)
{
LOG(LOG_GL, Logger::Error, "ERROR: BCIOGET_BUFFERCOUNT failed");
return false;
}
if (ioctlVar.output == 0)
{
LOG(LOG_GL, Logger::Error, "ERROR: no texture buffers available");
return false;
}
for(bufPtr = m_vidBufferAddresses[currentVidIx].begin(); bufPtr != m_vidBufferAddresses[currentVidIx].end(); ++bufPtr)
{
if (ioctl(m_bcFds[currentVidIx], BCIOSET_BUFFERPHYADDR, bufPtr) != 0)
{
LOG(LOG_GL, Logger::Error, "ERROR: BCIOSET_BUFFERADDR[%d]: failed (0x%lx)",
bufPtr->index, bufPtr->pa);
}
}
}
printOpenGLError(__FILE__, __LINE__);
// Should be able to set up the GLES side now:
const GLubyte *imgDevName;
imgDevName = this->glGetTexDeviceIMG(vidIx);
printOpenGLError(__FILE__, __LINE__);
GLint numImgBufs, imgBufWidth, imgBufHeight, imgBufFmt;
this->glGetTexAttrIMG(vidIx, GL_TEXTURE_STREAM_DEVICE_NUM_BUFFERS_IMG, &numImgBufs);
this->glGetTexAttrIMG(vidIx, GL_TEXTURE_STREAM_DEVICE_WIDTH_IMG, &imgBufWidth);
this->glGetTexAttrIMG(vidIx, GL_TEXTURE_STREAM_DEVICE_HEIGHT_IMG, &imgBufHeight);
this->glGetTexAttrIMG(vidIx, GL_TEXTURE_STREAM_DEVICE_FORMAT_IMG, &imgBufFmt);
LOG(LOG_GL, Logger::Debug1, "GLES IMG attrs: dev name: %s, numbufs=%d, width=%d, height=%d, format=%d",
imgDevName, numImgBufs, imgBufWidth, imgBufHeight, imgBufFmt);
printOpenGLError(__FILE__, __LINE__);
/* do stuff from setup_shaders() in bc_cat example common.c code here */
glActiveTexture(GL_TEXTURE0);
for(int currentVidIx = 0; currentVidIx < m_vidPipelines.size(); currentVidIx++)
{
// Delete the single texture ID created in superclass,
// ready to create the pool of texture IDs for each video instead
glDeleteTextures (1, &m_vidTextures[currentVidIx].texId);
// Loop through all the buffers, link buf index to tex IDs:
QVector<bc_buf_ptr_t>::iterator bufPtr;
for(bufPtr = m_vidBufferAddresses[currentVidIx].begin(); bufPtr != m_vidBufferAddresses[currentVidIx].end(); ++bufPtr)
{
GLuint newTexId;
glGenTextures(1, &newTexId);
LOG(LOG_GL, Logger::Debug1, "calling glBindTexture texId=%d",
newTexId);
glBindTexture(GL_TEXTURE_STREAM_IMG, newTexId);
printOpenGLError(__FILE__, __LINE__);
LOG(LOG_GL, Logger::Debug1, "setting texture filters");
// specify filters
//glTexParameterf(GL_TEXTURE_STREAM_IMG, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexParameterf(GL_TEXTURE_STREAM_IMG, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// cmem examples use:
glTexParameterf(GL_TEXTURE_STREAM_IMG, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_STREAM_IMG, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
printOpenGLError(__FILE__, __LINE__);
// assign the buffer
LOG(LOG_GL, Logger::Debug1, "calling glTexBindStreamIMG buf index=%d", bufPtr->index);
glTexBindStreamIMG(vidIx, bufPtr->index);
printOpenGLError(__FILE__, __LINE__);
m_bcBufIxToTexId[bufPtr->index] = newTexId;
// When the loop exits, take last buffer captured for vid as active texture
this->m_vidTextures[currentVidIx].texId = newTexId;
}
}
texLoaded = true;
}
}
else
{
LOG(LOG_GL, Logger::Debug2, "vid %d, looking up bc_buf_ptr_t index for buf pa=%lx",
vidIx, currentVidBufferAddress);
bool bufAdrFound = false;
QVector<bc_buf_ptr_t>::iterator bufPtr;
for(bufPtr = m_vidBufferAddresses[vidIx].begin(); bufPtr != m_vidBufferAddresses[vidIx].end(); ++bufPtr)
{
if(bufPtr->pa == currentVidBufferAddress)
{
LOG(LOG_GL, Logger::Debug2, "vid %d, setting texture to bc_buf_ptr_t index %d, texId %d",
vidIx, bufPtr->index, m_bcBufIxToTexId[bufPtr->index]);
this->m_vidTextures[vidIx].texId = m_bcBufIxToTexId[bufPtr->index];
bufAdrFound = true;
break;
}
}
if(bufAdrFound)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_STREAM_IMG, this->m_vidTextures[vidIx].texId);
texLoaded = true;
}
else
{
LOG(LOG_GL, Logger::Error, "new vid buffer arrived after all expected buffers have been setup, pa=%lx",
currentVidBufferAddress);
}
}
return texLoaded;
}
/*
* ======== Memory_getBufferPhysicalAddress ========
* Converts user virtual address to physical address,
* but also verifies that the buffer is really contiguous
* and does some bookkeeping so that reverse mapping is possible.
* Returns 0 on failure, physical address on success.
* *isContiguous is set to TRUE or FALSE if isContiguous!=NULL.
*/
UInt32 Memory_getBufferPhysicalAddress(
Ptr virtualAddress, Int sizeInBytes, /* input */
Bool *isContiguous /* output */
)
{
UInt32 physicalAddress = 0;
UInt32 physicalAddressOfLastByte;
Lock_acquire(moduleLock);
Log_print2(Diags_ENTRY, "[+E] Memory_getBufferPhysicalAddress> "
"Enter(virtAddr=0x%x, size=0x%x)",
(IArg)virtualAddress, (IArg)sizeInBytes);
if (Memory_skipVirtualAddressTranslation == TRUE) {
if (isContiguous != NULL) {
*isContiguous = TRUE;
}
physicalAddress = (UInt32)virtualAddress;
goto Memory_getBufferPhysicalAddress_return;
}
if (sizeInBytes == 0) {
Log_print0(Diags_USER6, "[+6] Memory_getBufferPhysicalAddress> "
"invalid buffer size provided (0)");
/* Note that physicalAddress is already initialized to zero */
goto Memory_getBufferPhysicalAddress_return;
}
/* first try to find the buffer in our tables */
physicalAddress = getPhysicalAddress((UInt32)virtualAddress, sizeInBytes);
if (physicalAddress != 0) {
if (isContiguous != NULL) {
*isContiguous = TRUE;
}
}
else {
#if 0 /* TODO:M - should we re-enable this as a warning? */
/* [cr]TODO:H this is DaVinci specific; should the caller check it? */
/* Ensure the buffer destined for the DSP is cache aligned. */
if ((((UInt32)virtualAddress) & 0x7F) != 0) {
Log_print1(Diags_USER7, "[+7] Memory_getBufferPhysicalAddress> "
"ERROR: buffer (0x%x) is not cache aligned on 128 byte "
"boundary.", (IArg)virtualAddress);
Lock_release(moduleLock);
return (0);
}
#endif
/* ask CMEM to convert addresses of the first and the last byte */
physicalAddress = CMEM_getPhys(virtualAddress);
Log_print2(Diags_USER1, "[+1] Memory_getBufferPhysicalAddress> "
"CMEM_getPhys(0x%x) = 0x%x.",
(IArg)virtualAddress, (IArg)physicalAddress);
physicalAddressOfLastByte = CMEM_getPhys(
(Ptr)((UInt32)virtualAddress + sizeInBytes - 1));
if (physicalAddress != 0) {
if (physicalAddressOfLastByte == physicalAddress + sizeInBytes - 1)
{
if (isContiguous != NULL) {
*isContiguous = TRUE;
}
}
else {
if (isContiguous != NULL) {
*isContiguous = FALSE;
}
else {
Log_print2(Diags_USER7,
"[+7] Memory_getBufferPhysicalAddress> "
"ERROR: user buffer at addr=0x%x, size=0x%x "
"is NOT contiguous",
(IArg)virtualAddress, (IArg)sizeInBytes);
}
/* invalid buffer - it's not contiguous. */
physicalAddress = 0;
}
}
}
Memory_getBufferPhysicalAddress_return:
Log_print1(Diags_EXIT, "[+X] Memory_getBufferPhysicalAddress> "
"return (0x%x)", (IArg)physicalAddress);
Lock_release(moduleLock);
return (physicalAddress);
}
/*
* ======== contigAlloc ========
*/
static Ptr contigAlloc(UInt size, UInt align, Bool cacheable, Bool heap)
{
Ptr addr = NULL;
UInt32 physAddr;
CMEM_AllocParams cmemParams;
/* lock acquire should be after the trace, but it's unlikely to fail
* and we get a more consistent/less confusing output this way.
*/
Lock_acquire(moduleLock);
Log_print4(Diags_ENTRY, "[+E] Memory_contigAlloc> "
"Enter(size=0x%x, align=0x%x, cached=%s, heap=%s)", (IArg)size,
(IArg)align, (IArg)(cacheable ? "TRUE" : "FALSE"),
(IArg)(heap ? "TRUE" : "FALSE"));
if (!cmemInitialized) {
Log_print1(Diags_USER7, "[+7] Memory_contigAlloc> "
"ERROR: request for size=0x%x failed -- CMEM has not been "
"initialized.", (IArg)size);
goto contigAlloc_return;
}
if (!heap && (Int)align > CMEMPOOLALIGN) {
Log_print2(Diags_USER6, "[+6] Memory_contigAlloc> "
"Warning: alignment %#x not supported for pool-based allocations,"
" using fixed alignment %#x.",
(IArg)align, (IArg)CMEMPOOLALIGN);
/* align is not used for pool-based allocs, but set it anyway */
align = CMEMPOOLALIGN;
}
cmemParams.type = heap ? CMEM_HEAP : CMEM_POOL;
cmemParams.flags = cacheable ? CMEM_CACHED : CMEM_NONCACHED;
cmemParams.alignment = align;
addr = CMEM_alloc(size, &cmemParams);
Log_print2(Diags_USER4, "[+4] Memory_contigAlloc> CMEM_alloc(0x%x) = 0x%x.",
(IArg)size, (IArg)addr);
if (addr != NULL) {
/* since the allocation succeeded, get physical address now and add the
* description for this buffer in our list of contiguous buffers.
*/
physAddr = CMEM_getPhys(addr);
if (physAddr != 0) {
Log_print2(Diags_USER4, "[+4] Memory_contigAlloc> "
"CMEM_getPhys(0x%x) = 0x%x.", (IArg)addr, (IArg)physAddr);
addContigBuf((Uint32)addr, size, physAddr);
} else {
Log_print1(Diags_USER7, "[+7] Memory_contigAlloc> "
"ERROR: CMEM_getPhys(0x%x) (virt-to-phys) failed; "
"releasing the block.", (IArg)addr);
CMEM_free(addr, &cmemParams);
addr = NULL;
}
} else {
Log_print0(Diags_USER7, "[+7] Memory_contigAlloc> "
"ERROR: CMEM alloc failed");
}
contigAlloc_return:
Log_print1(Diags_EXIT, "[+X] Memory_contigAlloc> return (0x%x)",
(IArg)addr);
Lock_release(moduleLock);
return addr;
}
/* ARGSUSED - this line tells the compiler not to warn about unused args */
IRES_Status IRESMAN_MEMTCM_freeHandle(IALG_Handle algHandle, IRES_Handle
algResourceHandle, IRES_ProtocolArgs * protocolArgs,
Int scratchGroupId)
{
IALG_MemRec resourceMemRecs[1];
Int numMemRecs;
IRES_Status status = IRES_OK;
Int resourceId = -1;
unsigned int numResources = 0;
unsigned int addr = 0x0;
unsigned int size = 0x0;
Bool smg_status = FALSE;
GT_assert(CURTRACE, protocolArgs);
GT_assert(CURTRACE, algResourceHandle);
GT_3trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_freeHandles> Enter (handle=0x%x, "
"protocolArgs=0x%x, scratchGroupId=%d)\n", algResourceHandle,
protocolArgs, scratchGroupId);
if (_initialized != 1) {
status = IRES_ENORESOURCE;
GT_0trace(CURTRACE, GT_7CLASS,
"IRESMAN_MEMTCM_getHandles> RMAN register for MEMTCM "
"resource not happened successfully. Please call RMAN_register "
"before trying to assign or release resources\n");
return (status);
}
/*
* Obtain memory resources to free and free them
*/
numMemRecs = IRESMAN_MEMTCM_CONSTRUCTFXNS.getNumMemRecs
( (IRES_ProtocolArgs *)protocolArgs);
IRESMAN_MEMTCM_CONSTRUCTFXNS.getMemRecs((IRES_Handle)NULL,
(IRES_ProtocolArgs *) protocolArgs, resourceMemRecs);
/* Set Base address of Memory location to free */
resourceMemRecs[0].base = algResourceHandle;
/* Free other things allocated */
addr = CMEM_getPhys(((IRES_MEMTCM_Handle)algResourceHandle)->memAddr);
size = ((IRES_MEMTCM_Handle)algResourceHandle)->memSize;
resourceId = ((unsigned int)addr -
(unsigned int)_resmanInternalState->armtcmAddr)/MEMTCM_RESSIZE;
numResources = (size + (MEMTCM_RESSIZE -1))/MEMTCM_RESSIZE;
smg_status = SMGRMP_free(smgr, algHandle, resourceId, numResources,
scratchGroupId);
if (smg_status == FALSE) {
GT_1trace(CURTRACE, GT_7CLASS,
"IRESMAN_MEMTCM_freeHandles> Error trying to free "
"memory 0x%x\n",
((IRES_MEMTCM_Handle)algResourceHandle)->memAddr);
return (IRES_EFAIL);
}
/*
* Use IRES_MEMTCM_RESOURCEPROTOCOL to de-init the resource protocol
* if required
*/
IRESMAN_MEMTCM_CONSTRUCTFXNS.destructHandle(algResourceHandle);
/*
* Free the memory for the handles
*/
_freeFxn(resourceMemRecs, numMemRecs);
GT_0trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_freeHandles> Exit (status=IRES_OK)\n");
return (IRES_OK);
}
int clear_plane(int index,jpegdec_config_t *config)
{
int fd_ge2d=-1;
config_para_t ge2d_config;
int format;
ge2d_op_para_t op_para;
memset((char*)&ge2d_config,0,sizeof(config_para_t));
fd_ge2d= open(FILE_NAME_GE2D, O_RDWR);
if(fd_ge2d<0)
{
#ifdef JPEG_DBG
printf("can't open framebuffer device" );
#endif
goto exit;
}
format = Format_RGB32;
#ifdef JPEG_DBG
printf("start clean plane buffer %d!!!!!\n", index);
#endif
ge2d_config.src_dst_type = ALLOC_ALLOC;
// qCritical("planes[3]addr : 0x%x-0x%x" ,planes[3],ge2d_config.dst_planes[0].addr);
switch(index){
case 0:
op_para.color=0x008080ff;
ge2d_config.src_format = GE2D_FORMAT_S8_Y;
ge2d_config.dst_format = GE2D_FORMAT_S8_Y;
ge2d_config.dst_planes[0].addr = config->addr_y;
ge2d_config.dst_planes[0].w = config->canvas_width;
ge2d_config.dst_planes[0].h = config->dec_h;
op_para.src1_rect.x = config->dec_x;
op_para.src1_rect.y = config->dec_y;
op_para.src1_rect.w = config->dec_w;
op_para.src1_rect.h = config->dec_h;
op_para.dst_rect.x = config->dec_x;
op_para.dst_rect.y = config->dec_y;
op_para.dst_rect.w = config->dec_w;
op_para.dst_rect.h = config->dec_h;
break;
case 1:
op_para.color=0x008080ff;
ge2d_config.src_format = GE2D_FORMAT_S8_CB;
ge2d_config.dst_format = GE2D_FORMAT_S8_CB;
ge2d_config.dst_planes[0].addr = config->addr_u;
ge2d_config.dst_planes[0].w = config->canvas_width/2;
ge2d_config.dst_planes[0].h = config->dec_h / 2;
op_para.src1_rect.x = config->dec_x/2;
op_para.src1_rect.y = config->dec_y/2;
op_para.src1_rect.w = config->dec_w/2;
op_para.src1_rect.h = config->dec_h/2;
op_para.dst_rect.x = config->dec_x/2;
op_para.dst_rect.y = config->dec_y/2;
op_para.dst_rect.w = config->dec_w/2;
op_para.dst_rect.h = config->dec_h/2;
break;
case 2:
op_para.color=0x008080ff;
ge2d_config.src_format = GE2D_FORMAT_S8_CR;
ge2d_config.dst_format = GE2D_FORMAT_S8_CR;
ge2d_config.dst_planes[0].addr = config->addr_v;
ge2d_config.dst_planes[0].w = config->canvas_width/2;
ge2d_config.dst_planes[0].h = config->dec_h / 2;
op_para.src1_rect.x = config->dec_x/2;
op_para.src1_rect.y = config->dec_y/2;
op_para.src1_rect.w = config->dec_w/2;
op_para.src1_rect.h = config->dec_h/2;
op_para.dst_rect.x = config->dec_x/2;
op_para.dst_rect.y = config->dec_y/2;
op_para.dst_rect.w = config->dec_w/2;
op_para.dst_rect.h = config->dec_h/2;
break;
case 3:
op_para.color=0x000000ff;
ge2d_config.src_format = ImgFormat2Ge2dFormat(format);
ge2d_config.dst_format = ImgFormat2Ge2dFormat(format);
ge2d_config.dst_planes[0].addr=CMEM_getPhys(planes[3]);
ge2d_config.dst_planes[0].w= scale_w;
ge2d_config.dst_planes[0].h = scale_h;
op_para.src1_rect.x = scale_x;
op_para.src1_rect.y = scale_y;
op_para.src1_rect.w = scale_w;
op_para.src1_rect.h = scale_h;
op_para.dst_rect.x = scale_x;
op_para.dst_rect.y = scale_y;
op_para.dst_rect.w = scale_w;
op_para.dst_rect.h = scale_h;
break;
case 4:
ge2d_config.src_dst_type = OSD0_OSD0;
op_para.color=0x000000ff;
ge2d_config.src_format = ImgFormat2Ge2dFormat(format);
ge2d_config.dst_format = ImgFormat2Ge2dFormat(format);
op_para.src1_rect.x = scale_x;
op_para.src1_rect.y = scale_y;
op_para.src1_rect.w = scale_w;
op_para.src1_rect.h = scale_h;
op_para.dst_rect.x = scale_x;
op_para.dst_rect.y = scale_y;
op_para.dst_rect.w = scale_w;
op_para.dst_rect.h = scale_h;
break;
default:
break;
}
ioctl(fd_ge2d, FBIOPUT_GE2D_CONFIG, &ge2d_config);
ioctl(fd_ge2d, FBIOPUT_GE2D_FILLRECTANGLE, &op_para);
exit:
if(fd_ge2d >=0){
close(fd_ge2d);
fd_ge2d = -1;
}
#ifdef JPEG_DBG
printf("finish clean plane buffer %d!!!!!\n", index);
#endif
return 0;
}
void testCache(int size, int block)
{
unsigned int *ptr1_nocache = NULL;
unsigned int *ptr1_cache = NULL;
unsigned int *ptr1_dma = NULL;
unsigned int *ptr2 = NULL;
unsigned long physp;
unsigned long physp_dma;
unsigned long physp_nocache;
unsigned long physp_cache;
int poolid;
int i, j;
struct timeval start_tv, end_tv;
unsigned long diff;
int foo, bar;
CMEM_AllocParams params;
printf("Allocating first noncached buffer.\n");
/* First allocate a buffer from the pool that best fits */
ptr1_nocache = CMEM_alloc(size, NULL);
if (ptr1_nocache == NULL) {
fprintf(stderr, "Failed to allocate buffer of size %d\n", size);
goto cleanup;
}
printf("Allocated buffer of size %d at address %#x.\n", size,
(unsigned int) ptr1_nocache);
/* Find out and print the physical address of this buffer */
physp_nocache = CMEM_getPhys(ptr1_nocache);
if (physp_nocache == 0) {
fprintf(stderr, "Failed to get physical address of buffer %#x\n",
(unsigned int) ptr1_nocache);
goto cleanup;
}
printf("Physical address of allocated buffer is %#x.\n",
(unsigned int) physp_nocache);
/* Write some data into this buffer */
for (i=0; i < size / sizeof(int) ; i++) {
ptr1_nocache[i] = 0xbeefbeef;
}
printf("Allocating first cached buffer.\n");
/* First allocate a buffer from the pool that best fits */
params = CMEM_DEFAULTPARAMS;
params.flags = CMEM_CACHED;
ptr1_cache = CMEM_alloc2(block, size, ¶ms);
if (ptr1_cache == NULL) {
fprintf(stderr, "Failed to allocate buffer of size %d\n", size);
goto cleanup;
}
printf("Allocated buffer of size %d at address %#x.\n", size,
(unsigned int) ptr1_cache);
/* Find out and print the physical address of this buffer */
physp_cache = CMEM_getPhys(ptr1_cache);
if (physp_cache == 0) {
fprintf(stderr, "Failed to get physical address of buffer %#x\n",
(unsigned int) ptr1_cache);
goto cleanup;
}
printf("Physical address of allocated buffer is %#x.\n",
(unsigned int) physp_cache);
/* Write some data into this buffer */
for (i = 0; i < size / sizeof(int); i++) {
ptr1_cache[i] = 0x0dead1ce;
}
printf("Allocating noncached DMA source buffer.\n");
/* Allocate a noncached buffer for the DMA source */
ptr1_dma = CMEM_alloc(size, NULL);
if (ptr1_dma == NULL) {
fprintf(stderr, "Failed to allocate buffer of size %d\n", size);
goto cleanup;
}
printf("Allocated buffer of size %d at address %#x.\n", size,
(unsigned int) ptr1_dma);
/* Find out and print the physical address of this buffer */
physp_dma = CMEM_getPhys(ptr1_dma);
if (physp_dma == 0) {
fprintf(stderr, "Failed to get physical address of buffer %#x\n",
(unsigned int) ptr1_dma);
goto cleanup;
}
printf("Physical address of allocated buffer is %#x.\n",
(unsigned int) physp_dma);
/* Initialize DMA source buffer */
for (i = 0; i < size / sizeof(int); i++) {
ptr1_cache[i] = 0x0dead1ce;
}
/*
* Measure the write performance of each buffer to check that one
* is cached and the other isn't.
*/
printf("Measuring R-M-W performance (cached should be quicker).\n");
for (j = 0; j < 3; j++) {
printf("R-M-W noncached buffer %lx\n", physp_nocache);
gettimeofday(&start_tv, NULL);
for (i = 0; i < (size / sizeof(int)); i += 1) {
ptr1_nocache[i] += 1;
}
gettimeofday(&end_tv, NULL);
diff = end_tv.tv_usec - start_tv.tv_usec;
if (end_tv.tv_sec > start_tv.tv_sec) {
diff += (end_tv.tv_sec - start_tv.tv_sec) * 1000000;
}
printf(" diff=%ld\n", diff);
printf("R-M-W cached buffer %lx\n", physp_cache);
gettimeofday(&start_tv, NULL);
for (i = 0; i < (size / sizeof(int)); i += 1) {
ptr1_cache[i] += 1;
}
gettimeofday(&end_tv, NULL);
diff = end_tv.tv_usec - start_tv.tv_usec;
if (end_tv.tv_sec > start_tv.tv_sec) {
diff += (end_tv.tv_sec - start_tv.tv_sec) * 1000000;
}
printf(" diff=%ld\n", diff);
}
printf("Invalidate cached buffer %p\n", ptr1_cache);
foo = *ptr1_cache;
bar = foo;
bar++;
*ptr1_cache = bar;
CMEM_cacheInv(ptr1_cache, size);
printf("post-flush *ptr1_cache=0x%x\n", foo);
printf("wrote 0x%x to *ptr1_cache\n", bar);
printf("post-inv *ptr1_cache=0x%x\n", *ptr1_cache);
printf("R-M-W cached buffer %lx\n", physp_cache);
gettimeofday(&start_tv, NULL);
for (i = 0; i < (size / sizeof(int)); i += 1) {
ptr1_cache[i] += 1;
}
gettimeofday(&end_tv, NULL);
diff = end_tv.tv_usec - start_tv.tv_usec;
if (end_tv.tv_sec > start_tv.tv_sec) {
diff += (end_tv.tv_sec - start_tv.tv_sec) * 1000000;
}
printf(" diff=%ld\n", diff);
/*
* Now allocate another buffer by first finding out which pool that fits
* best, and then explicitly allocating from that pool. This gives more
* control at the cost of an extra function call, but essentially does
* the same thing as the above CMEM_alloc() call.
*/
printf("Allocating second buffer.\n");
poolid = CMEM_getPool(size);
if (poolid == -1) {
fprintf(stderr, "Failed to get a pool which fits size %d\n", size);
goto cleanup;
}
printf("Got a pool (%d) that fits the size %d\n", poolid, size);
ptr2 = CMEM_allocPool(poolid, NULL);
if (ptr2 == NULL) {
fprintf(stderr, "Failed to allocate buffer of size %d\n", size);
goto cleanup;
}
printf("Allocated buffer of size %d at address %#x.\n", size,
(unsigned int) ptr2);
/* Find out and print the physical address of this buffer */
physp = CMEM_getPhys(ptr2);
if (physp == 0) {
fprintf(stderr, "Failed to get physical address of buffer %#x\n",
(unsigned int) ptr2);
goto cleanup;
}
printf("Physical address of allocated buffer is %#x.\n",
(unsigned int) physp);
/* Write some data into this buffer */
for (i=0; i < size / sizeof(int); i++) {
ptr2[i] = 0xfeebfeeb;
}
printf("Inspect your memory map in /proc/%d/maps.\n", getpid());
printf("Also look at your pool info under /proc/cmem\n");
printf("Press ENTER to exit (after 'cat /proc/cmem' if desired).\n");
getchar();
cleanup:
if (ptr1_nocache != NULL) {
if (CMEM_free(ptr1_nocache, NULL) < 0) {
fprintf(stderr, "Failed to free buffer at %#x\n",
(unsigned int) ptr1_nocache);
}
printf("Successfully freed buffer at %#x.\n",
(unsigned int) ptr1_nocache);
}
if (ptr1_cache != NULL) {
if (CMEM_free(ptr1_cache, ¶ms) < 0) {
fprintf(stderr, "Failed to free buffer at %#x\n",
(unsigned int) ptr1_cache);
}
printf("Successfully freed buffer at %#x.\n",
(unsigned int) ptr1_cache);
}
if (ptr1_dma != NULL) {
if (CMEM_free(ptr1_dma, NULL) < 0) {
fprintf(stderr, "Failed to free buffer at %#x\n",
(unsigned int) ptr1_dma);
}
printf("Successfully freed buffer at %#x.\n",
(unsigned int) ptr1_dma);
}
if (ptr2 != NULL) {
if (CMEM_free(ptr2, NULL) < 0) {
fprintf(stderr, "Failed to free buffer at %#x\n",
(unsigned int) ptr2);
}
printf("Successfully freed buffer at %#x.\n",
(unsigned int) ptr2);
}
}
/*
* Construct new bufferpool and allocate buffers from driver
*
* @elem the parent element that owns this buffer
* @fd the file descriptor of the device file
* @count the requested number of buffers in the pool
* @caps the requested buffer caps
* @return the bufferpool or <code>NULL</code> if error
*/
GstBufferClassBufferPool *
gst_buffer_manager_new (GstElement * elem, int fd, int count, GstCaps * caps)
{
GstBufferClassBufferPool *pool = NULL;
GstVideoFormat format;
gint width, height ;
void *vidStreamBufVa;
unsigned long vidStreamBufPa;
int n, i;
gst_initpacket pack_info;
if (gst_video_format_parse_caps(caps, &format, &width, &height)) {
bc_buf_params_t param;
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
CMEM_init();
vidStreamBufVa = CMEM_alloc((width*height*2*MAX_FCOUNT), &cmem_params);
if (!vidStreamBufVa)
{
printf ("CMEM_alloc for Video Stream buffer returned NULL \n");
return NULL;
}
vidStreamBufPa = CMEM_getPhys(vidStreamBufVa);
for (i = 0; i < count; i++)
{
TextureBufsPa[i] = vidStreamBufPa + (width*height*2*i);
}
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
param.count = count;
param.width = width; /* width should be multiple of 32 */
param.height = height;
switch(format)
{
case 3 : param.fourcc = BC_PIX_FMT_YUYV;
break;
case 22: param.fourcc = BC_PIX_FMT_NV12;
break;
case 4 : param.fourcc = BC_PIX_FMT_UYVY;
break;
default: /* Uknown Format */
return -1;
}
param.type = BC_MEMORY_USERPTR;
pack_info.params = param;
pack_info.phyaddr = vidStreamBufPa;
n = write(fd_bcinit_fifo, &pack_info, sizeof(gst_initpacket));
if(n != sizeof(gst_initpacket))
{
printf("Error in writing to queue\n");
}
/* We no longer need this pipe */
close(fd_bcinit_fifo);
/* construct bufferpool */
pool = (GstBufferClassBufferPool *)
gst_mini_object_new (GST_TYPE_BCBUFFERPOOL);
//TODO: Remove fd from pool -not required any more.
pool->fd = -1;
pool->elem = elem;
pool->num_buffers = param.count;
GST_DEBUG_OBJECT (pool->elem, "orig caps: %" GST_PTR_FORMAT, caps);
GST_DEBUG_OBJECT (pool->elem, "requested %d buffers, got %d buffers", count,
param.count);
pool->caps = caps;
/* and allocate buffers:
*/
pool->num_buffers = param.count;
pool->buffers = g_new0 (GstBufferClassBuffer *, param.count);
pool->avail_buffers = g_async_queue_new_full (
(GDestroyNotify) gst_mini_object_unref);
for (i = 0; i < param.count; i++) {
// TODO: Find correct size here
GstBufferClassBuffer *buf = gst_bcbuffer_new (pool, i, param.width*param.height*2, TextureBufsPa[i]);
GST_BUFFER_DATA (buf) = (vidStreamBufVa + param.width*param.height*2*i);
GST_BUFFER_SIZE (buf) = param.width*param.height*2;
if (G_UNLIKELY (!buf)) {
GST_WARNING_OBJECT (pool->elem, "Buffer %d allocation failed", i);
goto fail;
}
gst_buffer_set_caps (GST_BUFFER (buf), caps);
pool->buffers[i] = buf;
g_async_queue_push (pool->avail_buffers, buf);
}
return pool;
} else {
Void *deiThrFxn(Void *arg)
{
DeiEnv *envp = (DeiEnv *) arg;
Void *status = THREAD_SUCCESS;
Uint32 sysRegBase = 0;
VIDENC1_Handle hDei = NULL;
IDEI_Params deiParams;
Uint16 frame_width = 0, frame_height = 0;
Uint16 threshold_low = 0, threshold_high = 0;
IVIDEO1_BufDescIn inBufDesc;
XDM_BufDesc outBufDesc;
XDAS_Int8 *outbufs[2];
XDAS_Int32 outBufSizeArray[2];
VIDENC1_InArgs inArgs;
IDEI_OutArgs outArgs;
Uint32 bufferSize;
CMEM_AllocParams cmemPrm;
Uint32 prevBufAddr, outBufAddr;
Buffer_Handle cBuf, dBuf;
Int ret = 0;
int fd = -1;
dm365mmap_params_t dm365mmap_params;
pthread_mutex_t Dmai_DM365dmaLock = PTHREAD_MUTEX_INITIALIZER;
/* ▼▼▼▼▼ Initialization ▼▼▼▼▼ */
DM365MM_init(); printf("\n"); /* dm365mm issue */
sysRegBase = DM365MM_mmap(0x01C40000, 0x4000);
CMEM_init();
cmemPrm.type = CMEM_HEAP;
cmemPrm.flags = CMEM_NONCACHED;
cmemPrm.alignment = 32;
prevBufAddr = (Uint32)CMEM_alloc(IN_OUT_BUF_SIZE, &cmemPrm);
outBufAddr = (Uint32)CMEM_alloc(IN_OUT_BUF_SIZE, &cmemPrm);
frame_width = 720;
frame_height = 576;
threshold_low = 16;
threshold_high = 20;
/* Create DEI instance */
deiParams.videncParams.size = sizeof(IDEI_Params);
deiParams.frameHeight = frame_height;
deiParams.frameWidth = frame_width;
deiParams.inLineOffset = frame_width;
deiParams.outLineOffset = (frame_width - 8);
deiParams.threshold_low = threshold_low;
deiParams.threshold_high = threshold_high;
deiParams.inputFormat = XDM_YUV_422ILE;
deiParams.outputFormat = XDM_YUV_420SP;
deiParams.q_num = 1;
deiParams.askIMCOPRes = 0;
deiParams.sysBaseAddr = sysRegBase;
hDei = VIDENC1_create(envp->hEngine, "dei", (VIDENC1_Params *)&deiParams);
if(hDei == NULL)
{
ERR("DEI alg creation failed\n");
cleanup(THREAD_FAILURE);
}
fd = open("/dev/dm365mmap", O_RDWR | O_SYNC);
Rendezvous_meet(envp->hRendezvousInit);
/* ▲▲▲▲▲ Initialization ▲▲▲▲▲ */
while (1) {
if (Fifo_get(envp->hFromCaptureFifo, &cBuf) < 0) {
ERR("Failed to get buffer from capture thread\n");
cleanup(THREAD_FAILURE);
}
if (Fifo_get(envp->hFromDisplayFifo, &dBuf) < 0) {
ERR("Failed to get buffer from display thread\n");
cleanup(THREAD_FAILURE);
}
inBufDesc.numBufs = 4;
bufferSize = (frame_width * frame_height);
inBufDesc.bufDesc[0].bufSize = bufferSize;
inBufDesc.bufDesc[0].buf = (XDAS_Int8 *)Buffer_getUserPtr(cBuf);
inBufDesc.bufDesc[0].accessMask = 0;
inBufDesc.bufDesc[1].bufSize = bufferSize;
inBufDesc.bufDesc[1].buf = (XDAS_Int8 *)(Buffer_getUserPtr(cBuf) + bufferSize);
inBufDesc.bufDesc[1].accessMask = 0;
inBufDesc.bufDesc[2].bufSize = bufferSize;
inBufDesc.bufDesc[2].buf = (XDAS_Int8 *)prevBufAddr;
inBufDesc.bufDesc[2].accessMask = 0;
inBufDesc.bufDesc[3].bufSize = bufferSize;
inBufDesc.bufDesc[3].buf = (XDAS_Int8 *)(prevBufAddr + bufferSize);
inBufDesc.bufDesc[3].accessMask = 0;
/* Output buffers */
outBufDesc.numBufs = 2;
outbufs[0] = (XDAS_Int8*)outBufAddr;
outbufs[1] = (XDAS_Int8*)(outBufAddr + bufferSize);
outBufSizeArray[0] = bufferSize;
outBufSizeArray[1] = bufferSize / 2;
outBufDesc.bufSizes = outBufSizeArray;
outBufDesc.bufs = outbufs;
inArgs.size = sizeof(VIDENC1_InArgs);
outArgs.videncOutArgs.size = sizeof(IDEI_OutArgs);
ret = VIDENC1_process((VIDENC1_Handle)hDei,
&inBufDesc,
&outBufDesc,
&inArgs,
(IVIDENC1_OutArgs *)&outArgs);
if (ret != VIDENC1_EOK) {
ERR("DEI process failed\n");
cleanup(THREAD_FAILURE);
}
dm365mmap_params.src = CMEM_getPhys(outbufs[0]);
dm365mmap_params.srcmode = 0;
dm365mmap_params.dst = Buffer_getPhysicalPtr(dBuf);
dm365mmap_params.dstmode = 0;
dm365mmap_params.srcbidx = 712;
dm365mmap_params.dstbidx = 704;
dm365mmap_params.acnt = 704;
dm365mmap_params.bcnt = 576;
dm365mmap_params.ccnt = 1;
dm365mmap_params.bcntrld = dm365mmap_params.bcnt;
dm365mmap_params.syncmode = 1;
pthread_mutex_lock(&Dmai_DM365dmaLock);
if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) {
ERR("memcpy: Failed to do memcpy\n");
cleanup(THREAD_FAILURE);
}
pthread_mutex_unlock(&Dmai_DM365dmaLock);
dm365mmap_params.src = CMEM_getPhys(outbufs[1]);
dm365mmap_params.srcmode = 0;
dm365mmap_params.dst = Buffer_getPhysicalPtr(dBuf) + (Buffer_getSize(dBuf) * 2 / 3);
dm365mmap_params.dstmode = 0;
dm365mmap_params.srcbidx = 712;
dm365mmap_params.dstbidx = 704;
dm365mmap_params.acnt = 712;
dm365mmap_params.bcnt = 570 / 2;
dm365mmap_params.ccnt = 1;
dm365mmap_params.bcntrld = dm365mmap_params.bcnt;
dm365mmap_params.syncmode = 1;
pthread_mutex_lock(&Dmai_DM365dmaLock);
if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) {
ERR("memcpy: Failed to do memcpy\n");
cleanup(THREAD_FAILURE);
}
pthread_mutex_unlock(&Dmai_DM365dmaLock);
Buffer_setNumBytesUsed(dBuf, 704 * 576 * 3 / 2);
dm365mmap_params.src = Buffer_getPhysicalPtr(cBuf);
dm365mmap_params.srcmode = 0;
dm365mmap_params.dst = prevBufAddr;
dm365mmap_params.dstmode = 0;
dm365mmap_params.srcbidx = 1440;
dm365mmap_params.dstbidx = 1440;
dm365mmap_params.acnt = 1440;
dm365mmap_params.bcnt = 576;
dm365mmap_params.ccnt = 1;
dm365mmap_params.bcntrld = dm365mmap_params.bcnt;
dm365mmap_params.syncmode = 1;
pthread_mutex_lock(&Dmai_DM365dmaLock);
if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) {
ERR("memcpy: Failed to do memcpy\n");
cleanup(THREAD_FAILURE);
}
pthread_mutex_unlock(&Dmai_DM365dmaLock);
/* Send buffer to display thread */
if (Fifo_put(envp->hToDisplayFifo, dBuf) < 0) {
ERR("Failed to send buffer to dei thread\n");
cleanup(THREAD_FAILURE);
}
/* Send buffer to display thread */
if (Fifo_put(envp->hToCaptureFifo, cBuf) < 0) {
ERR("Failed to send buffer to dei thread\n");
cleanup(THREAD_FAILURE);
}
}
cleanup:
Rendezvous_force(envp->hRendezvousInit);
Rendezvous_meet(envp->hRendezvousCleanup);
/* Delete DEI ALG instance */
VIDENC1_delete(hDei);
DM365MM_ummap(sysRegBase,0x4000);
DM365MM_exit();
if (fd > 0) {
close(fd);
}
return status;
}
int rebuild_jpg_config_para(jpeg_data_t *jpeg_data,jpegdec_config_t *config)
{
int ret = 0;
if((scale_w*jpeg_data->info.height)!= (scale_h*jpeg_data->info.width)){
sMode = IGNOREASPECTRATIO;
}else{
sMode = KEEPASPECTRATIO;
}
#ifdef JPEG_DBG
printf("current sMode is %d\n",sMode);
#endif
switch(sMode){
case KEEPASPECTRATIO:
ret = compute_keep_ratio(jpeg_data,config);
break;
case IGNOREASPECTRATIO:
ret = compute_keep_ratio_by_expanding(jpeg_data,config);
if(ret < 0){
ret = compute_keep_ratio(jpeg_data,config);
}
break;
case KEEPASPECTRATIOBYEXPANDING:
ret = compute_keep_ratio_by_expanding(jpeg_data,config);
if(ret < 0){
ret = compute_keep_ratio(jpeg_data,config);
}
break;
default:
break;
}
if(config->dec_h<2) {
printf("too small to decode with hwjpeg decoder.\n");
return -1;
}
config->canvas_width = CANVAS_ALIGNED(config->dec_w);
planes[0] = (unsigned char *)CMEM_alloc(0,
config->canvas_width * config->dec_h, &cmemParm);
planes[1] = (unsigned char *)CMEM_alloc(0,
CANVAS_ALIGNED((config->canvas_width/2)) *config->dec_h/2, &cmemParm);
planes[2] = (unsigned char *)CMEM_alloc(0,
CANVAS_ALIGNED((config->canvas_width/2)) * config->dec_h/2, &cmemParm);
if ((!planes[0]) || (!planes[1]) || (!planes[2])) {
printf("Not enough memory\n");
if (planes[0])
CMEM_free(planes[0], &cmemParm);
if (planes[1])
CMEM_free(planes[1], &cmemParm);
if (planes[2])
CMEM_free(planes[2], &cmemParm);
return -1;
}
config->addr_y = CMEM_getPhys(planes[0]);
config->addr_u = CMEM_getPhys(planes[1]);
config->addr_v = CMEM_getPhys(planes[2]);
if(config->dec_w==0 ||config->dec_h==0)
{
config->dec_w= jpeg_data->info.width;
config->dec_h= jpeg_data->info.height;
}
// scaleSize(config->dec_w, config->dec_h, jpeg_data->info.width, jpeg_data->info.height, (Qt::AspectRatioMode)config->opt);
config->opt = 0;
config->dec_x = 0;
config->dec_y = 0;
config->angle = CLKWISE_0;
clear_plane(0,config);
clear_plane(1,config);
clear_plane(2,config);
return 0;
}
aml_image_info_t* read_jpeg_image_rgb_test(char* url , int width, int height,int mode , int flag)
{
aml_image_info_t* output_image_info;
output_image_info = (aml_image_info_t*)malloc(sizeof(aml_image_info_t));
memset((char*)output_image_info , 0 , sizeof(aml_image_info_t));
/*default para*/
if((width <= 0)||(height <=0)||(mode > 2) ){
width = 1280;
height = 720;
mode = KEEPASPECTRATIO;
}
int wait_timeout = 0 ;
char* outimage = NULL;
int fd = open(url,O_RDWR ) ;
if(fd < 0){
goto exit;
}
printf("open 15.jpeg sucessfuly\n");
//we need some step to decompress jpeg image to output
// 1 request yuv space from cmem to store decompressed data
// 2 config and decompress jpg picture.
// 3 request new rgb space from cmem to store output rgb data.
// 4 ge2d move yuv data to rgb space.
// 5 release request mem to cmem module.
jpegdec_config_t config;
jpeg_data_t jpeg_data;
int fd_ge2d=-1;
config_para_t ge2d_config;
int format;
ge2d_op_para_t op_para;
int bpl ;
memset((char*)&ge2d_config,0,sizeof(config_para_t));
scale_x = 0;
scale_y = 0;
scale_w = width;
scale_h = height;
/*default value for no scaler input*/
#if 1
if(scale_w>0 && scale_w<=200 && scale_h>0 && scale_h<=200) {
decoder_opt=JPEGDEC_OPT_THUMBNAIL_PREFERED;
} else {
decoder_opt=0;
}
#else
decoder_opt=0;
#endif
if((scale_w == 0)||(scale_h ==0)){
scale_w = 160 ;
scale_h = 100;
}
config.opt=(unsigned)sMode ;
jpeg_data.fd_amport=fd_amport;
if(!(JPEGDEC_STAT_DONE&read_jpeg_data(fd,&jpeg_data,DEC_STAT_MAX,&config)))
{
#ifdef JPEG_DBG
printf("can't decode jpg pic");
#endif
goto exit;
}
#ifdef JPEG_DBG
printf("deocde jpg pic completed");
#endif
planes[3]=(unsigned char *)CMEM_alloc(0,CANVAS_ALIGNED(scale_w)*scale_h*4,&cmemParm);
if(!planes[3])
{
#ifdef JPEG_DBG
printf("can't get rgb memory from heap");
#endif
goto exit;
}
#ifdef JPEG_DBG
printf("planes[3]=(unsigned char *)CMEM_alloc(0,%d * %d *4,&cmemParm)\n",scale_w ,scale_h);
#endif
clear_plane(3,&config);
//open fb device to handle ge2d op FILE_NAME_GE2D
fd_ge2d= open(FILE_NAME_GE2D, O_RDWR);
//#ifdef JPEG_DBG
// printf("fd_ge2d= open(%s, O_RDWR)\n",dev.toLatin1().constData());
//#endif
if(fd_ge2d<0)
{
#ifdef JPEG_DBG
printf("can't open framebuffer device" );
#endif
goto exit;
}
/*antiflicking setting*/
if(flag){
ioctl(fd_ge2d,FBIOPUT_GE2D_ANTIFLICKER_ENABLE,1);
}else{
ioctl(fd_ge2d,FBIOPUT_GE2D_ANTIFLICKER_ENABLE,0);
}
if(jpeg_data.info.comp_num==3 ||jpeg_data.info.comp_num==4)
{
format = Format_RGB32;
}else{
#ifdef JPEG_DBG
printf("unsupported color format" );
#endif
goto exit;
}
#ifdef JPEG_DBG
printf("start ge2d image format convert!!!!!\n");
#endif
ge2d_config.src_dst_type = ALLOC_ALLOC;
// ge2d_config.src_dst_type = ALLOC_OSD1; //only for test
ge2d_config.alu_const_color=0xff0000ff;
ge2d_config.src_format = GE2D_FORMAT_M24_YUV420;
ge2d_config.dst_format = ImgFormat2Ge2dFormat(format);
if(0xffffffff==ge2d_config.dst_format)
{
#ifdef JPEG_DBG
printf("can't get proper ge2d format" );
#endif
goto exit;
}
ge2d_config.src_planes[0].addr = config.addr_y;
ge2d_config.src_planes[0].w = config.canvas_width;
ge2d_config.src_planes[0].h = config.dec_h;
ge2d_config.src_planes[1].addr = config.addr_u;
ge2d_config.src_planes[1].w = config.canvas_width/2;
ge2d_config.src_planes[1].h = config.dec_h / 2;
ge2d_config.src_planes[2].addr = config.addr_v;
ge2d_config.src_planes[2].w = config.canvas_width/2;
ge2d_config.src_planes[2].h = config.dec_h / 2;
ge2d_config.dst_planes[0].addr=CMEM_getPhys(planes[3]);
ge2d_config.dst_planes[0].w= scale_w;
ge2d_config.dst_planes[0].h = scale_h;
//#ifdef JPEG_DBG
// printf("planes[3]addr : 0x%x-0x%x" ,planes[3],ge2d_config.dst_planes[0].addr);
//#endif
ioctl(fd_ge2d, FBIOPUT_GE2D_CONFIG, &ge2d_config);
/*crop case*/
if((config.dec_w > scale_w )||(config.dec_h > scale_h)){
op_para.src1_rect.x = (config.dec_w - scale_w)>>1;
op_para.src1_rect.y = (config.dec_h - scale_h)>>1;
op_para.src1_rect.w = scale_w;
op_para.src1_rect.h = scale_h;
op_para.dst_rect.x = 0;
op_para.dst_rect.y = 0;
op_para.dst_rect.w = scale_w;
op_para.dst_rect.h = scale_h;
}else{
int testMap(size_t size)
{
unsigned int *ptr;
unsigned int *map_ptr;
#if defined(LINUXUTILS_BUILDOS_ANDROID)
off64_t physp;
#else
off_t physp;
#endif
int ret = 0;
ptr = CMEM_alloc(size, NULL);
printf("testMap: ptr = %p\n", ptr);
if (ptr == NULL) {
printf("testMap: CMEM_alloc() failed\n");
return 1;
}
printf(" writing 0xdadaface to *ptr\n");
*ptr = 0xdadaface;
#if defined(LINUXUTILS_BUILDOS_ANDROID)
physp = CMEM_getPhys64(ptr);
map_ptr = CMEM_map64(physp, size);
#else
physp = CMEM_getPhys(ptr);
map_ptr = CMEM_map(physp, size);
#endif
if (map_ptr == NULL) {
printf("testMap: CMEM_map() failed\n");
ret = 1;
goto cleanup;
}
else {
printf("testMap: remapped physp %#llx to %p\n",
physp, map_ptr);
printf(" *map_ptr = 0x%x\n", *map_ptr);
}
if (*map_ptr != 0xdadaface) {
printf("testMap: failed, read didn't match write\n");
ret = 1;
}
CMEM_unmap(map_ptr, size);
if (*ptr != 0xdadaface) {
printf("testMap: after unmap *ptr != 0xdadaface\n");
ret = 1;
goto cleanup;
}
else {
printf("testMap: original pointer still good\n");
}
printf("testMap: trying to map too much (0x%x)...\n", size * 0x10);
#if defined(LINUXUTILS_BUILDOS_ANDROID)
map_ptr = CMEM_map64(physp, size * 0x10);
#else
map_ptr = CMEM_map(physp, size * 0x10);
#endif
if (map_ptr != NULL) {
printf("testMap: CMEM_map() should've failed but didn't\n");
CMEM_unmap(map_ptr, size * 0x10);
ret = 1;
}
cleanup:
CMEM_free(ptr, NULL);
return ret;
}
/* ARGSUSED - this line tells the compiler not to warn about unused args. */
IRES_Status IRESMAN_MEMTCM_init(IRESMAN_Params * initArgs)
{
SMGRMP_Attrs attrs;
IRESMAN_MemTcmParams * resmanArgs = (IRESMAN_MemTcmParams *)initArgs;
/* CMEM_AllocParams params; */
GT_assert(ti_sdo_fc_ires_memtcm, initArgs != NULL);
/*
* Check if already initialized
*/
if (_initialized) {
GT_0trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_init> Exit (status=IRES_EEXISTS)\n");
return (IRES_EEXISTS);
}
if (gtInit == 0) {
GT_init();
GT_create(&CURTRACE, "ti.sdo.fc.ires.memtcm");
gtInit = 1;
}
GT_1trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_init> Enter (initArgs=0x%x)\n", initArgs);
/*
* Information regarding the memory allocation/free functions
* is stored as part of the internal state of the resource
* manager
*/
if (NULL == _MEMTCM_lock) {
/* Create a lock for protecting MEMTCM internal state object */
_MEMTCM_lock = LockMP_create(_MEMTCM_LOCKID);
if (_MEMTCM_lock == NULL) {
GT_1trace(CURTRACE, GT_7CLASS,
"IRESMAN_MEMTCM_init> Failed to create IPC lock, "
"key = 0x%x\n", _MEMTCM_LOCKID);
GT_0trace(CURTRACE, GT_ENTER, "IRESMAN_MEMTCM_init> Exit (status="
"IRES_EFAIL)\n");
return (IRES_EFAIL);
}
}
getInternalState();
if (NULL == _resmanInternalState) {
GT_0trace(CURTRACE, GT_7CLASS,
"IRESMAN_MEMTCM_init>Failed to obtain Internal state Object\n");
GT_0trace(CURTRACE, GT_ENTER, "IRESMAN_MEMTCM_init> Exit (status="
"IRES_EFAIL)\n");
LockMP_delete(_MEMTCM_lock);
return (IRES_EFAIL);
}
/*
* Information regarding the memory allocation/free functions
*/
_allocFxn = resmanArgs->baseConfig.allocFxn;
_freeFxn = resmanArgs->baseConfig.freeFxn;
if (0 != CMEM_init()) {
GT_0trace(CURTRACE, GT_7CLASS,
"IRESMAN_MEMTCM_init> Could not initialize CMEM\n");
GT_0trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_init> Exit (status=IRES_EFAIL)\n");
freeInternalState();
LockMP_delete(_MEMTCM_lock);
return (IRES_EFAIL);
}
/* TODO: Figure out how to populate the params */
if (_resmanInternalState->numOpens == 0) {
armtcmAddr = CMEM_alloc2(MEMTCM_blockId, MEMTCM_size, NULL);
_resmanInternalState->armtcmAddr = (void *)CMEM_getPhys(armtcmAddr);
}
else {
armtcmAddr = CMEM_registerAlloc(
(unsigned long)_resmanInternalState->armtcmAddr);
}
if (NULL == armtcmAddr) {
GT_0trace(CURTRACE, GT_7CLASS,
"IRESMAN_MEMTCM_init> Could not allocate TCM memory from CMEM"
"\n");
GT_0trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_init> Exit (status=IRES_EFAIL)\n");
freeInternalState();
LockMP_delete(_MEMTCM_lock);
return (IRES_EFAIL);
}
if (NULL == smgr) {
attrs.numScratchGroups = MEMTCM_NUM_GROUPS;
attrs.numResources = (MEMTCM_NUMRES);
/* One resource corresponds to a 1/2 K
chunk of memory (0x200), Manage memory
in chunks of 0x200
*/
attrs.lock = _MEMTCM_lock;
attrs.key = (void *)_MEMTCM_MEMID; /* A key specific to the resource
being managed */
/* This will create a new resource manager or return a process-specific
handle to an existing smgr */
smgr = SMGRMP_create(&attrs);
if (NULL == smgr) {
GT_0trace(CURTRACE, GT_7CLASS, "IRESMAN_MEMTCM_init> Error creating"
" scratch resource manager.\n");
GT_0trace(CURTRACE, GT_ENTER, "IRESMAN_MEMTCM_init> Exit (status="
"IRES_EFAIL)\n");
freeInternalState();
LockMP_delete(_MEMTCM_lock);
return (IRES_EFAIL);
}
}
_resmanInternalState->numOpens++;
/*
* Set Initalized flag to 1 if successful
*/
_initialized = 1;
GT_0trace(CURTRACE, GT_ENTER,
"IRESMAN_MEMTCM_init> Exit (status=IRES_OK)\n");
return (IRES_OK);
}