JNIEXPORT void JNICALL Java_com_example_enzocamtest_CamView_stopCamera(JNIEnv* env,
jobject thiz)
{
cameraDeinit(usbCam);
decoderDeinit(mjpgDec);
free(mjpgDec);
free(usbCam);
free(camData);
free(yuvData);
free(y422_buf);
g2d_free(rgb_buf);
g2d_free(y420_buf);
vpuDeinit();
}
int g2d_mem_release(__u32 sel)
{
if(g2d_size ==0) {
unsigned map_size = PAGE_ALIGN(g2d_mem[sel].mem_len);
unsigned page_size = map_size;
if(g2d_mem[sel].b_used == 0)
{
ERR("mem not used in g2d_mem_release,%d\n",sel);
return -EINVAL;
}
free_pages((unsigned long)(g2d_mem[sel].virt_addr),get_order(page_size));
memset(&g2d_mem[sel],0,sizeof(struct info_mem));
}
else {
if(g2d_mem[sel].b_used == 0)
{
ERR("mem not used in g2d_mem_release,%d\n",sel);
return -EINVAL;
}
g2d_free((void *)g2d_mem[sel].virt_addr);
memset(&g2d_mem[sel],0,sizeof(struct info_mem));
}
return 0;
}
void
v4l_stop_capturing(int instns)
{
int i;
int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ioctl(ins_priv[instns].fd_capture_v4l, VIDIOC_STREAMOFF, &type);
for (i = 0; i < g_num_buffers; i++)
{
g2d_free(ins_priv[instns].g2d_buffers[i]);
}
if (g_mem_type == V4L2_MEMORY_USERPTR) {
memfree(g_frame_size, g_num_buffers, instns);
} else {
for (i = 0; i < g_num_buffers; i++)
{
munmap(ins_priv[instns].cap_buffers[i].start, ins_priv[instns].cap_buffers[i].length);
}
}
munmap(g_fb, g_fb_size);
close(fd_fb);
close(fd_ipu);
close(ins_priv[instns].fd_capture_v4l);
ins_priv[instns].fd_capture_v4l = -1;
}
/*!
* @brief Free specified memory
* When user wants to free massive memory for the system,
* they needs to fill the physical address and size to be freed
* in buff structure.
*
* @param buff the structure containing memory information to be freed;
*
* @return
* @li 0 Freeing memory success.
* @li -1 Freeing memory failure.
*/
int _IOFreePhyMem(int which, vpu_mem_desc * buff)
{
#ifdef BUILD_FOR_ANDROID
#ifdef USE_ION
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
int shared_fd;
#else
struct ion_handle *handle;
#endif
int fd;
if (!buff || !(buff->size) || ((unsigned long)buff->cpu_addr == 0)) {
err_msg("Error!_IOFreePhyMem:Invalid parameters");
return -1;
}
if (which != VPU_IOC_PHYMEM_FREE) {
err_msg("Error!_IOFreePhyMem unsupported memtype: %d",which);
return -1;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
shared_fd = buff->cpu_addr;
#else
handle = (struct ion_handle *)buff->cpu_addr;
#endif
fd = ion_open();
if (fd <= 0) {
err_msg("ion open failed!\n");
return -1;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)
ion_close(shared_fd);
info_msg("<ion> free handle: 0x%x, paddr: 0x%x, vaddr: 0x%x",
(unsigned int)shared_fd, (unsigned int)buff->phy_addr,
(unsigned int)buff->virt_uaddr);
#else
ion_free(fd, handle);
info_msg("<ion> free handle: 0x%x, paddr: 0x%x, vaddr: 0x%x",
(unsigned int)handle, (unsigned int)buff->phy_addr,
(unsigned int)buff->virt_uaddr);
#endif
ion_close(fd);
munmap((void *)buff->virt_uaddr, buff->size);
memset((void*)buff, 0, sizeof(*buff));
#elif USE_GPU
struct g2d_buf *gbuf = (struct g2d_buf *)buff->cpu_addr;
if(gbuf) {
if(g2d_free(gbuf) != 0) {
err_msg("%s: gpu allocator failed to free buffer 0x%x", __FUNCTION__, (unsigned int)gbuf);
return -1;
}
info_msg("<gpu> free handle: 0x%x, paddr: 0x%x, vaddr: 0x%x",
(unsigned int)gbuf, (unsigned int)buff->phy_addr,
(unsigned int)buff->virt_uaddr);
}
memset((void*)buff, 0, sizeof(*buff));
#else
int fd_pmem;
if (!buff || !(buff->size) || ((int)buff->cpu_addr <= 0)) {
err_msg("Error!_IOFreePhyMem:Invalid parameters");
return -1;
}
if (which != VPU_IOC_PHYMEM_FREE) {
err_msg("Error!_IOFreePhyMem unsupported memtype: %d",which);
return -1;
}
fd_pmem = (int)buff->cpu_addr;
if(fd_pmem) {
munmap((void *)buff->virt_uaddr, buff->size);
close(fd_pmem);
}
memset((void*)buff, 0, sizeof(*buff));
#endif
#else
if (buff->phy_addr != 0) {
dprintf(3, "%s: phy addr = %08lx\n", __func__, buff->phy_addr);
ioctl(vpu_fd, which, buff);
}
sz_alloc -= buff->size;
dprintf(3, "%s: total=%d\n", __func__, sz_alloc);
memset(buff, 0, sizeof(*buff));
#endif
return 0;
}
/**
* Generates an LDM product-identifier from a GRIB edition 2 message.
*
* Atomic,
* Idempotent,
* Not thread-safe
*
* @param[in] data Pointer to the GRIB message.
* @param[in] sz Length of the GRIB message in bytes.
* @param[in] wmohead Pointer to the associated WMO header string.
* @param[out] ident Pointer to a buffer to receive the LDM
* product-identifier.
* @param[in] identSize Size of the \c ident buffer in bytes.
* @retval 0 Success. \c ident is set and NUL-terminated.
* @retval 1 Invalid GRIB message.
* @retval 2 GRIB message isn't edition 2.
* @retval 3 System error.
*/
int grib2name (
char* const data,
const size_t sz,
const char* const wmohead,
char* const ident,
const size_t identSize)
{
#if USE_GRIB2_DECODER
int status;
DecodedGrib2Msg* decoded;
if (status = g2d_new(&decoded, (unsigned char*)data, sz)) {
log_add("Couldn't decode GRIB message");
status = G2D_INVALID == status
? 1
: G2D_NOT_2
? 2
: 3;
}
else {
if (status = setIdent(ident, identSize, decoded, wmohead)) {
log_add("Couldn't set LDM product-identifier");
status = 1;
}
g2d_free(decoded);
} /* "decoded" allocated */
return status;
#else
static StringBuf* paramNames; /* Buffer for parameter name(s) */
int iField; /* GRIB-2 field index */
int status; /* Function return code */
g2int listsec0[3]; /* GRIB-2 section 0 parameters */
g2int listsec1[13]; /* GRIB-2 section 1 parameters */
g2int numlocal; /* Number of GRIB section 2-s */
int model_id; /* ID of model */
int grid_id; /* ID of grid */
char fdats[80]; /* No idea */
char levelstmp[80]; /* Level? */
Gribmsg g2Msg; /* GRIB-2 message structure */
if (paramNames) {
strBuf_clear(paramNames);
}
else {
paramNames = strBuf_new(127);
if (NULL == paramNames) {
log_add("Couldn't allocate buffer for parameter name(s)");
return 3;
}
}
g2Msg.cgrib2 = (unsigned char*)data;
g2Msg.mlength = sz;
g2Msg.gfld = NULL;
g2Msg.field_tot = 0;
if ((status = g2_info(g2Msg.cgrib2, g2Msg.mlength, listsec0, listsec1,
&(g2Msg.field_tot), &numlocal)) != 0)
return (2 == status) ? 2 : 1;
if (g2Msg.field_tot <= 0) {
log_add("GRIB-2 message has no data fields");
return 1;
}
for (iField = 0; iField < g2Msg.field_tot; iField++) {
static char g2tables[5][LLMXLN]; /* GRIB tables */
static char* tbllist[5] = {g2tables[0], g2tables[1], g2tables[2],
g2tables[3], g2tables[4]}; /* Addresses of GRIB tables */
Geminfo gemInfo; /* GEMPAK structure */
int const lastField = iField == g2Msg.field_tot - 1;
status = g2_getfld(g2Msg.cgrib2, g2Msg.mlength, iField+1, 0, 0,
&g2Msg.gfld);
if (status) {
log_add("Invalid GRIB-2 message: g2_getfld() status=%d", status);
return (2 == status) ? 2 : 1;
}
/* "g2Msg.gfld" is allocated */
/* Initialize strings in Geminfo structure */
(void)memset(gemInfo.cproj, 0, sizeof(gemInfo.cproj));
(void)memset(gemInfo.parm, 0, sizeof(gemInfo.parm));
(void)memset(gemInfo.gdattm1, 0, sizeof(gemInfo.gdattm1));
(void)memset(gemInfo.gdattm2, 0, sizeof(gemInfo.gdattm2));
/*
* In the original code, the last field determined the model ID.
*/
if (lastField)
model_id = g2Msg.gfld->ipdtmpl[4];
/*
* This assignment to "grid_id" isn't under the above "lastField"
* conditional because "decode_g2gnum()" might have side-effects upon
* which "gb2_2gem()" depends.
*/
grid_id = (g2Msg.gfld->griddef == 0)
? decode_g2gnum(g2Msg.gfld)
: g2Msg.gfld->griddef;
gb2_2gem(&g2Msg, &gemInfo, tbllist, &status);
if (status) {
log_add("Couldn't decode GRIB2 message. WMO header=\"%s\"",
wmohead);
log_flush_error();
if (lastField) {
(void)strcpy(fdats, "FHRS"); /* safe */
(void)strcpy(levelstmp, "LVL"); /* safe */
}
}
else {
char g2name[13]; /**< Name of product/parameter */
int ilen; /**< Length of resulting string */
(void)strcpy(g2name, gemInfo.parm); /* both 13 bytes */
cst_rmbl(g2name, g2name, &ilen, &status);
if (iField)
strBuf_appendString(paramNames, ";");
strBuf_appendString(paramNames, g2name);
cst_rxbl(gemInfo.unit, gemInfo.unit, &ilen, &status);
if (ilen == 0)
(void)strcpy(gemInfo.unit, "-"); /* safe */
cst_rmbl(gemInfo.gdattm1, gemInfo.gdattm1, &ilen, &status);
cst_rmbl(gemInfo.gdattm2, gemInfo.gdattm2, &ilen, &status);
/*
* In the original code, the last field determined the following
* parameters.
*/
if (lastField) {
static char strBuf[5]; /* Holds 4-char string */
static char* strptr = strBuf; /* For "cst_itoc()" */
if (ilen > 0)
(void)snprintf(fdats, sizeof(fdats), "%s-%s",
gemInfo.gdattm1, gemInfo.gdattm2);
else
(void)snprintf(fdats, sizeof(fdats), "%s",
gemInfo.gdattm1);
for (ilen = 1; ilen > 0;
cst_rmst(fdats, "/", &ilen, fdats, &status));
cst_itoc(&gemInfo.vcord, 1, &strptr, &status);
if (gemInfo.level[1] == -1)
(void)snprintf(levelstmp, sizeof(levelstmp), "%d %s %s",
gemInfo.level[0], gemInfo.unit, strptr);
else
(void)snprintf(levelstmp, sizeof(levelstmp), "%d-%d %s %s",
gemInfo.level[0], gemInfo.level[1], gemInfo.unit,
strptr);
}
}
g2_free(g2Msg.gfld);
g2Msg.gfld = NULL;
}
/*
* See if the WMO header can be used for grid 0 products
*/
if ((grid_id == 0) && (strlen(wmohead) > 11) && (wmohead[7] == 'K') &&
(wmohead[8] == 'W')) {
int wmoGridId = wmo_to_gridid(&wmohead[0], &wmohead[2]);
if (wmoGridId > 0)
grid_id = wmoGridId;
}
(void)snprintf(ident, identSize, "grib2/%s/%s/#%03d/%s/%s/%s",
s_pds_center((int)listsec1[0], (int)listsec1[1]),
s_pds_model((int)listsec1[0], model_id),
grid_id,
fdats,
strBuf_toString(paramNames),
levelstmp);
return 0;
#endif
}
static void draw_image_to_framebuffer(struct g2d_buf *buf, int img_width, int img_height, int img_format,
struct fb_var_screeninfo *screen_info, int left, int top, int to_width, int to_height, int set_alpha, int rotation)
{
int i;
struct g2d_surface src,dst;
void *g2dHandle;
if ( ( (left+to_width) > (int)screen_info->xres ) || ( (top+to_height) > (int)screen_info->yres ) ) {
printf("Bad display image dimensions!\n");
return;
}
#if CACHEABLE
g2d_cache_op(buf, G2D_CACHE_FLUSH);
#endif
if(g2d_open(&g2dHandle) == -1 || g2dHandle == NULL) {
printf("Fail to open g2d device!\n");
g2d_free(buf);
return;
}
/*
NOTE: in this example, all the test image data meet with the alignment requirement.
Thus, in your code, you need to pay attention on that.
Pixel buffer address alignment requirement,
RGB/BGR: pixel data in planes [0] with 16bytes alignment,
NV12/NV16: Y in planes [0], UV in planes [1], with 64bytes alignment,
I420: Y in planes [0], U in planes [1], V in planes [2], with 64 bytes alignment,
YV12: Y in planes [0], V in planes [1], U in planes [2], with 64 bytes alignment,
NV21/NV61: Y in planes [0], VU in planes [1], with 64bytes alignment,
YUYV/YVYU/UYVY/VYUY: in planes[0], buffer address is with 16bytes alignment.
*/
src.format = img_format;
switch (src.format) {
case G2D_RGB565:
case G2D_RGBA8888:
case G2D_RGBX8888:
case G2D_BGRA8888:
case G2D_BGRX8888:
case G2D_BGR565:
case G2D_YUYV:
case G2D_UYVY:
src.planes[0] = buf->buf_paddr;
break;
case G2D_NV12:
src.planes[0] = buf->buf_paddr;
src.planes[1] = buf->buf_paddr + img_width * img_height;
break;
case G2D_I420:
src.planes[0] = buf->buf_paddr;
src.planes[1] = buf->buf_paddr + img_width * img_height;
src.planes[2] = src.planes[1] + img_width * img_height / 4;
break;
case G2D_NV16:
src.planes[0] = buf->buf_paddr;
src.planes[1] = buf->buf_paddr + img_width * img_height;
break;
default:
printf("Unsupport image format in the example code\n");
return;
}
src.left = 0;
src.top = 0;
src.right = img_width;
src.bottom = img_height;
src.stride = img_width;
src.width = img_width;
src.height = img_height;
src.rot = G2D_ROTATION_0;
dst.planes[0] = g_fb_phys;
dst.left = left;
dst.top = top;
dst.right = left + to_width;
dst.bottom = top + to_height;
dst.stride = screen_info->xres;
dst.width = screen_info->xres;
dst.height = screen_info->yres;
dst.rot = rotation;
dst.format = screen_info->bits_per_pixel == 16 ? G2D_RGB565 : (screen_info->red.offset == 0 ? G2D_RGBA8888 : G2D_BGRA8888);
if (set_alpha)
{
src.blendfunc = G2D_ONE;
dst.blendfunc = G2D_ONE_MINUS_SRC_ALPHA;
src.global_alpha = 0x80;
dst.global_alpha = 0xff;
g2d_enable(g2dHandle, G2D_BLEND);
g2d_enable(g2dHandle, G2D_GLOBAL_ALPHA);
}
g2d_blit(g2dHandle, &src, &dst);
g2d_finish(g2dHandle);
if (set_alpha)
{
g2d_disable(g2dHandle, G2D_GLOBAL_ALPHA);
g2d_disable(g2dHandle, G2D_BLEND);
}
g2d_close(g2dHandle);
}
