/*
* Copyright (C) Texas Instruments - http://www.ti.com/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file V4LCameraAdapter.cpp
*
* This file maps the Camera Hardware Interface to V4L2.
*
*/
#include "V4LCameraAdapter.h"
#include "CameraHal.h"
#include "TICameraParameters.h"
#include "DebugUtils.h"
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/select.h>
#include <linux/videodev.h>
#include <ui/GraphicBuffer.h>
#include <ui/GraphicBufferMapper.h>
#include <cutils/properties.h>
#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
static int mDebugFps = 0;
#define Q16_OFFSET 16
#define HERE(Msg) {CAMHAL_LOGEB("--=== %s===--\n", Msg);}
namespace Ti {
namespace Camera {
//frames skipped before recalculating the framerate
#define FPS_PERIOD 30
//define this macro to save first few raw frames when starting the preview.
//#define SAVE_RAW_FRAMES 1
//#define DUMP_CAPTURE_FRAME 1
//#define PPM_PER_FRAME_CONVERSION 1
//Proto Types
static void convertYUV422i_yuyvTouyvy(uint8_t *src, uint8_t *dest, size_t size );
static void convertYUV422ToNV12Tiler(unsigned char *src, unsigned char *dest, int width, int height );
static void convertYUV422ToNV12(unsigned char *src, unsigned char *dest, int width, int height );
android::Mutex gV4LAdapterLock;
char device[15];
/*--------------------Camera Adapter Class STARTS here-----------------------------*/
/*--------------------V4L wrapper functions -------------------------------*/
status_t V4LCameraAdapter::v4lIoctl (int fd, int req, void* argp) {
status_t ret = NO_ERROR;
errno = 0;
do {
ret = ioctl (fd, req, argp);
}while (-1 == ret && EINTR == errno);
return ret;
}
status_t V4LCameraAdapter::v4lInitMmap(int& count) {
status_t ret = NO_ERROR;
//First allocate adapter internal buffers at V4L level for USB Cam
//These are the buffers from which we will copy the data into overlay buffers
/* Check if camera can handle NB_BUFFER buffers */
mVideoInfo->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->rb.memory = V4L2_MEMORY_MMAP;
mVideoInfo->rb.count = count;
ret = v4lIoctl(mCameraHandle, VIDIOC_REQBUFS, &mVideoInfo->rb);
if (ret < 0) {
CAMHAL_LOGEB("VIDIOC_REQBUFS failed: %s", strerror(errno));
return ret;
}
count = mVideoInfo->rb.count;
for (int i = 0; i < count; i++) {
memset (&mVideoInfo->buf, 0, sizeof (struct v4l2_buffer));
mVideoInfo->buf.index = i;
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
ret = v4lIoctl (mCameraHandle, VIDIOC_QUERYBUF, &mVideoInfo->buf);
if (ret < 0) {
CAMHAL_LOGEB("Unable to query buffer (%s)", strerror(errno));
return ret;
}
mVideoInfo->mem[i] = mmap (NULL,
mVideoInfo->buf.length,
PROT_READ | PROT_WRITE,
MAP_SHARED,
mCameraHandle,
mVideoInfo->buf.m.offset);
CAMHAL_LOGVB(" mVideoInfo->mem[%d]=%p ; mVideoInfo->buf.length = %d", i, mVideoInfo->mem[i], mVideoInfo->buf.length);
if (mVideoInfo->mem[i] == MAP_FAILED) {
CAMHAL_LOGEB("Unable to map buffer [%d]. (%s)", i, strerror(errno));
return -1;
}
}
return ret;
}
status_t V4LCameraAdapter::v4lInitUsrPtr(int& count) {
status_t ret = NO_ERROR;
mVideoInfo->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->rb.memory = V4L2_MEMORY_USERPTR;
mVideoInfo->rb.count = count;
ret = v4lIoctl(mCameraHandle, VIDIOC_REQBUFS, &mVideoInfo->rb);
if (ret < 0) {
CAMHAL_LOGEB("VIDIOC_REQBUFS failed for USERPTR: %s", strerror(errno));
return ret;
}
count = mVideoInfo->rb.count;
return ret;
}
status_t V4LCameraAdapter::v4lStartStreaming () {
status_t ret = NO_ERROR;
enum v4l2_buf_type bufType;
if (!mVideoInfo->isStreaming) {
bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ret = v4lIoctl (mCameraHandle, VIDIOC_STREAMON, &bufType);
if (ret < 0) {
CAMHAL_LOGEB("StartStreaming: Unable to start capture: %s", strerror(errno));
return ret;
}
mVideoInfo->isStreaming = true;
}
return ret;
}
status_t V4LCameraAdapter::v4lStopStreaming (int nBufferCount) {
status_t ret = NO_ERROR;
enum v4l2_buf_type bufType;
if (mVideoInfo->isStreaming) {
bufType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ret = v4lIoctl (mCameraHandle, VIDIOC_STREAMOFF, &bufType);
if (ret < 0) {
CAMHAL_LOGEB("StopStreaming: Unable to stop capture: %s", strerror(errno));
goto EXIT;
}
mVideoInfo->isStreaming = false;
/* Unmap buffers */
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
for (int i = 0; i < nBufferCount; i++) {
if (munmap(mVideoInfo->mem[i], mVideoInfo->buf.length) < 0) {
CAMHAL_LOGEA("munmap() failed");
}
}
//free the memory allocated during REQBUFS, by setting the count=0
mVideoInfo->rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->rb.memory = V4L2_MEMORY_MMAP;
mVideoInfo->rb.count = 0;
ret = v4lIoctl(mCameraHandle, VIDIOC_REQBUFS, &mVideoInfo->rb);
if (ret < 0) {
CAMHAL_LOGEB("VIDIOC_REQBUFS failed: %s", strerror(errno));
goto EXIT;
}
}
EXIT:
return ret;
}
status_t V4LCameraAdapter::v4lSetFormat (int width, int height, uint32_t pix_format) {
status_t ret = NO_ERROR;
mVideoInfo->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
ret = v4lIoctl(mCameraHandle, VIDIOC_G_FMT, &mVideoInfo->format);
if (ret < 0) {
CAMHAL_LOGEB("VIDIOC_G_FMT Failed: %s", strerror(errno));
}
mVideoInfo->width = width;
mVideoInfo->height = height;
mVideoInfo->framesizeIn = (width * height << 1);
mVideoInfo->formatIn = DEFAULT_PIXEL_FORMAT;
mVideoInfo->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->format.fmt.pix.width = width;
mVideoInfo->format.fmt.pix.height = height;
mVideoInfo->format.fmt.pix.pixelformat = pix_format;
ret = v4lIoctl(mCameraHandle, VIDIOC_S_FMT, &mVideoInfo->format);
if (ret < 0) {
CAMHAL_LOGEB("VIDIOC_S_FMT Failed: %s", strerror(errno));
return ret;
}
v4lIoctl(mCameraHandle, VIDIOC_G_FMT, &mVideoInfo->format);
CAMHAL_LOGDB("VIDIOC_G_FMT : WxH = %dx%d", mVideoInfo->format.fmt.pix.width, mVideoInfo->format.fmt.pix.height);
return ret;
}
status_t V4LCameraAdapter::restartPreview ()
{
status_t ret = NO_ERROR;
int width = 0;
int height = 0;
struct v4l2_streamparm streamParams;
//configure for preview size and pixel format.
mParams.getPreviewSize(&width, &height);
ret = v4lSetFormat (width, height, DEFAULT_PIXEL_FORMAT);
if (ret < 0) {
CAMHAL_LOGEB("v4lSetFormat Failed: %s", strerror(errno));
goto EXIT;
}
ret = v4lInitMmap(mPreviewBufferCount);
if (ret < 0) {
CAMHAL_LOGEB("v4lInitMmap Failed: %s", strerror(errno));
goto EXIT;
}
//set frame rate
streamParams.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
streamParams.parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
streamParams.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
streamParams.parm.capture.timeperframe.denominator = FPS_PERIOD;
streamParams.parm.capture.timeperframe.numerator= 1;
ret = v4lIoctl(mCameraHandle, VIDIOC_S_PARM, &streamParams);
if (ret < 0) {
CAMHAL_LOGEB("VIDIOC_S_PARM Failed: %s", strerror(errno));
goto EXIT;
}
for (int i = 0; i < mPreviewBufferCountQueueable; i++) {
mVideoInfo->buf.index = i;
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
if (ret < 0) {
CAMHAL_LOGEA("VIDIOC_QBUF Failed");
goto EXIT;
}
nQueued++;
}
ret = v4lStartStreaming();
CAMHAL_LOGDA("Ready for preview....");
EXIT:
return ret;
}
/*--------------------Camera Adapter Functions-----------------------------*/
status_t V4LCameraAdapter::initialize(CameraProperties::Properties* caps)
{
char value[PROPERTY_VALUE_MAX];
LOG_FUNCTION_NAME;
property_get("debug.camera.showfps", value, "0");
mDebugFps = atoi(value);
int ret = NO_ERROR;
// Allocate memory for video info structure
mVideoInfo = (struct VideoInfo *) calloc (1, sizeof (struct VideoInfo));
if(!mVideoInfo) {
ret = NO_MEMORY;
goto EXIT;
}
if ((mCameraHandle = open(device, O_RDWR | O_NONBLOCK) ) == -1) {
CAMHAL_LOGEB("Error while opening handle to V4L2 Camera: %s", strerror(errno));
ret = BAD_VALUE;
goto EXIT;
}
ret = v4lIoctl (mCameraHandle, VIDIOC_QUERYCAP, &mVideoInfo->cap);
if (ret < 0) {
CAMHAL_LOGEA("Error when querying the capabilities of the V4L Camera");
ret = BAD_VALUE;
goto EXIT;
}
if ((mVideoInfo->cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
CAMHAL_LOGEA("Error while adapter initialization: video capture not supported.");
ret = BAD_VALUE;
goto EXIT;
}
if (!(mVideoInfo->cap.capabilities & V4L2_CAP_STREAMING)) {
CAMHAL_LOGEA("Error while adapter initialization: Capture device does not support streaming i/o");
ret = BAD_VALUE;
goto EXIT;
}
// Initialize flags
mPreviewing = false;
mVideoInfo->isStreaming = false;
mRecording = false;
mCapturing = false;
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::fillThisBuffer(CameraBuffer *frameBuf, CameraFrame::FrameType frameType)
{
status_t ret = NO_ERROR;
int idx = 0;
LOG_FUNCTION_NAME;
if ( frameType == CameraFrame::IMAGE_FRAME) { //(1 > mCapturedFrames)
// Signal end of image capture
if ( NULL != mEndImageCaptureCallback) {
CAMHAL_LOGDB("===========Signal End Image Capture==========");
mEndImageCaptureCallback(mEndCaptureData);
}
goto EXIT;
}
if ( !mVideoInfo->isStreaming ) {
goto EXIT;
}
idx = mPreviewBufs.valueFor(frameBuf);
if(idx < 0) {
CAMHAL_LOGEB("Wrong index = %d",idx);
goto EXIT;
}
mVideoInfo->buf.index = idx;
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
if (ret < 0) {
CAMHAL_LOGEA("VIDIOC_QBUF Failed");
goto EXIT;
}
nQueued++;
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::setParameters(const android::CameraParameters ¶ms)
{
status_t ret = NO_ERROR;
int width, height;
struct v4l2_streamparm streamParams;
LOG_FUNCTION_NAME;
if(!mPreviewing && !mCapturing) {
params.getPreviewSize(&width, &height);
CAMHAL_LOGDB("Width * Height %d x %d format 0x%x", width, height, DEFAULT_PIXEL_FORMAT);
ret = v4lSetFormat( width, height, DEFAULT_PIXEL_FORMAT);
if (ret < 0) {
CAMHAL_LOGEB(" VIDIOC_S_FMT Failed: %s", strerror(errno));
goto EXIT;
}
//set frame rate
// Now its fixed to 30 FPS
streamParams.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
streamParams.parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
streamParams.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
streamParams.parm.capture.timeperframe.denominator = FPS_PERIOD;
streamParams.parm.capture.timeperframe.numerator= 1;
ret = v4lIoctl(mCameraHandle, VIDIOC_S_PARM, &streamParams);
if (ret < 0) {
CAMHAL_LOGEB(" VIDIOC_S_PARM Failed: %s", strerror(errno));
goto EXIT;
}
int actualFps = streamParams.parm.capture.timeperframe.denominator / streamParams.parm.capture.timeperframe.numerator;
CAMHAL_LOGDB("Actual FPS set is : %d.", actualFps);
}
// Udpate the current parameter set
mParams = params;
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
void V4LCameraAdapter::getParameters(android::CameraParameters& params)
{
LOG_FUNCTION_NAME;
// Return the current parameter set
params = mParams;
LOG_FUNCTION_NAME_EXIT;
}
///API to give the buffers to Adapter
status_t V4LCameraAdapter::useBuffers(CameraMode mode, CameraBuffer *bufArr, int num, size_t length, unsigned int queueable)
{
status_t ret = NO_ERROR;
LOG_FUNCTION_NAME;
android::AutoMutex lock(mLock);
switch(mode)
{
case CAMERA_PREVIEW:
mPreviewBufferCountQueueable = queueable;
ret = UseBuffersPreview(bufArr, num);
break;
case CAMERA_IMAGE_CAPTURE:
mCaptureBufferCountQueueable = queueable;
ret = UseBuffersCapture(bufArr, num);
break;
case CAMERA_VIDEO:
//@warn Video capture is not fully supported yet
mPreviewBufferCountQueueable = queueable;
ret = UseBuffersPreview(bufArr, num);
break;
case CAMERA_MEASUREMENT:
break;
default:
break;
}
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::UseBuffersCapture(CameraBuffer *bufArr, int num) {
int ret = NO_ERROR;
LOG_FUNCTION_NAME;
if(NULL == bufArr) {
ret = BAD_VALUE;
goto EXIT;
}
for (int i = 0; i < num; i++) {
//Associate each Camera internal buffer with the one from Overlay
mCaptureBufs.add(&bufArr[i], i);
CAMHAL_LOGDB("capture- buff [%d] = 0x%x ",i, mCaptureBufs.keyAt(i));
}
mCaptureBuffersAvailable.clear();
for (int i = 0; i < mCaptureBufferCountQueueable; i++ ) {
mCaptureBuffersAvailable.add(&mCaptureBuffers[i], 0);
}
// initial ref count for undeqeueued buffers is 1 since buffer provider
// is still holding on to it
for (int i = mCaptureBufferCountQueueable; i < num; i++ ) {
mCaptureBuffersAvailable.add(&mCaptureBuffers[i], 1);
}
// Update the preview buffer count
mCaptureBufferCount = num;
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::UseBuffersPreview(CameraBuffer *bufArr, int num)
{
int ret = NO_ERROR;
LOG_FUNCTION_NAME;
if(NULL == bufArr) {
ret = BAD_VALUE;
goto EXIT;
}
ret = v4lInitMmap(num);
if (ret == NO_ERROR) {
for (int i = 0; i < num; i++) {
//Associate each Camera internal buffer with the one from Overlay
mPreviewBufs.add(&bufArr[i], i);
CAMHAL_LOGDB("Preview- buff [%d] = 0x%x ",i, mPreviewBufs.keyAt(i));
}
// Update the preview buffer count
mPreviewBufferCount = num;
}
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::takePicture() {
status_t ret = NO_ERROR;
int width = 0;
int height = 0;
size_t yuv422i_buff_size = 0;
int index = 0;
char *fp = NULL;
CameraBuffer *buffer = NULL;
CameraFrame frame;
LOG_FUNCTION_NAME;
android::AutoMutex lock(mCaptureBufsLock);
if(mCapturing) {
CAMHAL_LOGEA("Already Capture in Progress...");
ret = BAD_VALUE;
goto EXIT;
}
mCapturing = true;
mPreviewing = false;
// Stop preview streaming
ret = v4lStopStreaming(mPreviewBufferCount);
if (ret < 0 ) {
CAMHAL_LOGEB("v4lStopStreaming Failed: %s", strerror(errno));
goto EXIT;
}
//configure for capture image size and pixel format.
mParams.getPictureSize(&width, &height);
CAMHAL_LOGDB("Image Capture Size WxH = %dx%d",width,height);
yuv422i_buff_size = width * height * 2;
ret = v4lSetFormat (width, height, DEFAULT_PIXEL_FORMAT);
if (ret < 0) {
CAMHAL_LOGEB("v4lSetFormat Failed: %s", strerror(errno));
goto EXIT;
}
ret = v4lInitMmap(mCaptureBufferCount);
if (ret < 0) {
CAMHAL_LOGEB("v4lInitMmap Failed: %s", strerror(errno));
goto EXIT;
}
for (int i = 0; i < mCaptureBufferCountQueueable; i++) {
mVideoInfo->buf.index = i;
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
if (ret < 0) {
CAMHAL_LOGEA("VIDIOC_QBUF Failed");
ret = BAD_VALUE;
goto EXIT;
}
nQueued++;
}
ret = v4lStartStreaming();
if (ret < 0) {
CAMHAL_LOGEB("v4lStartStreaming Failed: %s", strerror(errno));
goto EXIT;
}
CAMHAL_LOGDA("Streaming started for Image Capture");
//get the frame and send to encode as JPG
fp = this->GetFrame(index);
if(!fp) {
CAMHAL_LOGEA("!!! Captured frame is NULL !!!!");
ret = BAD_VALUE;
goto EXIT;
}
CAMHAL_LOGDA("::Capture Frame received from V4L::");
buffer = mCaptureBufs.keyAt(index);
CAMHAL_LOGVB("## captureBuf[%d] = 0x%x, yuv422i_buff_size=%d", index, buffer->opaque, yuv422i_buff_size);
//copy the yuv422i data to the image buffer.
memcpy(buffer->opaque, fp, yuv422i_buff_size);
#ifdef DUMP_CAPTURE_FRAME
//dump the YUV422 buffer in to a file
//a folder should have been created at /data/misc/camera/raw/
{
int fd =-1;
fd = open("/data/misc/camera/raw/captured_yuv422i_dump.yuv", O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
if(fd < 0) {
CAMHAL_LOGEB("Unable to open file: %s", strerror(fd));
}
else {
write(fd, fp, yuv422i_buff_size );
close(fd);
CAMHAL_LOGDB("::Captured Frame dumped at /data/misc/camera/raw/captured_yuv422i_dump.yuv::");
}
}
#endif
CAMHAL_LOGDA("::sending capture frame to encoder::");
frame.mFrameType = CameraFrame::IMAGE_FRAME;
frame.mBuffer = buffer;
frame.mLength = yuv422i_buff_size;
frame.mWidth = width;
frame.mHeight = height;
frame.mAlignment = width*2;
frame.mOffset = 0;
frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
frame.mFrameMask = (unsigned int)CameraFrame::IMAGE_FRAME;
frame.mQuirks |= CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG;
frame.mQuirks |= CameraFrame::FORMAT_YUV422I_YUYV;
ret = setInitFrameRefCount(frame.mBuffer, frame.mFrameMask);
if (ret != NO_ERROR) {
CAMHAL_LOGDB("Error in setInitFrameRefCount %d", ret);
} else {
ret = sendFrameToSubscribers(&frame);
}
// Stop streaming after image capture
ret = v4lStopStreaming(mCaptureBufferCount);
if (ret < 0 ) {
CAMHAL_LOGEB("v4lStopStreaming Failed: %s", strerror(errno));
goto EXIT;
}
ret = restartPreview();
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::stopImageCapture()
{
status_t ret = NO_ERROR;
LOG_FUNCTION_NAME;
//Release image buffers
if ( NULL != mReleaseImageBuffersCallback ) {
mReleaseImageBuffersCallback(mReleaseData);
}
mCaptureBufs.clear();
mCapturing = false;
mPreviewing = true;
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::autoFocus()
{
status_t ret = NO_ERROR;
LOG_FUNCTION_NAME;
//autoFocus is not implemented. Just return.
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::startPreview()
{
status_t ret = NO_ERROR;
LOG_FUNCTION_NAME;
android::AutoMutex lock(mPreviewBufsLock);
if(mPreviewing) {
ret = BAD_VALUE;
goto EXIT;
}
for (int i = 0; i < mPreviewBufferCountQueueable; i++) {
mVideoInfo->buf.index = i;
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
ret = v4lIoctl(mCameraHandle, VIDIOC_QBUF, &mVideoInfo->buf);
if (ret < 0) {
CAMHAL_LOGEA("VIDIOC_QBUF Failed");
goto EXIT;
}
nQueued++;
}
ret = v4lStartStreaming();
// Create and start preview thread for receiving buffers from V4L Camera
if(!mCapturing) {
mPreviewThread = new PreviewThread(this);
CAMHAL_LOGDA("Created preview thread");
}
//Update the flag to indicate we are previewing
mPreviewing = true;
mCapturing = false;
EXIT:
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::stopPreview()
{
enum v4l2_buf_type bufType;
int ret = NO_ERROR;
LOG_FUNCTION_NAME;
android::AutoMutex lock(mStopPreviewLock);
if(!mPreviewing) {
return NO_INIT;
}
mPreviewing = false;
ret = v4lStopStreaming(mPreviewBufferCount);
if (ret < 0) {
CAMHAL_LOGEB("StopStreaming: FAILED: %s", strerror(errno));
}
nQueued = 0;
nDequeued = 0;
mFramesWithEncoder = 0;
mPreviewBufs.clear();
mPreviewThread->requestExitAndWait();
mPreviewThread.clear();
LOG_FUNCTION_NAME_EXIT;
return ret;
}
char * V4LCameraAdapter::GetFrame(int &index)
{
int ret = NO_ERROR;
LOG_FUNCTION_NAME;
mVideoInfo->buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
mVideoInfo->buf.memory = V4L2_MEMORY_MMAP;
/* DQ */
// Some V4L drivers, notably uvc, protect each incoming call with
// a driver-wide mutex. If we use poll() or blocking VIDIOC_DQBUF ioctl
// here then we sometimes would run into a deadlock on VIDIO_QBUF ioctl.
while(true) {
if(!mVideoInfo->isStreaming) {
return NULL;
}
ret = v4lIoctl(mCameraHandle, VIDIOC_DQBUF, &mVideoInfo->buf);
if((ret == 0) || (errno != EAGAIN)) {
break;
}
}
if (ret < 0) {
CAMHAL_LOGEA("GetFrame: VIDIOC_DQBUF Failed");
return NULL;
}
nDequeued++;
index = mVideoInfo->buf.index;
LOG_FUNCTION_NAME_EXIT;
return (char *)mVideoInfo->mem[mVideoInfo->buf.index];
}
//API to get the frame size required to be allocated. This size is used to override the size passed
//by camera service when VSTAB/VNF is turned ON for example
status_t V4LCameraAdapter::getFrameSize(size_t &width, size_t &height)
{
status_t ret = NO_ERROR;
LOG_FUNCTION_NAME;
// Just return the current preview size, nothing more to do here.
mParams.getPreviewSize(( int * ) &width,
( int * ) &height);
LOG_FUNCTION_NAME_EXIT;
return ret;
}
status_t V4LCameraAdapter::getFrameDataSize(size_t &dataFrameSize, size_t bufferCount)
{
// We don't support meta data, so simply return
return NO_ERROR;
}
status_t V4LCameraAdapter::getPictureBufferSize(CameraFrame &frame, size_t bufferCount)
{
int width = 0;
int height = 0;
int bytesPerPixel = 2; // for YUV422i; default pixel format
LOG_FUNCTION_NAME;
mParams.getPictureSize( &width, &height );
frame.mLength = width * height * bytesPerPixel;
frame.mWidth = width;
frame.mHeight = height;
frame.mAlignment = width * bytesPerPixel;
CAMHAL_LOGDB("Picture size: W x H = %u x %u (size=%u bytes, alignment=%u bytes)",
frame.mWidth, frame.mHeight, frame.mLength, frame.mAlignment);
LOG_FUNCTION_NAME_EXIT;
return NO_ERROR;
}
static void debugShowFPS()
{
static int mFrameCount = 0;
static int mLastFrameCount = 0;
static nsecs_t mLastFpsTime = 0;
static float mFps = 0;
if(mDebugFps) {
mFrameCount++;
if (!(mFrameCount & 0x1F)) {
nsecs_t now = systemTime();
nsecs_t diff = now - mLastFpsTime;
mFps = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
mLastFpsTime = now;
mLastFrameCount = mFrameCount;
CAMHAL_LOGI("Camera %d Frames, %f FPS", mFrameCount, mFps);
}
}
}
status_t V4LCameraAdapter::recalculateFPS()
{
float currentFPS;
mFrameCount++;
if ( ( mFrameCount % FPS_PERIOD ) == 0 )
{
nsecs_t now = systemTime();
nsecs_t diff = now - mLastFPSTime;
currentFPS = ((mFrameCount - mLastFrameCount) * float(s2ns(1))) / diff;
mLastFPSTime = now;
mLastFrameCount = mFrameCount;
if ( 1 == mIter )
{
mFPS = currentFPS;
}
else
{
//cumulative moving average
mFPS = mLastFPS + (currentFPS - mLastFPS)/mIter;
}
mLastFPS = mFPS;
mIter++;
}
return NO_ERROR;
}
void V4LCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
{
LOG_FUNCTION_NAME;
LOG_FUNCTION_NAME_EXIT;
}
V4LCameraAdapter::V4LCameraAdapter(size_t sensor_index)
{
LOG_FUNCTION_NAME;
// Nothing useful to do in the constructor
mFramesWithEncoder = 0;
LOG_FUNCTION_NAME_EXIT;
}
V4LCameraAdapter::~V4LCameraAdapter()
{
LOG_FUNCTION_NAME;
// Close the camera handle and free the video info structure
close(mCameraHandle);
if (mVideoInfo)
{
free(mVideoInfo);
mVideoInfo = NULL;
}
LOG_FUNCTION_NAME_EXIT;
}
static void convertYUV422i_yuyvTouyvy(uint8_t *src, uint8_t *dest, size_t size ) {
//convert YUV422I yuyv to uyvy format.
uint32_t *bf = (uint32_t*)src;
uint32_t *dst = (uint32_t*)dest;
LOG_FUNCTION_NAME;
if (!src || !dest) {
return;
}
for(size_t i = 0; i < size; i = i+4)
{
dst[0] = ((bf[0] & 0x00FF00FF) << 8) | ((bf[0] & 0xFF00FF00) >> 8);
bf++;
dst++;
}
LOG_FUNCTION_NAME_EXIT;
}
static void convertYUV422ToNV12Tiler(unsigned char *src, unsigned char *dest, int width, int height ) {
//convert YUV422I to YUV420 NV12 format and copies directly to preview buffers (Tiler memory).
int stride = 4096;
unsigned char *bf = src;
unsigned char *dst_y = dest;
unsigned char *dst_uv = dest + ( height * stride);
#ifdef PPM_PER_FRAME_CONVERSION
static int frameCount = 0;
static nsecs_t ppm_diff = 0;
nsecs_t ppm_start = systemTime();
#endif
LOG_FUNCTION_NAME;
if (width % 16 ) {
for(int i = 0; i < height; i++) {
for(int j = 0; j < width; j++) {
*dst_y = *bf;
dst_y++;
bf = bf + 2;
}
dst_y += (stride - width);
}
bf = src;
bf++; //UV sample
for(int i = 0; i < height/2; i++) {
for(int j=0; j<width; j++) {
*dst_uv = *bf;
dst_uv++;
bf = bf + 2;
}
bf = bf + width*2;
dst_uv = dst_uv + (stride - width);
}
} else {
//neon conversion
for(int i = 0; i < height; i++) {
int n = width;
int skip = i & 0x1; // skip uv elements for the odd rows
asm volatile (
" pld [%[src], %[src_stride], lsl #2] \n\t"
" cmp %[n], #16 \n\t"
" blt 5f \n\t"
"0: @ 16 pixel copy \n\t"
" vld2.8 {q0, q1} , [%[src]]! @ q0 = yyyy.. q1 = uvuv.. \n\t"
" @ now q0 = y q1 = uv \n\t"
" vst1.32 {d0,d1}, [%[dst_y]]! \n\t"
" cmp %[skip], #0 \n\t"
" bne 1f \n\t"
" vst1.32 {d2,d3},[%[dst_uv]]! \n\t"
"1: @ skip odd rows for UV \n\t"
" sub %[n], %[n], #16 \n\t"
" cmp %[n], #16 \n\t"
" bge 0b \n\t"
"5: @ end \n\t"
#ifdef NEEDS_ARM_ERRATA_754319_754320
" vmov s0,s0 @ add noop for errata item \n\t"
#endif
: [dst_y] "+r" (dst_y), [dst_uv] "+r" (dst_uv), [src] "+r" (src), [n] "+r" (n)
: [src_stride] "r" (width), [skip] "r" (skip)
: "cc", "memory", "q0", "q1", "q2", "d0", "d1", "d2", "d3"
);
dst_y = dst_y + (stride - width);
if (skip == 0) {
dst_uv = dst_uv + (stride - width);
}
} //end of for()
}
#ifdef PPM_PER_FRAME_CONVERSION
ppm_diff += (systemTime() - ppm_start);
frameCount++;
if (frameCount >= 30) {
ppm_diff = ppm_diff / frameCount;
LOGD("PPM: YUV422i to NV12 Conversion(%d x %d): %llu us ( %llu ms )", width, height,
ns2us(ppm_diff), ns2ms(ppm_diff) );
ppm_diff = 0;
frameCount = 0;
}
#endif
LOG_FUNCTION_NAME_EXIT;
}
static void convertYUV422ToNV12(unsigned char *src, unsigned char *dest, int width, int height ) {
//convert YUV422I to YUV420 NV12 format.
unsigned char *bf = src;
unsigned char *dst_y = dest;
unsigned char *dst_uv = dest + (width * height);
LOG_FUNCTION_NAME;
if (width % 16 ) {
for(int i = 0; i < height; i++) {
for(int j = 0; j < width; j++) {
*dst_y = *bf;
dst_y++;
bf = bf + 2;
}
}
bf = src;
bf++; //UV sample
for(int i = 0; i < height/2; i++) {
for(int j=0; j<width; j++) {
*dst_uv = *bf;
dst_uv++;
bf = bf + 2;
}
bf = bf + width*2;
}
} else {
//neon conversion
for(int i = 0; i < height; i++) {
int n = width;
int skip = i & 0x1; // skip uv elements for the odd rows
asm volatile (
" pld [%[src], %[src_stride], lsl #2] \n\t"
" cmp %[n], #16 \n\t"
" blt 5f \n\t"
"0: @ 16 pixel copy \n\t"
" vld2.8 {q0, q1} , [%[src]]! @ q0 = yyyy.. q1 = uvuv.. \n\t"
" @ now q0 = y q1 = uv \n\t"
" vst1.32 {d0,d1}, [%[dst_y]]! \n\t"
" cmp %[skip], #0 \n\t"
" bne 1f \n\t"
" vst1.32 {d2,d3},[%[dst_uv]]! \n\t"
"1: @ skip odd rows for UV \n\t"
" sub %[n], %[n], #16 \n\t"
" cmp %[n], #16 \n\t"
" bge 0b \n\t"
"5: @ end \n\t"
#ifdef NEEDS_ARM_ERRATA_754319_754320
" vmov s0,s0 @ add noop for errata item \n\t"
#endif
: [dst_y] "+r" (dst_y), [dst_uv] "+r" (dst_uv), [src] "+r" (src), [n] "+r" (n)
: [src_stride] "r" (width), [skip] "r" (skip)
: "cc", "memory", "q0", "q1", "q2", "d0", "d1", "d2", "d3"
);
}
}
LOG_FUNCTION_NAME_EXIT;
}
#ifdef SAVE_RAW_FRAMES
void saveFile(unsigned char* buff, int buff_size) {
static int counter = 1;
int fd = -1;
char fn[256];
LOG_FUNCTION_NAME;
if (counter > 3) {
return;
}
//dump nv12 buffer
counter++;
sprintf(fn, "/data/misc/camera/raw/nv12_dump_%03d.yuv", counter);
CAMHAL_LOGEB("Dumping nv12 frame to a file : %s.", fn);
fd = open(fn, O_CREAT | O_WRONLY | O_SYNC | O_TRUNC, 0777);
if(fd < 0) {
CAMHAL_LOGE("Unable to open file %s: %s", fn, strerror(fd));
return;
}
write(fd, buff, buff_size );
close(fd);
LOG_FUNCTION_NAME_EXIT;
}
#endif
/* Preview Thread */
// ---------------------------------------------------------------------------
int V4LCameraAdapter::previewThread()
{
status_t ret = NO_ERROR;
int width, height;
CameraFrame frame;
void *y_uv[2];
int index = 0;
int stride = 4096;
char *fp = NULL;
mParams.getPreviewSize(&width, &height);
if (mPreviewing) {
fp = this->GetFrame(index);
if(!fp) {
ret = BAD_VALUE;
goto EXIT;
}
CameraBuffer *buffer = mPreviewBufs.keyAt(index);
CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(buffer);
if (!lframe) {
ret = BAD_VALUE;
goto EXIT;
}
debugShowFPS();
if ( mFrameSubscribers.size() == 0 ) {
ret = BAD_VALUE;
goto EXIT;
}
y_uv[0] = (void*) lframe->mYuv[0];
//y_uv[1] = (void*) lframe->mYuv[1];
//y_uv[1] = (void*) (lframe->mYuv[0] + height*stride);
convertYUV422ToNV12Tiler ( (unsigned char*)fp, (unsigned char*)y_uv[0], width, height);
CAMHAL_LOGVB("##...index= %d.;camera buffer= 0x%x; y= 0x%x; UV= 0x%x.",index, buffer, y_uv[0], y_uv[1] );
#ifdef SAVE_RAW_FRAMES
unsigned char* nv12_buff = (unsigned char*) malloc(width*height*3/2);
//Convert yuv422i to yuv420sp(NV12) & dump the frame to a file
convertYUV422ToNV12 ( (unsigned char*)fp, nv12_buff, width, height);
saveFile( nv12_buff, ((width*height)*3/2) );
free (nv12_buff);
#endif
frame.mFrameType = CameraFrame::PREVIEW_FRAME_SYNC;
frame.mBuffer = buffer;
frame.mLength = width*height*3/2;
frame.mAlignment = stride;
frame.mOffset = 0;
frame.mTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
frame.mFrameMask = (unsigned int)CameraFrame::PREVIEW_FRAME_SYNC;
if (mRecording)
{
frame.mFrameMask |= (unsigned int)CameraFrame::VIDEO_FRAME_SYNC;
mFramesWithEncoder++;
}
ret = setInitFrameRefCount(frame.mBuffer, frame.mFrameMask);
if (ret != NO_ERROR) {
CAMHAL_LOGDB("Error in setInitFrameRefCount %d", ret);
} else {
ret = sendFrameToSubscribers(&frame);
}
}
EXIT:
return ret;
}
//scan for video devices
void detectVideoDevice(char** video_device_list, int& num_device) {
char dir_path[20];
char* filename;
char** dev_list = video_device_list;
DIR *d;
struct dirent *dir;
int index = 0;
strcpy(dir_path, DEVICE_PATH);
d = opendir(dir_path);
if(d) {
//read each entry in the /dev/ and find if there is videox entry.
while ((dir = readdir(d)) != NULL) {
filename = dir->d_name;
if (strncmp(filename, DEVICE_NAME, 5) == 0) {
strcpy(dev_list[index],DEVICE_PATH);
strncat(dev_list[index],filename,sizeof(DEVICE_NAME));
index++;
}
} //end of while()
closedir(d);
num_device = index;
for(int i=0; i<index; i++){
CAMHAL_LOGDB("Video device list::dev_list[%d]= %s",i,dev_list[i]);
}
}
}
extern "C" CameraAdapter* V4LCameraAdapter_Factory(size_t sensor_index)
{
CameraAdapter *adapter = NULL;
android::AutoMutex lock(gV4LAdapterLock);
LOG_FUNCTION_NAME;
adapter = new V4LCameraAdapter(sensor_index);
if ( adapter ) {
CAMHAL_LOGDB("New V4L Camera adapter instance created for sensor %d",sensor_index);
} else {
CAMHAL_LOGEA("V4L Camera adapter create failed for sensor index = %d!",sensor_index);
}
LOG_FUNCTION_NAME_EXIT;
return adapter;
}
extern "C" status_t V4LCameraAdapter_Capabilities(
CameraProperties::Properties * const properties_array,
const int starting_camera, const int max_camera, int & supportedCameras)
{
status_t ret = NO_ERROR;
struct v4l2_capability cap;
int tempHandle = NULL;
int num_cameras_supported = 0;
char device_list[5][15];
char* video_device_list[5];
int num_v4l_devices = 0;
int sensorId = 0;
CameraProperties::Properties* properties = NULL;
LOG_FUNCTION_NAME;
supportedCameras = 0;
memset((void*)&cap, 0, sizeof(v4l2_capability));
if (!properties_array) {
CAMHAL_LOGEB("invalid param: properties = 0x%p", properties_array);
LOG_FUNCTION_NAME_EXIT;
return BAD_VALUE;
}
for (int i = 0; i < 5; i++) {
video_device_list[i] = device_list[i];
}
//look for the connected video devices
detectVideoDevice(video_device_list, num_v4l_devices);
for (int i = 0; i < num_v4l_devices; i++) {
if ( (starting_camera + num_cameras_supported) < max_camera) {
sensorId = starting_camera + num_cameras_supported;
CAMHAL_LOGDB("Opening device[%d] = %s..",i, video_device_list[i]);
if ((tempHandle = open(video_device_list[i], O_RDWR)) == -1) {
CAMHAL_LOGEB("Error while opening handle to V4L2 Camera(%s): %s",video_device_list[i], strerror(errno));
continue;
}
ret = ioctl (tempHandle, VIDIOC_QUERYCAP, &cap);
if (ret < 0) {
CAMHAL_LOGEA("Error when querying the capabilities of the V4L Camera");
close(tempHandle);
continue;
}
//check for video capture devices
if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == 0) {
CAMHAL_LOGEA("Error while adapter initialization: video capture not supported.");
close(tempHandle);
continue;
}
strcpy(device, video_device_list[i]);
properties = properties_array + starting_camera + num_cameras_supported;
//fetch capabilities for this camera
ret = V4LCameraAdapter::getCaps( sensorId, properties, tempHandle );
if (ret < 0) {
CAMHAL_LOGEA("Error while getting capabilities.");
close(tempHandle);
continue;
}
num_cameras_supported++;
}
//For now exit this loop once a valid video capture device is found.
//TODO: find all V4L capture devices and it capabilities
break;
}//end of for() loop
supportedCameras = num_cameras_supported;
CAMHAL_LOGDB("Number of V4L cameras detected =%d", num_cameras_supported);
EXIT:
LOG_FUNCTION_NAME_EXIT;
close(tempHandle);
return NO_ERROR;
}
} // namespace Camera
} // namespace Ti
/*--------------------Camera Adapter Class ENDS here-----------------------------*/