//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
uint8_t* getRenderBuffer( uint32_t w, uint32_t h )
{
lockRenderBuffer();
// Resize if necessary.
if( w != state.renderBufWidth || h != state.renderBufHeight )
{
if( state.renderBufRGB565 != NULL )
{
fcvMemFree( state.renderBufRGB565 );
state.renderBufRGB565 = NULL;
state.renderBufSize = 0;
state.renderBufWidth = 0;
state.renderBufHeight = 0;
}
}
// Allocate if necessary.
if( state.renderBufRGB565 == NULL )
{
state.renderBufSize = w * h * 2;
state.renderBufRGB565 = (uint8_t*) fcvMemAlloc(state.renderBufSize, 16);
state.renderBufWidth = w;
state.renderBufHeight = h;
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glDisable(GL_DITHER);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_ONE, GL_SRC_COLOR);
// Initialize mutex
pthread_mutexattr_t attribute;
pthread_mutexattr_init( &attribute );
pthread_mutexattr_settype( &attribute, PTHREAD_MUTEX_NORMAL );
pthread_mutex_init( &state.mutex, &attribute );
pthread_mutexattr_destroy( &attribute );
}
unlockRenderBuffer();
return state.renderBufRGB565;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
JNIEXPORT void JNICALL Java_com_qualcomm_fastcvdemo_utils_FastCVSampleRenderer_render
(
JNIEnv * env,
jobject obj,
jbyteArray img,
jint w,
jint h
)
{
if( state.cameraRenderer == NULL )
{
state.cameraRenderer = new CameraRendererRGB565GL2();
if (state.cameraRenderer)
{
state.cameraRenderer->Init();
}
else
{
EPRINTF( "Unable to get Camera Render object\n" );
}
}
//if camera frame is ready, display that
if( state.cameraRenderer && state.renderBufRGB565 )
{
lockRenderBuffer();
state.cameraRenderer->Render
(
state.renderBufRGB565,
state.renderBufWidth,
state.renderBufHeight
);
unlockRenderBuffer();
//glFlush();
glFinish();
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
JNIEXPORT void JNICALL Java_com_qualcomm_fastcvdemo_apis_imageTransformation_Affine_update
(
JNIEnv* env,
jobject obj,
jbyteArray img,
jint w,
jint h
)
{
jbyte* jimgData = NULL;
jboolean isCopy = 0;
uint32_t* curCornerPtr = 0;
uint8_t* renderBuffer;
uint64_t time;
float timeMs;
// Allocate the buffer once here if it's not allocated already
if( affineState.affineImgBuf == NULL)
{
int frameSize = w*h*3/2;
affineState.affineImgBuf = (uint8_t *)fcvMemAlloc(frameSize, 16);
if( affineState.affineImgBuf == NULL )
{
EPRINTF("Allocate affineImgBuf failed");
}
else
{
memset(affineState.affineImgBuf, 0, w*h);
memset(affineState.affineImgBuf+(w*h), 128, w*h/2);
}
}
// Get data from JNI
jimgData = env->GetByteArrayElements( img, &isCopy );
renderBuffer = getRenderBuffer( w, h );
lockRenderBuffer();
time = util.getTimeMicroSeconds();
uint8_t* pJimgData = (uint8_t*)jimgData;
// Check if camera image data is not aligned.
if( (int)jimgData & 0xF )
{
// Allow for rescale if dimensions changed.
if( w != (int)affineState.alignedImgWidth ||
h != (int)affineState.alignedImgHeight )
{
if( affineState.alignedImgBuf != NULL )
{
DPRINTF( "%s %d Creating aligned for preview\n",
__FILE__, __LINE__ );
fcvMemFree( affineState.alignedImgBuf );
affineState.alignedImgBuf = NULL;
}
}
// Allocate buffer for aligned data if necessary.
if( affineState.alignedImgBuf == NULL )
{
affineState.alignedImgWidth = w;
affineState.alignedImgHeight = h;
affineState.alignedImgBuf = (uint8_t*)fcvMemAlloc( w*h*3/2, 16 );
}
memcpy( affineState.alignedImgBuf, jimgData, w*h*3/2 );
pJimgData = affineState.alignedImgBuf;
}
// Perform FastCV Function processing
switch( affineState.affineType )
{
case AFFINE_U8:
updateAffine( (uint8_t*)pJimgData, w, h, affineState.affineImgBuf);
colorConvertYUV420ToRGB565Renderer(affineState.affineImgBuf, w, h, (uint32_t*)renderBuffer );
break;
case AFFINE_8X8:
updateAffine( (uint8_t*)pJimgData, w, h, affineState.affineImgBuf);
colorConvertYUV420ToRGB565Renderer(affineState.affineImgBuf, w, h, (uint32_t*)renderBuffer );
break;
case NO_AFFINE:
default:
colorConvertYUV420ToRGB565Renderer(pJimgData, w, h, (uint32_t*)renderBuffer );
break;
}
// Update image
timeMs = ( util.getTimeMicroSeconds() - time ) / 1000.f;
util.setProcessTime((util.getProcessTime()*(29.f/30.f))+(float)(timeMs/30.f));
unlockRenderBuffer();
// Let JNI know we don't need data anymore
env->ReleaseByteArrayElements( img, jimgData, JNI_ABORT );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
JNIEXPORT void JNICALL Java_com_qualcomm_fastcvdemo_apis_imageProcessing_Filter_update
(
JNIEnv* env,
jobject obj,
jbyteArray img,
jint w,
jint h
)
{
jbyte* jimgData = NULL;
jboolean isCopy = 0;
uint32_t* curCornerPtr = 0;
uint8_t* renderBuffer;
uint64_t time;
float timeMs;
// Allocate the buffer once here if it's not allocated already
if( filterState.filteredImgBuf == NULL)
{
int frameSize = w*h*3/2;
filterState.filteredImgBuf = (uint8_t *)fcvMemAlloc(frameSize, 16);
if( filterState.filteredImgBuf == NULL )
{
EPRINTF("Allocate filteredImgBuf failed");
}
else
{
memset(filterState.filteredImgBuf, 128, frameSize);
}
}
// Get data from JNI
jimgData = env->GetByteArrayElements( img, &isCopy );
renderBuffer = getRenderBuffer( w, h );
lockRenderBuffer();
time = util.getTimeMicroSeconds();
// jimgData might not be 128 bit aligned.
// fcvColorYUV420toRGB565u8() and other fcv functionality inside
// require 128 bit memory aligned. In case of jimgData
// is not 128 bit aligned, it will allocate memory that is 128 bit
// aligned and copies jimgData to the aligned memory.
uint8_t* pJimgData = (uint8_t*)jimgData;
uint8_t* pFilteringData = (uint8_t*)filterState.filteredImgBuf;
// Check if camera image data is not aligned.
if( (int)jimgData & 0xF )
{
// Allow for rescale if dimensions changed.
if( w != (int)filterState.imgWidth ||
h != (int)filterState.imgHeight )
{
if( filterState.alignedImgBuf != NULL )
{
DPRINTF( "%s %d Creating aligned for preview\n",
__FILE__, __LINE__ );
fcvMemFree( filterState.alignedImgBuf );
filterState.alignedImgBuf = NULL;
}
}
// Allocate buffer for aligned data if necessary.
if( filterState.alignedImgBuf == NULL )
{
filterState.imgWidth = w;
filterState.imgHeight = h;
filterState.alignedImgBuf = (uint8_t*)fcvMemAlloc( w*h*3/2, 16 );
}
memcpy( filterState.alignedImgBuf, jimgData, w*h*3/2 );
pJimgData = filterState.alignedImgBuf;
}
else if( w != (int)filterState.imgWidth ||
h != (int)filterState.imgHeight )
{
filterState.imgWidth = w;
filterState.imgHeight = h;
}
// Perform FastCV Function processing
updateFilter( (uint8_t*)pJimgData, w, h, (uint8_t*)pFilteringData );
// Copy the image first in our own buffer to avoid corruption during
// rendering. Not that we can still have corruption in image while we do
// copy but we can't help that.
colorConvertYUV420ToRGB565Renderer(pFilteringData,
w,
h,
(uint32_t*)renderBuffer );
// Update image
timeMs = ( util.getTimeMicroSeconds() - time ) / 1000.f;
util.setProcessTime((util.getProcessTime()*(29.f/30.f))+(float)(timeMs/30.f));
if( filterState.filterType == ENABLE_CANNY )
{
drawEdges(filterState.edgeImgBuf, filterState.edgeImgHeight, filterState.edgeImgWidth);
}
unlockRenderBuffer();
// Let JNI know we don't need data anymore
env->ReleaseByteArrayElements( img, jimgData, JNI_ABORT );
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
JNIEXPORT void JNICALL
Java_com_qualcomm_fastcvdemo_apis_imageProcessing_ImgDiff_update
(
JNIEnv* env,
jobject obj,
jbyteArray img,
jint w,
jint h
)
{
jbyte* jimgData = NULL;
jboolean isCopy = 0;
uint32_t* curCornerPtr = 0;
uint8_t* renderBuffer;
uint64_t time;
float timeMs;
// Get data from JNI
jimgData = env->GetByteArrayElements( img, &isCopy );
DPRINTF("ImgDiff: update");
renderBuffer = getRenderBuffer( w, h );
lockRenderBuffer();
time = util.getTimeMicroSeconds();
// Allocate the buffer once here if it's not allocated already
if( imgDiffState.referenceImgBuf == NULL)
{
imgDiffState.referenceImgBuf = (uint8_t *)fcvMemAlloc(w*h*3/2, 16);
if( imgDiffState.referenceImgBuf == NULL )
{
EPRINTF("Allocate referenceImgBuf failed");
}
}
// Allocate the buffer once here if it's not allocated already
if( imgDiffState.diffImgBuf == NULL)
{
int frameSize = w*h*3/2;
imgDiffState.diffImgBuf = (uint8_t *)fcvMemAlloc(frameSize, 16);
if( imgDiffState.diffImgBuf == NULL )
{
EPRINTF("Allocate diffImgBuf failed");
}
else
{
memset(imgDiffState.diffImgBuf, 0, w*h);
memset(imgDiffState.diffImgBuf+(w*h), 128, w*h/2);
}
}
uint8_t* pJimgData = (uint8_t*)jimgData;
uint8_t* pDiffData = (uint8_t*)imgDiffState.diffImgBuf;
// jimgData might not be 128 bit aligned.
// fcvColorYUV420toRGB565u8() and other fcv functionality inside
// require 128 bit memory aligned. In case of jimgData
// is not 128 bit aligned, it will allocate memory that is 128 bit
// aligned and copies jimgData to the aligned memory.
// Check if camera image data is not aligned.
if( (int)jimgData & 0xF )
{
// Allow for rescale if dimensions changed.
if( w != (int)imgDiffState.alignedImgWidth ||
h != (int)imgDiffState.alignedImgHeight )
{
if( imgDiffState.alignedImgBuf != NULL )
{
DPRINTF( "%s %d Creating aligned for preview\n",
__FILE__, __LINE__ );
fcvMemFree( imgDiffState.alignedImgBuf );
imgDiffState.alignedImgBuf = NULL;
}
}
// Allocate buffer for aligned data if necessary.
if( imgDiffState.alignedImgBuf == NULL )
{
imgDiffState.alignedImgWidth = w;
imgDiffState.alignedImgHeight = h;
imgDiffState.alignedImgBuf = (uint8_t*)fcvMemAlloc( w*h*3/2, 16 );
}
memcpy( imgDiffState.alignedImgBuf, jimgData, w*h*3/2 );
pJimgData = imgDiffState.alignedImgBuf;
}
uint8_t* pPreviewData = pJimgData;
//Handles reference frame state
switch( imgDiffState.diffState )
{
case NO_REF_FRAME:
break;
case TAKE_REF_FRAME:
DPRINTF("In take frame");
memcpy(imgDiffState.referenceImgBuf, pPreviewData, w*h);
imgDiffState.diffState = HAS_REF_FRAME;
DPRINTF("ImgDiff: taken frame");
break;
case HAS_REF_FRAME:
updateDiff( imgDiffState.referenceImgBuf, pJimgData, w, h, pDiffData );
pPreviewData = pDiffData;
break;
case NEED_RESET:
imgDiffState.diffState = NO_REF_FRAME;
break;
default:
break;
}
colorConvertYUV420ToRGB565Renderer(pPreviewData,
w,
h,
(uint32_t*)renderBuffer );
// Update image
timeMs = ( util.getTimeMicroSeconds() - time ) / 1000.f;
util.setProcessTime((util.getProcessTime()*(29.f/30.f))+(float)(timeMs/30.f));
unlockRenderBuffer();
// Let JNI know we don't need data anymore
env->ReleaseByteArrayElements( img, jimgData, JNI_ABORT );
}
