USB Web Camera Test in SKT WIPI Emulator

WIPI SDK Camera Test
 - you have to have an USB Webcam(recommended Logitech device) for prepare to camera test in SKT WIPI SDK
 - below codes are not tested but have an enjoy! lol  ㅋㅋㅋ  --- June

* Simple Camera Test code

void cameraTest(void) {
M_Int32 ret = -1;
M_Int32 fd = 0;
M_Byte buf[2048];
MC_CameraInfo info;
MC_CameraOption option;
MC_CameraSnapshot snapshot;

M_Uint32 memID_pByteBuf = 0;
M_Byte* pByteBuf = NULL;

memset( (void*)buf, 0x00, sizeof(buf) );

// Open Camera
fd = OEMC_ioDevOpen( "Camera", 0, NULL );

if( fd )
MC_knlPrintk( "Open Camera [OK]\n" );
else {
MC_knlPrintk( "Open Camera [Fail]\n" );
return;
}

ret = OEMC_ioDevControl( fd, "GETSTATUS", &buf, (void*)sizeof(buf) );
if( !ret )
MC_knlPrintk( "Camera Status:\n%s\n", buf );
else {
MC_knlPrintk( "Camera Status [Fail]\n" );
return;
}

if( !ret )
ret = OEMC_ioDevControl( fd, "GETOPTION", &option, NULL );
else {
MC_knlPrintk( "GETOPTION [Fail]\n" );
return;
}

option.nPreviewWidth = 100;
option.nPreviewHeight = 100;
option.nPreviewPosX = 0;
option.nPreviewPosY = 0;
option.nCurrentResolution = 1;
 strncpy( option.szCurrentImageType, "image/jpeg", sizeof(option.szCurrentImageType) );
  
if( !ret )
ret = OEMC_ioDevControl( fd, "SETOPTION", &option, NULL );
else {
MC_knlPrintk( "SETOPTION [Fail]\n" );
return;
}

// Turn on Preview
if( !ret )
ret = OEMC_ioDevControl( fd, "SETPREVIEW", (void*)"on", NULL );
else {
MC_knlPrintk( "SETPREVIEW [Fail]\n" );
return;
}

 // Take a snapshot
ret = MC_ioDevControl( fd, "GETSNAPSHOT", &snapshot, NULL );
if( !ret ) {
if( memID_pByteBuf )
MC_knlFree( memID_pByteBuf );

memID_pByteBuf = MC_knlAlloc( snapshot.nImageDataSize );
pByteBuf = (M_Byte*)MC_GETDPTR( memID_pByteBuf );

if( pByteBuf )
memset( (void*)pByteBuf, 0x00, sizeof(snapshot.nImageDataSize) );
else {
MC_knlPrintk( "Allocates buffer [Fail]\n" );
memID_pByteBuf = 0;
return;
}

ret = MC_ioDevRead( fd, pByteBuf, snapshot.nImageDataSize );
if( ret ) { // read size
M_Int32 hFile;
M_Int32 retMkDir = 0;
M_Int32 flag = MC_FILE_OPEN_WRTRUNC;
M_Char* pFilename = "test_out.jpg";
M_Int32 len = snapshot.nImageDataSize;
M_Char* pFileExt = snapshot.szImageType;

hFile = MC_fsOpen( pFilename, flag, MC_DIR_PRIVATE_ACCESS );
if( hFile < 0 ) {
MC_knlPrintk( "Open a file to write [Fail]\n" );
return;
}

MC_fsSeek( hFile, 0, MC_FILE_SEEK_END );
MC_fsWrite( hFile, pByteBuf, len );
MC_fsClose( hFile );
}

  /*
{
M_Char retBuf[255] = { 0 };
M_Char* pFilename = "test_out2.jpg";
M_Int32 len = snapshot.nImageDataSize;

memset( (void*)retBuf, 0x00, sizeof(retBuf) );
strcpy( retBuf, "PHOTO" );
ret = MC_termResWrite( "PHOTO",
retBuf, sizeof(retBuf),
pFilename, "image/jpeg",
pByteBuf, len, MC_TERMRES_CREATE );
if( ret < 0 ) {
MC_knlPrintk( "MC_termResWrite [Fail]\n" );
return;
}
}
  */
}

// Release resource
if( fd ) ret = MC_ioDevClose( fd );
fd = 0;

if( memID_pByteBuf ) MC_knlFree( memID_pByteBuf );
memID_pByteBuf = 0;
}


* Camera image with mask-based foreground image
*  - NOT TESTED
{
 M_Int32 ret = -1;
M_Uint32 memID_pByteBufFrame = 0;
M_Byte* pByteBufFrame = NULL;
MC_CameraFrameInfo frameInfo;
MC_FileInfo fileInfo;
M_Int32 frameFileSize = 0;
M_Uint32 fd_res = 0;

#ifdef _VCDLL
if( MC_fsFileAttribute("PHOTO/test_frame.bmp", &fileInfo, MC_DIR_SYSTEM_ACCESS) < 0 ) {
MC_knlPrintk( "MC_fsFileAttribute [Fail]\n" );
return;
}
if( (fd_res = MC_fsOpen("PHOTO/test_frame.bmp", MC_FILE_OPEN_RDONLY, MC_DIR_SYSTEM_ACCESS)) < 0 ) {
MC_knlPrintk( "MC_fsOpen [Fail]\n" );
return;
}

frameFileSize = fileInfo.size;

if( memID_pByteBufFrame )
MC_knlFree( memID_pByteBufFrame );

memID_pByteBufFrame = MC_knlCalloc( frameFileSize );
if( memID_pByteBufFrame <= 0 ) {
MC_knlPrintk( "Allocates buffer [Fail]\n" );
}

pByteBufFrame = (M_Byte*)MC_GETDPTR( memID_pByteBufFrame );

if( MC_fsRead(fd_res, pByteBufFrame, frameFileSize) < 0 ) {
MC_knlPrintk( "MC_fsRead [Fail]\n" );

MC_knlFree( memID_pByteBufFrame );
MC_fsClose( fd_res );
return;
}

MC_fsClose( fd_res );
#else
frameFileSize = OEMC_termResGetSize( "PHOTO", "test_frame.bmp" );
if( frameFileSize < 0 ) {
MC_knlPrintk( OEMC_termResGetSize [Fail]\n" );
return;
}

if( memID_pByteBufFrame )
MC_knlFree( memID_pByteBufFrame );

memID_pByteBufFrame = MC_knlCalloc( frameFileSize );
if( memID_pByteBufFrame <= 0 ) {
MC_knlPrintk( "Allocates buffer [Fail]\n" );
}

pByteBufFrame = (M_Byte*)MC_GETDPTR( memID_pByteBufFrame );

if( OEMC_termResRead("PHOTO", "test_frame.bmp", pByteBufFrame, frameFileSize) < 0 ) {
MC_knlPrintk( "OEMC_termResRead [Fail]\n" );

MC_knlFree( memID_pByteBufFrame );
return;
}
#endif

//
// Frame
//
// Frame Image: Width(4 bytes), Height(4 bytes), 16 bit raw data (RGB: 565)
frameInfo.TransparencyColor = 0x00050605; // 0x00RRGGBB
frameInfo.pBmpBuffer = pByteBufFrame;
frameInfo.nBmpBufferSize = frameFileSize;
ret = OEMC_ioDevControl( fd, "SETFRAMEIMAGE", (void*)"on", &frameInfo );
if( ret < 0 ) {
MC_knlPrintk( "SETFRAMEIMAGE [Fail]\n" );
return;
}
}


-----
Cheers,
June