generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Android native camera: added BGR output format; added methods to configure output frame size.

Browse Source
This commit is contained in:
Andrey Kamaev 2011-04-18 08:50:24 +00:00
parent 1965b297d0
commit 31e77a3bd9
2 changed files with 277 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/highgui/include/opencv2/highgui/highgui_c.h
View File

@ -392,9 +392,8 @@ enum
//supported by Android camera output formats //supported by Android camera output formats
enum enum
{ {
CV_CAP_ANDROID_COLOR_FRAME = 1, //TODO: check RGB or BGR? CV_CAP_ANDROID_COLOR_FRAME = 0, //BGR
CV_CAP_ANDROID_GREY_FRAME = 0, CV_CAP_ANDROID_GREY_FRAME = 1 //Y
CV_CAP_ANDROID_YUV_FRAME = 2
}; };
/* retrieve or set capture properties */ /* retrieve or set capture properties */

443
modules/highgui/src/cap_android.cpp
View File

@ -1,4 +1,4 @@
/*M/////////////////////////////////////////////////////////////////////////////////////// /*M///////////////////////////////////////////////////////////////////////////////////////
// //
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
// //
@ -58,7 +58,7 @@ class HighguiAndroidCameraActivity;
class CvCapture_Android : public CvCapture class CvCapture_Android : public CvCapture
{ {
public: public:
CvCapture_Android(); CvCapture_Android(int);
virtual ~CvCapture_Android(); virtual ~CvCapture_Android();
virtual double getProperty(int propIdx); virtual double getProperty(int propIdx);
@ -81,66 +81,74 @@ protected:
CameraActivity* m_activity; CameraActivity* m_activity;
//raw from camera
int m_width;
int m_height;
unsigned char *m_frameYUV420i;
unsigned char *m_frameYUV420inext;
void setFrame(const void* buffer, int bufferSize);
private: private:
bool m_isOpened; bool m_isOpened;
bool m_CameraParamsChanged;
OutputMap *m_frameYUV; //frames counter for statistics
OutputMap *m_frameYUVnext; int m_framesGrabbed;
//cached converted frames
OutputMap m_frameGray; OutputMap m_frameGray;
OutputMap m_frameColor; OutputMap m_frameColor;
bool m_hasGray; bool m_hasGray;
bool m_hasColor; bool m_hasColor;
//synchronization
pthread_mutex_t m_nextFrameMutex; pthread_mutex_t m_nextFrameMutex;
pthread_cond_t m_nextFrameCond; pthread_cond_t m_nextFrameCond;
volatile bool m_waitingNextFrame; volatile bool m_waitingNextFrame;
int m_framesGrabbed; void prepareCacheForYUV420i(int width, int height);
static bool convertYUV420i2Grey(int width, int height, const unsigned char* yuv, cv::Mat& resmat);
static bool convertYUV420i2BGR888(int width, int height, const unsigned char* yuv, cv::Mat& resmat);
friend class HighguiAndroidCameraActivity; friend class HighguiAndroidCameraActivity;
void onFrame(const void* buffer, int bufferSize);
void convertBufferToYUV(const void* buffer, int size, int width, int height);
static bool convertYUVToGrey(const cv::Mat& yuv, cv::Mat& resmat);
static bool convertYUVToColor(const cv::Mat& yuv, cv::Mat& resmat);
}; };
class HighguiAndroidCameraActivity : public CameraActivity class HighguiAndroidCameraActivity : public CameraActivity
{ {
public: public:
HighguiAndroidCameraActivity(CvCapture_Android* capture) HighguiAndroidCameraActivity(CvCapture_Android* capture)
{ {
m_capture = capture; m_capture = capture;
m_framesReceived = 0; m_framesReceived = 0;
} }
virtual bool onFrameBuffer(void* buffer, int bufferSize) virtual bool onFrameBuffer(void* buffer, int bufferSize)
{ {
LOGD("buffer addr:%p size:%d",buffer, bufferSize); if(isConnected() && buffer != 0 && bufferSize > 0)
if(isConnected() && buffer != 0 && bufferSize > 0) {
{ m_framesReceived++;
m_framesReceived++; if (m_capture->m_waitingNextFrame)
if (m_capture->m_waitingNextFrame) {
{ m_capture->setFrame(buffer, bufferSize);
m_capture->onFrame(buffer, bufferSize); pthread_mutex_lock(&m_capture->m_nextFrameMutex);
pthread_mutex_lock(&m_capture->m_nextFrameMutex); m_capture->m_waitingNextFrame = false;//set flag that no more frames required at this moment
m_capture->m_waitingNextFrame = false;//set flag that no more frames required at this moment pthread_cond_broadcast(&m_capture->m_nextFrameCond);
pthread_cond_broadcast(&m_capture->m_nextFrameCond); pthread_mutex_unlock(&m_capture->m_nextFrameMutex);
pthread_mutex_unlock(&m_capture->m_nextFrameMutex); }
} return true;
return true; }
} return false;
return false;
} }
void LogFramesRate() void LogFramesRate()
{ {
LOGI("FRAMES received: %d grabbed: %d", m_framesReceived, m_capture->m_framesGrabbed); LOGI("FRAMES received: %d grabbed: %d", m_framesReceived, m_capture->m_framesGrabbed);
} }
private: private:
CvCapture_Android* m_capture; CvCapture_Android* m_capture;
int m_framesReceived; int m_framesReceived;
}; };
@ -154,195 +162,292 @@ IplImage* CvCapture_Android::OutputMap::getIplImagePtr()
return &iplHeader; return &iplHeader;
} }
CvCapture_Android::CvCapture_Android(int cameraId)
{
//defaults
m_width = 0;
m_height = 0;
m_activity = 0;
m_isOpened = false;
m_frameYUV420i = 0;
m_frameYUV420inext = 0;
m_hasGray = false;
m_hasColor = false;
m_waitingNextFrame = false;
m_framesGrabbed = 0;
m_CameraParamsChanged = false;
//try connect to camera
m_activity = new HighguiAndroidCameraActivity(this);
if (m_activity == 0) return;
pthread_mutex_init(&m_nextFrameMutex, NULL);
pthread_cond_init (&m_nextFrameCond, NULL);
CameraActivity::ErrorCode errcode = m_activity->connect(cameraId);
if(errcode == CameraActivity::NO_ERROR)
m_isOpened = true;
else
{
LOGE("Native_camera returned opening error: %d", errcode);
delete m_activity;
m_activity = 0;
}
}
bool CvCapture_Android::isOpened() const bool CvCapture_Android::isOpened() const
{ {
return m_isOpened; return m_isOpened;
} }
CvCapture_Android::CvCapture_Android()
{
//defaults
m_activity = 0;
m_isOpened = false;
m_frameYUV = 0;
m_frameYUVnext = 0;
m_hasGray = false;
m_hasColor = false;
m_waitingNextFrame = false;
m_framesGrabbed = 0;
//try connect to camera
m_activity = new HighguiAndroidCameraActivity(this);
if (m_activity == 0) return;
pthread_mutex_init(&m_nextFrameMutex, NULL);
pthread_cond_init (&m_nextFrameCond, NULL);
CameraActivity::ErrorCode errcode = m_activity->connect();
if(errcode == CameraActivity::NO_ERROR)
{
m_isOpened = true;
m_frameYUV = new OutputMap();
m_frameYUVnext = new OutputMap();
}
else
{
LOGE("Native_camera returned opening error: %d", errcode);
delete m_activity;
m_activity = 0;
}
}
CvCapture_Android::~CvCapture_Android() CvCapture_Android::~CvCapture_Android()
{ {
if (m_activity) if (m_activity)
{ {
((HighguiAndroidCameraActivity*)m_activity)->LogFramesRate(); ((HighguiAndroidCameraActivity*)m_activity)->LogFramesRate();
//m_activity->disconnect() will be automatically called inside destructor; //m_activity->disconnect() will be automatically called inside destructor;
delete m_activity; delete m_activity;
delete m_frameYUV; delete m_frameYUV420i;
delete m_frameYUVnext; delete m_frameYUV420inext;
m_activity = 0; m_activity = 0;
m_frameYUV = 0; m_frameYUV420i = 0;
m_frameYUVnext = 0; m_frameYUV420inext = 0;
pthread_mutex_destroy(&m_nextFrameMutex); pthread_mutex_destroy(&m_nextFrameMutex);
pthread_cond_destroy(&m_nextFrameCond); pthread_cond_destroy(&m_nextFrameCond);
} }
} }
double CvCapture_Android::getProperty( int propIdx ) double CvCapture_Android::getProperty( int propIdx )
{ {
switch ( propIdx ) switch ( propIdx )
{ {
case CV_CAP_PROP_FRAME_WIDTH: case CV_CAP_PROP_FRAME_WIDTH:
return (double)CameraActivity::getFrameWidth(); return (double)m_activity->getFrameWidth();
case CV_CAP_PROP_FRAME_HEIGHT: case CV_CAP_PROP_FRAME_HEIGHT:
return (double)CameraActivity::getFrameHeight(); return (double)m_activity->getFrameHeight();
default: default:
CV_Error( CV_StsError, "Failed attempt to GET unsupported camera property." ); CV_Error( CV_StsOutOfRange, "Failed attempt to GET unsupported camera property." );
break; break;
} }
return -1.0; return -1.0;
} }
bool CvCapture_Android::setProperty( int propIdx, double propValue ) bool CvCapture_Android::setProperty( int propIdx, double propValue )
{ {
bool res = false; bool res = false;
if( isOpened() ) if( isOpened() )
{
switch ( propIdx )
{ {
default: switch ( propIdx )
CV_Error( CV_StsError, "Failed attempt to SET unsupported camera property." ); {
break; case CV_CAP_PROP_FRAME_WIDTH:
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_FRAMEWIDTH, propValue);
break;
case CV_CAP_PROP_FRAME_HEIGHT:
m_activity->setProperty(ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT, propValue);
break;
default:
CV_Error( CV_StsOutOfRange, "Failed attempt to SET unsupported camera property." );
break;
}
m_CameraParamsChanged = true;
} }
}
return res; return res;
} }
bool CvCapture_Android::grabFrame() bool CvCapture_Android::grabFrame()
{ {
if( !isOpened() ) if( !isOpened() )
return false; return false;
pthread_mutex_lock(&m_nextFrameMutex); pthread_mutex_lock(&m_nextFrameMutex);
m_waitingNextFrame = true; if (m_CameraParamsChanged)
pthread_cond_wait(&m_nextFrameCond, &m_nextFrameMutex); {
pthread_mutex_unlock(&m_nextFrameMutex); m_activity->applyProperties();
m_framesGrabbed++; m_CameraParamsChanged = false;
return true; }
} m_waitingNextFrame = true;
pthread_cond_wait(&m_nextFrameCond, &m_nextFrameMutex);
pthread_mutex_unlock(&m_nextFrameMutex);
void CvCapture_Android::onFrame(const void* buffer, int bufferSize) m_framesGrabbed++;
{ return true;
LOGD("Buffer available: %p + %d", buffer, bufferSize);
convertBufferToYUV(buffer, bufferSize, CameraActivity::getFrameWidth(), CameraActivity::getFrameHeight());
//swap current and new frames
OutputMap* tmp = m_frameYUV;
m_frameYUV = m_frameYUVnext;
m_frameYUVnext = tmp;
//discard cached frames
m_hasGray = false;
m_hasColor = false;
} }
IplImage* CvCapture_Android::retrieveFrame( int outputType ) IplImage* CvCapture_Android::retrieveFrame( int outputType )
{ {
IplImage* image = 0; IplImage* image = 0;
if (0 != m_frameYUV && !m_frameYUV->mat.empty()) if (0 != m_frameYUV420i)
{
switch(outputType)
{ {
case CV_CAP_ANDROID_YUV_FRAME: switch(outputType)
image = m_frameYUV->getIplImagePtr(); {
break; case CV_CAP_ANDROID_COLOR_FRAME:
case CV_CAP_ANDROID_GREY_FRAME: if (!m_hasColor)
if (!m_hasGray) if (!(m_hasColor = convertYUV420i2BGR888(m_width, m_height, m_frameYUV420i, m_frameColor.mat)))
if (!(m_hasGray = convertYUVToGrey(m_frameYUV->mat, m_frameGray.mat))) return 0;
image = 0; image = m_frameColor.getIplImagePtr();
image = m_frameGray.getIplImagePtr(); break;
break; case CV_CAP_ANDROID_GREY_FRAME:
case CV_CAP_ANDROID_COLOR_FRAME: if (!m_hasGray)
if (!m_hasColor) if (!(m_hasGray = convertYUV420i2Grey(m_width, m_height, m_frameYUV420i, m_frameGray.mat)))
if (!(m_hasColor = convertYUVToColor(m_frameYUV->mat, m_frameColor.mat))) return 0;
image = 0; image = m_frameGray.getIplImagePtr();
image = m_frameColor.getIplImagePtr(); break;
break; default:
default: LOGE("Unsupported frame output format: %d", outputType);
LOGE("Unsupported frame output format: %d", outputType); CV_Error( CV_StsOutOfRange, "Output frame format is not supported." );
image = 0; image = 0;
break; break;
}
} }
} return image;
return image; }
void CvCapture_Android::setFrame(const void* buffer, int bufferSize)
{
int width = m_activity->getFrameWidth();
int height = m_activity->getFrameHeight();
int expectedSize = (width * height * 3) >> 1;
if ( expectedSize != bufferSize)
{
LOGE("ERROR reading YUV420i buffer: width=%d, height=%d, size=%d, receivedSize=%d", width, height, expectedSize, bufferSize);
return;
}
//allocate memery if needed
prepareCacheForYUV420i(width, height);
//copy data
memcpy(m_frameYUV420inext, buffer, bufferSize);
//swap current and new frames
unsigned char* tmp = m_frameYUV420i;
m_frameYUV420i = m_frameYUV420inext;
m_frameYUV420inext = tmp;
//discard cached frames
m_hasGray = false;
m_hasColor = false;
}
void CvCapture_Android::prepareCacheForYUV420i(int width, int height)
{
if (width != m_width || height != m_height)
{
m_width = width;
m_height = height;
unsigned char *tmp = m_frameYUV420inext;
m_frameYUV420inext = new unsigned char [width * height * 3 / 2];
delete[] tmp;
tmp = m_frameYUV420i;
m_frameYUV420i = new unsigned char [width * height * 3 / 2];
delete[] tmp;
}
}
inline unsigned char clamp(int value)
{
if (value <= 0)
return 0;
if (value >= 255)
return (unsigned char)255;
return (unsigned char)value;
} }
void CvCapture_Android::convertBufferToYUV(const void* buffer, int size, int width, int height) bool CvCapture_Android::convertYUV420i2Grey(int width, int height, const unsigned char* yuv, cv::Mat& resmat)
{ {
cv::Size buffSize(width, height + (height / 2)); if (yuv == 0) return false;
if (buffSize.area() != size)
{
LOGE("ERROR convertBufferToYuv_Mat: width=%d, height=%d, buffSize=%d x %d, buffSize.area()=%d, size=%d",
width, height, buffSize.width, buffSize.height, buffSize.area(), size);
return; resmat.create(width, height, CV_8UC1);
} unsigned char* matBuff = resmat.ptr<unsigned char> (0);
memcpy(matBuff, yuv, width * height);
m_frameYUVnext->mat.create(buffSize, CV_8UC1); return !resmat.empty();
uchar* matBuff = m_frameYUVnext->mat.ptr<uchar> (0);
memcpy(matBuff, buffer, size);
} }
bool CvCapture_Android::convertYUVToGrey(const cv::Mat& yuv, cv::Mat& resmat) bool CvCapture_Android::convertYUV420i2BGR888(int width, int height, const unsigned char* yuv, cv::Mat& resmat)
{ {
if (yuv.empty()) if (yuv == 0) return false;
return false; CV_Assert(width % 2 == 0 && height % 2 == 0);
resmat = yuv(cv::Range(0, yuv.rows * (2.0f / 3)), cv::Range::all()); resmat.create(height, width, CV_8UC3);
return !resmat.empty(); unsigned char* y1 = (unsigned char*)yuv;
} unsigned char* uv = y1 + width * height;
bool CvCapture_Android::convertYUVToColor(const cv::Mat& yuv, cv::Mat& resmat) //B = 1.164(Y - 16) + 2.018(U - 128)
{ //G = 1.164(Y - 16) - 0.813(V - 128) - 0.391(U - 128)
if (yuv.empty()) //R = 1.164(Y - 16) + 1.596(V - 128)
return false;
cv::cvtColor(yuv, resmat, CV_YUV2RGB); for (int j = 0; j < height; j+=2, y1+=width*2, uv+=width)
return !resmat.empty(); {
unsigned char* row1 = resmat.ptr<unsigned char>(j);
unsigned char* row2 = resmat.ptr<unsigned char>(j+1);
unsigned char* y2 = y1 + width;
for(int i = 0; i < width; i+=2,row1+=6,row2+=6)
{
// unsigned char cr = uv[i];
// unsigned char cb = uv[i+1];
// row1[0] = y1[i];
// row1[1] = cr;
// row1[2] = cb;
// row1[3] = y1[i+1];
// row1[4] = cr;
// row1[5] = cb;
// row2[0] = y2[i];
// row2[1] = cr;
// row2[2] = cb;
// row2[3] = y2[i+1];
// row2[4] = cr;
// row2[5] = cb;
int cr = uv[i] - 128;
int cb = uv[i+1] - 128;
int ruv = 409 * cr + 128;
int guv = 128 - 100 * cb - 208 * cr;
int buv = 516 * cb + 128;
int y00 = (y1[i] - 16) * 298;
row1[0] = clamp((y00 + buv) >> 8);
row1[1] = clamp((y00 + guv) >> 8);
row1[2] = clamp((y00 + ruv) >> 8);
int y01 = (y1[i+1] - 16) * 298;
row1[3] = clamp((y01 + buv) >> 8);
row1[4] = clamp((y01 + guv) >> 8);
row1[5] = clamp((y01 + ruv) >> 8);
int y10 = (y2[i] - 16) * 298;
row2[0] = clamp((y10 + buv) >> 8);
row2[1] = clamp((y10 + guv) >> 8);
row2[2] = clamp((y10 + ruv) >> 8);
int y11 = (y2[i+1] - 16) * 298;
row2[3] = clamp((y11 + buv) >> 8);
row2[4] = clamp((y11 + guv) >> 8);
row2[5] = clamp((y11 + ruv) >> 8);
}
}
return !resmat.empty();
} }
CvCapture* cvCreateCameraCapture_Android( int /*index*/ ) CvCapture* cvCreateCameraCapture_Android( int cameraId )
{ {
CvCapture_Android* capture = new CvCapture_Android(); CvCapture_Android* capture = new CvCapture_Android(cameraId);
if( capture->isOpened() ) if( capture->isOpened() )
return capture; return capture;