1563 lines
47 KiB
C++
1563 lines
47 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
|
|
|
|
#ifndef ANDROID_HARDWARE_CAMERA_HARDWARE_H
|
|
#define ANDROID_HARDWARE_CAMERA_HARDWARE_H
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <time.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <hardware/camera.h>
|
|
#include <utils/Log.h>
|
|
#include <utils/threads.h>
|
|
#include <utils/threads.h>
|
|
#include <binder/MemoryBase.h>
|
|
#include <binder/MemoryHeapBase.h>
|
|
#include <camera/CameraParameters.h>
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
#include <camera/CameraMetadata.h>
|
|
#include <camera/ShotParameters.h>
|
|
#endif
|
|
#include <ui/GraphicBufferAllocator.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
|
|
/* For IMG_native_handle_t */
|
|
#include <ui/GraphicBufferMapper.h>
|
|
#include <hal_public.h>
|
|
|
|
#ifdef USE_TI_LIBION
|
|
#include <ion_ti/ion.h>
|
|
#else
|
|
#include <ion/ion.h>
|
|
#include "ion_ti_custom.h"
|
|
#endif
|
|
|
|
#include "Common.h"
|
|
#include "MessageQueue.h"
|
|
#include "Semaphore.h"
|
|
#include "CameraProperties.h"
|
|
#include "SensorListener.h"
|
|
|
|
//temporarily define format here
|
|
#define HAL_PIXEL_FORMAT_TI_NV12 0x100
|
|
#define HAL_PIXEL_FORMAT_TI_Y8 0x103
|
|
#define HAL_PIXEL_FORMAT_TI_Y16 0x104
|
|
#define HAL_PIXEL_FORMAT_TI_UYVY 0x105
|
|
|
|
#define MIN_WIDTH 640
|
|
#define MIN_HEIGHT 480
|
|
#define PICTURE_WIDTH 3264 /* 5mp - 2560. 8mp - 3280 */ /* Make sure it is a multiple of 16. */
|
|
#define PICTURE_HEIGHT 2448 /* 5mp - 2048. 8mp - 2464 */ /* Make sure it is a multiple of 16. */
|
|
#define PREVIEW_WIDTH 176
|
|
#define PREVIEW_HEIGHT 144
|
|
#define PIXEL_FORMAT V4L2_PIX_FMT_UYVY
|
|
|
|
#define VIDEO_FRAME_COUNT_MAX 8 //NUM_OVERLAY_BUFFERS_REQUESTED
|
|
#define MAX_CAMERA_BUFFERS 8 //NUM_OVERLAY_BUFFERS_REQUESTED
|
|
#define MAX_ZOOM 3
|
|
#define THUMB_WIDTH 80
|
|
#define THUMB_HEIGHT 60
|
|
#define PIX_YUV422I 0
|
|
#define PIX_YUV420P 1
|
|
|
|
#define SATURATION_OFFSET 100
|
|
#define SHARPNESS_OFFSET 100
|
|
#define CONTRAST_OFFSET 100
|
|
|
|
#ifdef MOTOROLA_CAMERA
|
|
#define DEFAULT_INTENSITY 100
|
|
#define FLASH_VOLTAGE_THRESHOLD1 3700000 // intensity will be reduced to 50% below threshold1
|
|
#define FLASH_VOLTAGE_THRESHOLD2 3300000 // flash disabled below threshold2
|
|
#endif
|
|
|
|
#define FRAME_RATE_HIGH_HD 60
|
|
|
|
#define CAMHAL_GRALLOC_USAGE GRALLOC_USAGE_HW_TEXTURE | \
|
|
GRALLOC_USAGE_HW_RENDER | \
|
|
GRALLOC_USAGE_SW_READ_RARELY | \
|
|
GRALLOC_USAGE_SW_WRITE_NEVER
|
|
|
|
//Enables Absolute PPM measurements in logcat
|
|
#define PPM_INSTRUMENTATION_ABS 1
|
|
|
|
#define LOCK_BUFFER_TRIES 5
|
|
#define HAL_PIXEL_FORMAT_NV12 0x100
|
|
|
|
#define OP_STR_SIZE 100
|
|
|
|
#define NONNEG_ASSIGN(x,y) \
|
|
if(x > -1) \
|
|
y = x
|
|
|
|
#define CAMHAL_SIZE_OF_ARRAY(x) static_cast<int>(sizeof(x)/sizeof(x[0]))
|
|
|
|
namespace Ti {
|
|
namespace Camera {
|
|
|
|
#ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING
|
|
extern const char * const kRawImagesOutputDirPath;
|
|
extern const char * const kYuvImagesOutputDirPath;
|
|
#endif
|
|
#define V4L_CAMERA_NAME_USB "USBCAMERA"
|
|
#define OMX_CAMERA_NAME_OV "OV5640"
|
|
#define OMX_CAMERA_NAME_SONY "IMX060"
|
|
#ifdef MOTOROLA_CAMERA
|
|
#define OMX_CAMERA_NAME_OV8820 "OV8820"
|
|
#define OMX_CAMERA_NAME_OV7739 "OV7739"
|
|
#define OMX_CAMERA_NAME_MT9M114 "MT9M114"
|
|
#endif
|
|
|
|
|
|
///Forward declarations
|
|
class CameraHal;
|
|
class CameraFrame;
|
|
class CameraHalEvent;
|
|
class DisplayFrame;
|
|
|
|
class FpsRange {
|
|
public:
|
|
static int compare(const FpsRange * left, const FpsRange * right);
|
|
|
|
FpsRange(int min, int max);
|
|
FpsRange();
|
|
|
|
bool operator==(const FpsRange & fpsRange) const;
|
|
|
|
bool isNull() const;
|
|
bool isFixed() const;
|
|
|
|
int min() const;
|
|
int max() const;
|
|
|
|
private:
|
|
int mMin;
|
|
int mMax;
|
|
};
|
|
|
|
|
|
inline int FpsRange::compare(const FpsRange * const left, const FpsRange * const right) {
|
|
if ( left->max() < right->max() ) {
|
|
return -1;
|
|
}
|
|
|
|
if ( left->max() > right->max() ) {
|
|
return 1;
|
|
}
|
|
|
|
if ( left->min() < right->min() ) {
|
|
return -1;
|
|
}
|
|
|
|
if ( left->min() > right->min() ) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
inline FpsRange::FpsRange(const int min, const int max) : mMin(min), mMax(max) {}
|
|
|
|
inline FpsRange::FpsRange() : mMin(-1), mMax(-1) {}
|
|
|
|
inline bool FpsRange::operator==(const FpsRange & fpsRange) const {
|
|
return mMin == fpsRange.mMin && mMax == fpsRange.mMax;
|
|
}
|
|
|
|
inline bool FpsRange::isNull() const {
|
|
return mMin == -1 || mMax == -1;
|
|
}
|
|
|
|
inline bool FpsRange::isFixed() const {
|
|
return mMin == mMax;
|
|
}
|
|
|
|
inline int FpsRange::min() const { return mMin; }
|
|
|
|
inline int FpsRange::max() const { return mMax; }
|
|
|
|
class CameraArea : public android::RefBase
|
|
{
|
|
public:
|
|
|
|
CameraArea(ssize_t top,
|
|
ssize_t left,
|
|
ssize_t bottom,
|
|
ssize_t right,
|
|
size_t weight) : mTop(top),
|
|
mLeft(left),
|
|
mBottom(bottom),
|
|
mRight(right),
|
|
mWeight(weight) {}
|
|
|
|
status_t transfrom(size_t width,
|
|
size_t height,
|
|
size_t &top,
|
|
size_t &left,
|
|
size_t &areaWidth,
|
|
size_t &areaHeight);
|
|
|
|
bool isValid()
|
|
{
|
|
return ( ( 0 != mTop ) || ( 0 != mLeft ) || ( 0 != mBottom ) || ( 0 != mRight) );
|
|
}
|
|
|
|
bool isZeroArea()
|
|
{
|
|
return ( (0 == mTop ) && ( 0 == mLeft ) && ( 0 == mBottom )
|
|
&& ( 0 == mRight ) && ( 0 == mWeight ));
|
|
}
|
|
|
|
size_t getWeight()
|
|
{
|
|
return mWeight;
|
|
}
|
|
|
|
bool compare(const android::sp<CameraArea> &area);
|
|
|
|
static status_t parseAreas(const char *area,
|
|
size_t areaLength,
|
|
android::Vector< android::sp<CameraArea> > &areas);
|
|
|
|
static status_t checkArea(ssize_t top,
|
|
ssize_t left,
|
|
ssize_t bottom,
|
|
ssize_t right,
|
|
ssize_t weight);
|
|
|
|
static bool areAreasDifferent(android::Vector< android::sp<CameraArea> > &, android::Vector< android::sp<CameraArea> > &);
|
|
|
|
protected:
|
|
static const ssize_t TOP = -1000;
|
|
static const ssize_t LEFT = -1000;
|
|
static const ssize_t BOTTOM = 1000;
|
|
static const ssize_t RIGHT = 1000;
|
|
static const ssize_t WEIGHT_MIN = 1;
|
|
static const ssize_t WEIGHT_MAX = 1000;
|
|
|
|
ssize_t mTop;
|
|
ssize_t mLeft;
|
|
ssize_t mBottom;
|
|
ssize_t mRight;
|
|
size_t mWeight;
|
|
};
|
|
|
|
class CameraMetadataResult : public android::RefBase
|
|
{
|
|
public:
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
CameraMetadataResult(camera_memory_t * extMeta) : mExtendedMetadata(extMeta) {
|
|
mMetadata.faces = NULL;
|
|
mMetadata.number_of_faces = 0;
|
|
#ifdef OMAP_ENHANCEMENT
|
|
mMetadata.analog_gain = 0;
|
|
mMetadata.exposure_time = 0;
|
|
#endif
|
|
};
|
|
#endif
|
|
|
|
CameraMetadataResult() {
|
|
mMetadata.faces = NULL;
|
|
mMetadata.number_of_faces = 0;
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
mMetadata.analog_gain = 0;
|
|
mMetadata.exposure_time = 0;
|
|
#endif
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
mExtendedMetadata = NULL;
|
|
#endif
|
|
}
|
|
|
|
virtual ~CameraMetadataResult() {
|
|
if ( NULL != mMetadata.faces ) {
|
|
free(mMetadata.faces);
|
|
}
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
if ( NULL != mExtendedMetadata ) {
|
|
mExtendedMetadata->release(mExtendedMetadata);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
camera_frame_metadata_t *getMetadataResult() { return &mMetadata; };
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
camera_memory_t *getExtendedMetadata() { return mExtendedMetadata; };
|
|
#endif
|
|
|
|
static const ssize_t TOP = -1000;
|
|
static const ssize_t LEFT = -1000;
|
|
static const ssize_t BOTTOM = 1000;
|
|
static const ssize_t RIGHT = 1000;
|
|
static const ssize_t INVALID_DATA = -2000;
|
|
|
|
private:
|
|
|
|
camera_frame_metadata_t mMetadata;
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
camera_memory_t *mExtendedMetadata;
|
|
#endif
|
|
};
|
|
|
|
typedef enum {
|
|
CAMERA_BUFFER_NONE = 0,
|
|
CAMERA_BUFFER_GRALLOC,
|
|
CAMERA_BUFFER_ANW,
|
|
CAMERA_BUFFER_MEMORY,
|
|
CAMERA_BUFFER_ION
|
|
} CameraBufferType;
|
|
|
|
typedef struct _CameraBuffer {
|
|
CameraBufferType type;
|
|
/* opaque is the generic drop-in replacement for the pointers
|
|
* that were used previously */
|
|
void *opaque;
|
|
|
|
/* opaque has different meanings depending on the buffer type:
|
|
* GRALLOC - gralloc_handle_t
|
|
* ANW - a pointer to the buffer_handle_t (which corresponds to
|
|
* the ANativeWindowBuffer *)
|
|
* MEMORY - address of allocated memory
|
|
* ION - address of mapped ion allocation
|
|
*
|
|
* FIXME opaque should be split into several fields:
|
|
* - handle/pointer we got from the allocator
|
|
* - handle/value we pass to OMX
|
|
* - pointer to mapped memory (if the buffer is mapped)
|
|
*/
|
|
|
|
/* mapped holds ptr to mapped memory in userspace */
|
|
void *mapped;
|
|
|
|
/* These are specific to ION buffers */
|
|
struct ion_handle * ion_handle;
|
|
int ion_fd;
|
|
int fd;
|
|
size_t size;
|
|
int index;
|
|
|
|
/* These describe the camera buffer */
|
|
int width;
|
|
int stride;
|
|
int height;
|
|
const char *format;
|
|
|
|
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
|
|
|
|
struct timeval ppmStamp;
|
|
|
|
#endif
|
|
|
|
/* These are for buffers which include borders */
|
|
int offset; // where valid data starts
|
|
int actual_size; // size of the entire buffer with borders
|
|
int privateData;
|
|
} CameraBuffer;
|
|
|
|
void * camera_buffer_get_omx_ptr (CameraBuffer *buffer);
|
|
|
|
class CameraFrame
|
|
{
|
|
public:
|
|
|
|
enum FrameType
|
|
{
|
|
PREVIEW_FRAME_SYNC = 0x1, ///SYNC implies that the frame needs to be explicitly returned after consuming in order to be filled by camera again
|
|
PREVIEW_FRAME = 0x2 , ///Preview frame includes viewfinder and snapshot frames
|
|
IMAGE_FRAME_SYNC = 0x4, ///Image Frame is the image capture output frame
|
|
IMAGE_FRAME = 0x8,
|
|
VIDEO_FRAME_SYNC = 0x10, ///Timestamp will be updated for these frames
|
|
VIDEO_FRAME = 0x20,
|
|
FRAME_DATA_SYNC = 0x40, ///Any extra data assosicated with the frame. Always synced with the frame
|
|
FRAME_DATA= 0x80,
|
|
RAW_FRAME = 0x100,
|
|
SNAPSHOT_FRAME = 0x200,
|
|
REPROCESS_INPUT_FRAME = 0x400,
|
|
ALL_FRAMES = 0xFFFF ///Maximum of 16 frame types supported
|
|
};
|
|
|
|
enum FrameQuirks
|
|
{
|
|
ENCODE_RAW_YUV422I_TO_JPEG = 0x1 << 0,
|
|
HAS_EXIF_DATA = 0x1 << 1,
|
|
FORMAT_YUV422I_YUYV = 0x1 << 2,
|
|
FORMAT_YUV422I_UYVY = 0x1 << 3,
|
|
};
|
|
|
|
//default contrustor
|
|
CameraFrame():
|
|
mCookie(NULL),
|
|
mCookie2(NULL),
|
|
mBuffer(NULL),
|
|
mFrameType(0),
|
|
mTimestamp(0),
|
|
mWidth(0),
|
|
mHeight(0),
|
|
mOffset(0),
|
|
mAlignment(0),
|
|
mFd(0),
|
|
mLength(0),
|
|
mFrameMask(0),
|
|
mQuirks(0)
|
|
{
|
|
mYuv[0] = 0; // NULL is meant for pointers
|
|
mYuv[1] = 0; // NULL is meant for pointers
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
mMetaData = 0;
|
|
#endif
|
|
}
|
|
|
|
void *mCookie;
|
|
void *mCookie2;
|
|
CameraBuffer *mBuffer;
|
|
int mFrameType;
|
|
nsecs_t mTimestamp;
|
|
unsigned int mWidth, mHeight;
|
|
uint32_t mOffset;
|
|
unsigned int mAlignment;
|
|
int mFd;
|
|
size_t mLength;
|
|
unsigned mFrameMask;
|
|
unsigned int mQuirks;
|
|
unsigned int mYuv[2];
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
android::sp<CameraMetadataResult> mMetaData;
|
|
#endif
|
|
///@todo add other member vars like stride etc
|
|
};
|
|
|
|
enum CameraHalError
|
|
{
|
|
CAMERA_ERROR_FATAL = 0x1, //Fatal errors can only be recovered by restarting media server
|
|
CAMERA_ERROR_HARD = 0x2, // Hard errors are hardware hangs that may be recoverable by resetting the hardware internally within the adapter
|
|
CAMERA_ERROR_SOFT = 0x4, // Soft errors are non fatal errors that can be recovered from without needing to stop use-case
|
|
};
|
|
|
|
///Common Camera Hal Event class which is visible to CameraAdapter,DisplayAdapter and AppCallbackNotifier
|
|
///@todo Rename this class to CameraEvent
|
|
class CameraHalEvent
|
|
{
|
|
public:
|
|
//Enums
|
|
enum CameraHalEventType {
|
|
NO_EVENTS = 0x0,
|
|
EVENT_FOCUS_LOCKED = 0x1,
|
|
EVENT_FOCUS_ERROR = 0x2,
|
|
EVENT_ZOOM_INDEX_REACHED = 0x4,
|
|
EVENT_SHUTTER = 0x8,
|
|
EVENT_METADATA = 0x10,
|
|
///@remarks Future enum related to display, like frame displayed event, could be added here
|
|
ALL_EVENTS = 0xFFFF ///Maximum of 16 event types supported
|
|
};
|
|
|
|
enum FocusStatus {
|
|
FOCUS_STATUS_SUCCESS = 0x1,
|
|
FOCUS_STATUS_FAIL = 0x2,
|
|
FOCUS_STATUS_PENDING = 0x4,
|
|
FOCUS_STATUS_DONE = 0x8,
|
|
};
|
|
|
|
///Class declarations
|
|
///@remarks Add a new class for a new event type added above
|
|
|
|
//Shutter event specific data
|
|
typedef struct ShutterEventData_t {
|
|
bool shutterClosed;
|
|
}ShutterEventData;
|
|
|
|
///Focus event specific data
|
|
typedef struct FocusEventData_t {
|
|
FocusStatus focusStatus;
|
|
int currentFocusValue;
|
|
} FocusEventData;
|
|
|
|
///Zoom specific event data
|
|
typedef struct ZoomEventData_t {
|
|
int currentZoomIndex;
|
|
bool targetZoomIndexReached;
|
|
} ZoomEventData;
|
|
|
|
typedef struct FaceData_t {
|
|
ssize_t top;
|
|
ssize_t left;
|
|
ssize_t bottom;
|
|
ssize_t right;
|
|
size_t score;
|
|
} FaceData;
|
|
|
|
typedef android::sp<CameraMetadataResult> MetaEventData;
|
|
|
|
class CameraHalEventData : public android::RefBase{
|
|
|
|
public:
|
|
|
|
CameraHalEvent::FocusEventData focusEvent;
|
|
CameraHalEvent::ZoomEventData zoomEvent;
|
|
CameraHalEvent::ShutterEventData shutterEvent;
|
|
CameraHalEvent::MetaEventData metadataEvent;
|
|
};
|
|
|
|
//default contrustor
|
|
CameraHalEvent():
|
|
mCookie(NULL),
|
|
mEventType(NO_EVENTS) {}
|
|
|
|
//copy constructor
|
|
CameraHalEvent(const CameraHalEvent &event) :
|
|
mCookie(event.mCookie),
|
|
mEventType(event.mEventType),
|
|
mEventData(event.mEventData) {};
|
|
|
|
void* mCookie;
|
|
CameraHalEventType mEventType;
|
|
android::sp<CameraHalEventData> mEventData;
|
|
|
|
};
|
|
|
|
/// Have a generic callback class based on template - to adapt CameraFrame and Event
|
|
typedef void (*frame_callback) (CameraFrame *cameraFrame);
|
|
typedef void (*event_callback) (CameraHalEvent *event);
|
|
|
|
//signals CameraHAL to relase image buffers
|
|
typedef void (*release_image_buffers_callback) (void *userData);
|
|
typedef void (*end_image_capture_callback) (void *userData);
|
|
|
|
/**
|
|
* Interface class implemented by classes that have some events to communicate to dependendent classes
|
|
* Dependent classes use this interface for registering for events
|
|
*/
|
|
class MessageNotifier
|
|
{
|
|
public:
|
|
static const uint32_t EVENT_BIT_FIELD_POSITION;
|
|
static const uint32_t FRAME_BIT_FIELD_POSITION;
|
|
|
|
///@remarks Msg type comes from CameraFrame and CameraHalEvent classes
|
|
/// MSB 16 bits is for events and LSB 16 bits is for frame notifications
|
|
/// FrameProvider and EventProvider classes act as helpers to event/frame
|
|
/// consumers to call this api
|
|
virtual void enableMsgType(int32_t msgs, frame_callback frameCb=NULL, event_callback eventCb=NULL, void* cookie=NULL) = 0;
|
|
virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
|
|
|
|
virtual ~MessageNotifier() {};
|
|
};
|
|
|
|
class ErrorNotifier : public virtual android::RefBase
|
|
{
|
|
public:
|
|
virtual void errorNotify(int error) = 0;
|
|
|
|
virtual ~ErrorNotifier() {};
|
|
};
|
|
|
|
|
|
/**
|
|
* Interace class abstraction for Camera Adapter to act as a frame provider
|
|
* This interface is fully implemented by Camera Adapter
|
|
*/
|
|
class FrameNotifier : public MessageNotifier
|
|
{
|
|
public:
|
|
virtual void returnFrame(CameraBuffer* frameBuf, CameraFrame::FrameType frameType) = 0;
|
|
virtual void addFramePointers(CameraBuffer *frameBuf, void *buf) = 0;
|
|
virtual void removeFramePointers() = 0;
|
|
|
|
virtual ~FrameNotifier() {};
|
|
};
|
|
|
|
/** * Wrapper class around Frame Notifier, which is used by display and notification classes for interacting with Camera Adapter
|
|
*/
|
|
class FrameProvider
|
|
{
|
|
FrameNotifier* mFrameNotifier;
|
|
void* mCookie;
|
|
frame_callback mFrameCallback;
|
|
|
|
public:
|
|
FrameProvider(FrameNotifier *fn, void* cookie, frame_callback frameCallback)
|
|
:mFrameNotifier(fn), mCookie(cookie),mFrameCallback(frameCallback) { }
|
|
|
|
int enableFrameNotification(int32_t frameTypes);
|
|
int disableFrameNotification(int32_t frameTypes);
|
|
int returnFrame(CameraBuffer *frameBuf, CameraFrame::FrameType frameType);
|
|
void addFramePointers(CameraBuffer *frameBuf, void *buf);
|
|
void removeFramePointers();
|
|
};
|
|
|
|
/** Wrapper class around MessageNotifier, which is used by display and notification classes for interacting with
|
|
* Camera Adapter
|
|
*/
|
|
class EventProvider
|
|
{
|
|
public:
|
|
MessageNotifier* mEventNotifier;
|
|
void* mCookie;
|
|
event_callback mEventCallback;
|
|
|
|
public:
|
|
EventProvider(MessageNotifier *mn, void* cookie, event_callback eventCallback)
|
|
:mEventNotifier(mn), mCookie(cookie), mEventCallback(eventCallback) {}
|
|
|
|
int enableEventNotification(int32_t eventTypes);
|
|
int disableEventNotification(int32_t eventTypes);
|
|
};
|
|
|
|
/*
|
|
* Interface for providing buffers
|
|
*/
|
|
class BufferProvider
|
|
{
|
|
public:
|
|
virtual CameraBuffer * allocateBufferList(int width, int height, const char* format, int &bytes, int numBufs) = 0;
|
|
|
|
// gets a buffer list from BufferProvider when buffers are sent from external source and already pre-allocated
|
|
// only call this function for an input source into CameraHal. If buffers are not from a pre-allocated source
|
|
// this function will return NULL and numBufs of -1
|
|
virtual CameraBuffer *getBufferList(int *numBufs) = 0;
|
|
|
|
//additional methods used for memory mapping
|
|
virtual uint32_t * getOffsets() = 0;
|
|
virtual int getFd() = 0;
|
|
virtual CameraBuffer * getBuffers(__unused bool reset = false) { return NULL; }
|
|
virtual unsigned int getSize() {return 0; }
|
|
virtual int getBufferCount() {return -1; }
|
|
|
|
virtual int freeBufferList(CameraBuffer * buf) = 0;
|
|
|
|
virtual ~BufferProvider() {}
|
|
};
|
|
|
|
/**
|
|
* Class for handling data and notify callbacks to application
|
|
*/
|
|
class AppCallbackNotifier: public ErrorNotifier , public virtual android::RefBase
|
|
{
|
|
|
|
public:
|
|
|
|
///Constants
|
|
static const int NOTIFIER_TIMEOUT;
|
|
static const int32_t MAX_BUFFERS = 8;
|
|
|
|
enum NotifierCommands
|
|
{
|
|
NOTIFIER_CMD_PROCESS_EVENT,
|
|
NOTIFIER_CMD_PROCESS_FRAME,
|
|
NOTIFIER_CMD_PROCESS_ERROR
|
|
};
|
|
|
|
enum NotifierState
|
|
{
|
|
NOTIFIER_STOPPED,
|
|
NOTIFIER_STARTED,
|
|
NOTIFIER_EXITED
|
|
};
|
|
|
|
public:
|
|
|
|
~AppCallbackNotifier();
|
|
|
|
///Initialzes the callback notifier, creates any resources required
|
|
status_t initialize();
|
|
|
|
///Starts the callbacks to application
|
|
status_t start();
|
|
|
|
///Stops the callbacks from going to application
|
|
status_t stop();
|
|
|
|
void setEventProvider(int32_t eventMask, MessageNotifier * eventProvider);
|
|
void setFrameProvider(FrameNotifier *frameProvider);
|
|
|
|
//All sub-components of Camera HAL call this whenever any error happens
|
|
virtual void errorNotify(int error);
|
|
|
|
status_t startPreviewCallbacks(android::CameraParameters ¶ms, CameraBuffer *buffers, uint32_t *offsets, int fd, size_t length, size_t count);
|
|
status_t stopPreviewCallbacks();
|
|
|
|
status_t enableMsgType(int32_t msgType);
|
|
status_t disableMsgType(int32_t msgType);
|
|
|
|
//API for enabling/disabling measurement data
|
|
void setMeasurements(bool enable);
|
|
|
|
//thread loops
|
|
bool notificationThread();
|
|
|
|
///Notification callback functions
|
|
static void frameCallbackRelay(CameraFrame* caFrame);
|
|
static void eventCallbackRelay(CameraHalEvent* chEvt);
|
|
void frameCallback(CameraFrame* caFrame);
|
|
void eventCallback(CameraHalEvent* chEvt);
|
|
void flushAndReturnFrames();
|
|
|
|
void setCallbacks(CameraHal *cameraHal,
|
|
camera_notify_callback notify_cb,
|
|
camera_data_callback data_cb,
|
|
camera_data_timestamp_callback data_cb_timestamp,
|
|
camera_request_memory get_memory,
|
|
void *user);
|
|
|
|
//Set Burst mode
|
|
void setBurst(bool burst);
|
|
|
|
//Notifications from CameraHal for video recording case
|
|
status_t startRecording();
|
|
status_t stopRecording();
|
|
status_t initSharedVideoBuffers(CameraBuffer *buffers, uint32_t *offsets, int fd, size_t length, size_t count, CameraBuffer *vidBufs);
|
|
status_t releaseRecordingFrame(const void *opaque);
|
|
|
|
status_t useMetaDataBufferMode(bool enable);
|
|
|
|
void EncoderDoneCb(void*, void*, CameraFrame::FrameType type, void* cookie1, void* cookie2, void *cookie3);
|
|
|
|
void useVideoBuffers(bool useVideoBuffers);
|
|
|
|
bool getUesVideoBuffers();
|
|
void setVideoRes(int width, int height);
|
|
|
|
void flushEventQueue();
|
|
void setExternalLocking(bool extBuffLocking);
|
|
|
|
//Internal class definitions
|
|
class NotificationThread : public android::Thread {
|
|
AppCallbackNotifier* mAppCallbackNotifier;
|
|
Utils::MessageQueue mNotificationThreadQ;
|
|
public:
|
|
enum NotificationThreadCommands
|
|
{
|
|
NOTIFIER_START,
|
|
NOTIFIER_STOP,
|
|
NOTIFIER_EXIT,
|
|
};
|
|
public:
|
|
NotificationThread(AppCallbackNotifier* nh)
|
|
: Thread(false), mAppCallbackNotifier(nh) { }
|
|
virtual bool threadLoop() {
|
|
return mAppCallbackNotifier->notificationThread();
|
|
}
|
|
|
|
Utils::MessageQueue &msgQ() { return mNotificationThreadQ;}
|
|
};
|
|
|
|
//Friend declarations
|
|
friend class NotificationThread;
|
|
|
|
private:
|
|
void notifyEvent();
|
|
void notifyFrame();
|
|
bool processMessage();
|
|
void releaseSharedVideoBuffers();
|
|
status_t dummyRaw();
|
|
void copyAndSendPictureFrame(CameraFrame* frame, int32_t msgType);
|
|
void copyAndSendPreviewFrame(CameraFrame* frame, int32_t msgType);
|
|
size_t calculateBufferSize(size_t width, size_t height, const char *pixelFormat);
|
|
const char* getContstantForPixelFormat(const char *pixelFormat);
|
|
void lockBufferAndUpdatePtrs(CameraFrame* frame);
|
|
void unlockBufferAndUpdatePtrs(CameraFrame* frame);
|
|
|
|
private:
|
|
mutable android::Mutex mLock;
|
|
mutable android::Mutex mBurstLock;
|
|
CameraHal* mCameraHal;
|
|
camera_notify_callback mNotifyCb;
|
|
camera_data_callback mDataCb;
|
|
camera_data_timestamp_callback mDataCbTimestamp;
|
|
camera_request_memory mRequestMemory;
|
|
void *mCallbackCookie;
|
|
|
|
//Keeps Video MemoryHeaps and Buffers within
|
|
//these objects
|
|
android::KeyedVector<unsigned int, unsigned int> mVideoHeaps;
|
|
android::KeyedVector<unsigned int, unsigned int> mVideoBuffers;
|
|
android::KeyedVector<void *, CameraBuffer *> mVideoMap;
|
|
|
|
//Keeps list of Gralloc handles and associated Video Metadata Buffers
|
|
android::KeyedVector<void *, camera_memory_t *> mVideoMetadataBufferMemoryMap;
|
|
android::KeyedVector<void *, CameraBuffer *> mVideoMetadataBufferReverseMap;
|
|
|
|
bool mBufferReleased;
|
|
|
|
android::sp< NotificationThread> mNotificationThread;
|
|
EventProvider *mEventProvider;
|
|
FrameProvider *mFrameProvider;
|
|
Utils::MessageQueue mEventQ;
|
|
Utils::MessageQueue mFrameQ;
|
|
NotifierState mNotifierState;
|
|
|
|
bool mPreviewing;
|
|
camera_memory_t* mPreviewMemory;
|
|
CameraBuffer mPreviewBuffers[MAX_BUFFERS];
|
|
int mPreviewBufCount;
|
|
int mPreviewWidth;
|
|
int mPreviewHeight;
|
|
int mPreviewStride;
|
|
const char *mPreviewPixelFormat;
|
|
android::KeyedVector<unsigned int, android::sp<android::MemoryHeapBase> > mSharedPreviewHeaps;
|
|
android::KeyedVector<unsigned int, android::sp<android::MemoryBase> > mSharedPreviewBuffers;
|
|
|
|
//Burst mode active
|
|
bool mBurst;
|
|
mutable android::Mutex mRecordingLock;
|
|
bool mRecording;
|
|
bool mMeasurementEnabled;
|
|
|
|
bool mUseMetaDataBufferMode;
|
|
bool mRawAvailable;
|
|
|
|
bool mUseVideoBuffers;
|
|
|
|
int mVideoWidth;
|
|
int mVideoHeight;
|
|
|
|
bool mExternalLocking;
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* Class used for allocating memory for JPEG bit stream buffers, output buffers of camera in no overlay case
|
|
*/
|
|
class MemoryManager : public BufferProvider, public virtual android::RefBase
|
|
{
|
|
public:
|
|
MemoryManager();
|
|
~MemoryManager();
|
|
|
|
status_t initialize();
|
|
|
|
int setErrorHandler(ErrorNotifier *errorNotifier);
|
|
virtual CameraBuffer * allocateBufferList(int width, int height, const char* format, int &bytes, int numBufs);
|
|
virtual CameraBuffer *getBufferList(int *numBufs);
|
|
virtual uint32_t * getOffsets();
|
|
virtual int getFd() ;
|
|
virtual int freeBufferList(CameraBuffer * buflist);
|
|
|
|
private:
|
|
android::sp<ErrorNotifier> mErrorNotifier;
|
|
int mIonFd;
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
* CameraAdapter interface class
|
|
* Concrete classes derive from this class and provide implementations based on the specific camera h/w interface
|
|
*/
|
|
|
|
class CameraAdapter: public FrameNotifier, public virtual android::RefBase
|
|
{
|
|
protected:
|
|
enum AdapterActiveStates {
|
|
INTIALIZED_ACTIVE = 1 << 0,
|
|
LOADED_PREVIEW_ACTIVE = 1 << 1,
|
|
PREVIEW_ACTIVE = 1 << 2,
|
|
LOADED_CAPTURE_ACTIVE = 1 << 3,
|
|
CAPTURE_ACTIVE = 1 << 4,
|
|
BRACKETING_ACTIVE = 1 << 5,
|
|
AF_ACTIVE = 1 << 6,
|
|
ZOOM_ACTIVE = 1 << 7,
|
|
VIDEO_ACTIVE = 1 << 8,
|
|
LOADED_REPROCESS_ACTIVE = 1 << 9,
|
|
REPROCESS_ACTIVE = 1 << 10,
|
|
};
|
|
public:
|
|
typedef struct
|
|
{
|
|
CameraBuffer *mBuffers;
|
|
uint32_t *mOffsets;
|
|
int mFd;
|
|
size_t mLength;
|
|
size_t mCount;
|
|
size_t mMaxQueueable;
|
|
} BuffersDescriptor;
|
|
|
|
enum CameraCommands
|
|
{
|
|
CAMERA_START_PREVIEW = 0,
|
|
CAMERA_STOP_PREVIEW = 1,
|
|
CAMERA_START_VIDEO = 2,
|
|
CAMERA_STOP_VIDEO = 3,
|
|
CAMERA_START_IMAGE_CAPTURE = 4,
|
|
CAMERA_STOP_IMAGE_CAPTURE = 5,
|
|
CAMERA_PERFORM_AUTOFOCUS = 6,
|
|
CAMERA_CANCEL_AUTOFOCUS = 7,
|
|
CAMERA_PREVIEW_FLUSH_BUFFERS = 8,
|
|
CAMERA_START_SMOOTH_ZOOM = 9,
|
|
CAMERA_STOP_SMOOTH_ZOOM = 10,
|
|
CAMERA_USE_BUFFERS_PREVIEW = 11,
|
|
CAMERA_SET_TIMEOUT = 12,
|
|
CAMERA_CANCEL_TIMEOUT = 13,
|
|
CAMERA_START_BRACKET_CAPTURE = 14,
|
|
CAMERA_STOP_BRACKET_CAPTURE = 15,
|
|
CAMERA_QUERY_RESOLUTION_PREVIEW = 16,
|
|
CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE = 17,
|
|
CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA = 18,
|
|
CAMERA_USE_BUFFERS_IMAGE_CAPTURE = 19,
|
|
CAMERA_USE_BUFFERS_PREVIEW_DATA = 20,
|
|
CAMERA_TIMEOUT_EXPIRED = 21,
|
|
CAMERA_START_FD = 22,
|
|
CAMERA_STOP_FD = 23,
|
|
CAMERA_SWITCH_TO_EXECUTING = 24,
|
|
CAMERA_USE_BUFFERS_VIDEO_CAPTURE = 25,
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
CAMERA_USE_BUFFERS_REPROCESS = 26,
|
|
CAMERA_START_REPROCESS = 27,
|
|
#endif
|
|
#ifdef OMAP_ENHANCEMENT_VTC
|
|
CAMERA_SETUP_TUNNEL = 28,
|
|
CAMERA_DESTROY_TUNNEL = 29,
|
|
#endif
|
|
CAMERA_PREVIEW_INITIALIZATION = 30,
|
|
};
|
|
|
|
enum CameraMode
|
|
{
|
|
CAMERA_PREVIEW,
|
|
CAMERA_IMAGE_CAPTURE,
|
|
CAMERA_VIDEO,
|
|
CAMERA_MEASUREMENT,
|
|
CAMERA_REPROCESS,
|
|
};
|
|
|
|
enum AdapterState {
|
|
INTIALIZED_STATE = INTIALIZED_ACTIVE,
|
|
LOADED_PREVIEW_STATE = LOADED_PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
PREVIEW_STATE = PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
LOADED_CAPTURE_STATE = LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
CAPTURE_STATE = CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
BRACKETING_STATE = BRACKETING_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE ,
|
|
AF_STATE = AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
ZOOM_STATE = ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
VIDEO_STATE = VIDEO_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
VIDEO_AF_STATE = VIDEO_ACTIVE | AF_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
VIDEO_ZOOM_STATE = VIDEO_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
VIDEO_LOADED_CAPTURE_STATE = VIDEO_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
VIDEO_CAPTURE_STATE = VIDEO_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
AF_ZOOM_STATE = AF_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
BRACKETING_ZOOM_STATE = BRACKETING_ACTIVE | ZOOM_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
LOADED_REPROCESS_STATE = LOADED_REPROCESS_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
LOADED_REPROCESS_CAPTURE_STATE = LOADED_REPROCESS_ACTIVE | LOADED_CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
REPROCESS_STATE = REPROCESS_ACTIVE | CAPTURE_ACTIVE | PREVIEW_ACTIVE | INTIALIZED_ACTIVE,
|
|
};
|
|
|
|
|
|
public:
|
|
|
|
///Initialzes the camera adapter creates any resources required
|
|
virtual int initialize(CameraProperties::Properties*) = 0;
|
|
|
|
virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
|
|
|
|
//Message/Frame notification APIs
|
|
virtual void enableMsgType(int32_t msgs,
|
|
frame_callback callback = NULL,
|
|
event_callback eventCb = NULL,
|
|
void *cookie = NULL) = 0;
|
|
virtual void disableMsgType(int32_t msgs, void* cookie) = 0;
|
|
virtual void returnFrame(CameraBuffer* frameBuf, CameraFrame::FrameType frameType) = 0;
|
|
virtual void addFramePointers(CameraBuffer *frameBuf, void *buf) = 0;
|
|
virtual void removeFramePointers() = 0;
|
|
|
|
//APIs to configure Camera adapter and get the current parameter set
|
|
virtual int setParameters(const android::CameraParameters& params) = 0;
|
|
virtual void getParameters(android::CameraParameters& params) = 0;
|
|
|
|
//Registers callback for returning image buffers back to CameraHAL
|
|
virtual int registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data) = 0;
|
|
|
|
//Registers callback, which signals a completed image capture
|
|
virtual int registerEndCaptureCallback(end_image_capture_callback callback, void *user_data) = 0;
|
|
|
|
//API to send a command to the camera
|
|
virtual status_t sendCommand(CameraCommands operation, int value1=0, int value2=0, int value3=0, int value4=0) = 0;
|
|
|
|
virtual ~CameraAdapter() {};
|
|
|
|
//Retrieves the current Adapter state
|
|
virtual AdapterState getState() = 0;
|
|
|
|
//Retrieves the next Adapter state
|
|
virtual AdapterState getNextState() = 0;
|
|
|
|
// Receive orientation events from CameraHal
|
|
virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt) = 0;
|
|
|
|
// Rolls the state machine back to INTIALIZED_STATE from the current state
|
|
virtual status_t rollbackToInitializedState() = 0;
|
|
|
|
// Retrieves the current Adapter state - for internal use (not locked)
|
|
virtual status_t getState(AdapterState &state) = 0;
|
|
// Retrieves the next Adapter state - for internal use (not locked)
|
|
virtual status_t getNextState(AdapterState &state) = 0;
|
|
|
|
virtual status_t setSharedAllocator(camera_request_memory shmem_alloc) = 0;
|
|
|
|
protected:
|
|
//The first two methods will try to switch the adapter state.
|
|
//Every call to setState() should be followed by a corresponding
|
|
//call to commitState(). If the state switch fails, then it will
|
|
//get reset to the previous state via rollbackState().
|
|
virtual status_t setState(CameraCommands operation) = 0;
|
|
virtual status_t commitState() = 0;
|
|
virtual status_t rollbackState() = 0;
|
|
};
|
|
|
|
class DisplayAdapter : public BufferProvider, public virtual android::RefBase
|
|
{
|
|
public:
|
|
DisplayAdapter();
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
preview_stream_extended_ops_t * extendedOps() const {
|
|
return mExtendedOps;
|
|
}
|
|
|
|
void setExtendedOps(preview_stream_extended_ops_t * extendedOps);
|
|
#endif
|
|
|
|
///Initializes the display adapter creates any resources required
|
|
virtual int initialize() = 0;
|
|
|
|
virtual int setPreviewWindow(struct preview_stream_ops *window) = 0;
|
|
virtual int setFrameProvider(FrameNotifier *frameProvider) = 0;
|
|
virtual int setErrorHandler(ErrorNotifier *errorNotifier) = 0;
|
|
virtual int enableDisplay(int width, int height, struct timeval *refTime = NULL) = 0;
|
|
virtual int disableDisplay(bool cancel_buffer = true) = 0;
|
|
//Used for Snapshot review temp. pause
|
|
virtual int pauseDisplay(bool pause) = 0;
|
|
|
|
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
|
|
//Used for shot to snapshot measurement
|
|
virtual int setSnapshotTimeRef(struct timeval *refTime = NULL) = 0;
|
|
#endif
|
|
|
|
virtual bool supportsExternalBuffering() = 0;
|
|
|
|
// Get max queueable buffers display supports
|
|
// This function should only be called after
|
|
// allocateBufferList
|
|
virtual status_t maxQueueableBuffers(unsigned int& queueable) = 0;
|
|
|
|
// Get min buffers display needs at any given time
|
|
virtual status_t minUndequeueableBuffers(int& unqueueable) = 0;
|
|
|
|
// Given a vector of DisplayAdapters find the one corresponding to str
|
|
virtual bool match(__unused const char * str) { return false; }
|
|
|
|
private:
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
preview_stream_extended_ops_t * mExtendedOps;
|
|
#endif
|
|
};
|
|
|
|
static void releaseImageBuffers(void *userData);
|
|
|
|
static void endImageCapture(void *userData);
|
|
|
|
/**
|
|
Implementation of the Android Camera hardware abstraction layer
|
|
|
|
This class implements the interface methods defined in CameraHardwareInterface
|
|
for the OMAP4 platform
|
|
|
|
*/
|
|
class CameraHal
|
|
|
|
{
|
|
|
|
public:
|
|
enum SocFamily {
|
|
SocFamily_Undefined = -1,
|
|
SocFamily_Omap4430 = 0,
|
|
SocFamily_Omap4460,
|
|
SocFamily_Omap4470,
|
|
SocFamily_ElementCount // element count of SocFamily
|
|
};
|
|
|
|
///Constants
|
|
static const int NO_BUFFERS_PREVIEW;
|
|
static const int NO_BUFFERS_IMAGE_CAPTURE;
|
|
static const int NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP;
|
|
static const uint32_t VFR_SCALE = 1000;
|
|
|
|
|
|
/*--------------------Interface Methods---------------------------------*/
|
|
|
|
//@{
|
|
public:
|
|
|
|
#ifdef MOTOROLA_CAMERA
|
|
bool SetFlashLedTorch(unsigned intensity);
|
|
#endif
|
|
|
|
/** Set the notification and data callbacks */
|
|
void setCallbacks(camera_notify_callback notify_cb,
|
|
camera_data_callback data_cb,
|
|
camera_data_timestamp_callback data_cb_timestamp,
|
|
camera_request_memory get_memory,
|
|
void *user);
|
|
|
|
/** Receives orientation events from SensorListener **/
|
|
void onOrientationEvent(uint32_t orientation, uint32_t tilt);
|
|
|
|
/**
|
|
* The following three functions all take a msgtype,
|
|
* which is a bitmask of the messages defined in
|
|
* include/ui/Camera.h
|
|
*/
|
|
|
|
/**
|
|
* Enable a message, or set of messages.
|
|
*/
|
|
void enableMsgType(int32_t msgType);
|
|
|
|
/**
|
|
* Disable a message, or a set of messages.
|
|
*/
|
|
void disableMsgType(int32_t msgType);
|
|
|
|
/**
|
|
* Query whether a message, or a set of messages, is enabled.
|
|
* Note that this is operates as an AND, if any of the messages
|
|
* queried are off, this will return false.
|
|
*/
|
|
int msgTypeEnabled(int32_t msgType);
|
|
|
|
/**
|
|
* Start preview mode.
|
|
*/
|
|
int startPreview();
|
|
|
|
/**
|
|
* Set preview mode related initialization.
|
|
* Only used when slice based processing is enabled.
|
|
*/
|
|
int cameraPreviewInitialization();
|
|
|
|
/**
|
|
* Only used if overlays are used for camera preview.
|
|
*/
|
|
int setPreviewWindow(struct preview_stream_ops *window);
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
void setExtendedPreviewStreamOps(preview_stream_extended_ops_t *ops);
|
|
|
|
/**
|
|
* Set a tap-in or tap-out point.
|
|
*/
|
|
int setBufferSource(struct preview_stream_ops *tapin, struct preview_stream_ops *tapout);
|
|
#endif
|
|
|
|
/**
|
|
* Release a tap-in or tap-out point.
|
|
*/
|
|
int releaseBufferSource(struct preview_stream_ops *tapin, struct preview_stream_ops *tapout);
|
|
|
|
/**
|
|
* Stop a previously started preview.
|
|
*/
|
|
void stopPreview();
|
|
|
|
/**
|
|
* Returns true if preview is enabled.
|
|
*/
|
|
bool previewEnabled();
|
|
|
|
/**
|
|
* Start record mode. When a record image is available a CAMERA_MSG_VIDEO_FRAME
|
|
* message is sent with the corresponding frame. Every record frame must be released
|
|
* by calling releaseRecordingFrame().
|
|
*/
|
|
int startRecording();
|
|
|
|
/**
|
|
* Stop a previously started recording.
|
|
*/
|
|
void stopRecording();
|
|
|
|
/**
|
|
* Returns true if recording is enabled.
|
|
*/
|
|
int recordingEnabled();
|
|
|
|
/**
|
|
* Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
|
|
*/
|
|
void releaseRecordingFrame(const void *opaque);
|
|
|
|
/**
|
|
* Start auto focus, the notification callback routine is called
|
|
* with CAMERA_MSG_FOCUS once when focusing is complete. autoFocus()
|
|
* will be called again if another auto focus is needed.
|
|
*/
|
|
int autoFocus();
|
|
|
|
/**
|
|
* Cancels auto-focus function. If the auto-focus is still in progress,
|
|
* this function will cancel it. Whether the auto-focus is in progress
|
|
* or not, this function will return the focus position to the default.
|
|
* If the camera does not support auto-focus, this is a no-op.
|
|
*/
|
|
int cancelAutoFocus();
|
|
|
|
/**
|
|
* Take a picture.
|
|
*/
|
|
int takePicture(const char* params);
|
|
|
|
/**
|
|
* Cancel a picture that was started with takePicture. Calling this
|
|
* method when no picture is being taken is a no-op.
|
|
*/
|
|
int cancelPicture();
|
|
|
|
/** Set the camera parameters. */
|
|
int setParameters(const char* params);
|
|
int setParameters(const android::CameraParameters& params);
|
|
|
|
/** Return the camera parameters. */
|
|
char* getParameters();
|
|
void putParameters(char *);
|
|
|
|
/**
|
|
* Send command to camera driver.
|
|
*/
|
|
int sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
|
|
|
|
/**
|
|
* Release the hardware resources owned by this object. Note that this is
|
|
* *not* done in the destructor.
|
|
*/
|
|
void release();
|
|
|
|
/**
|
|
* Dump state of the camera hardware
|
|
*/
|
|
int dump(int fd) const;
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
/**
|
|
* start a reprocessing operation.
|
|
*/
|
|
int reprocess(const char* params);
|
|
|
|
/**
|
|
* cancels current reprocessing operation
|
|
*/
|
|
int cancel_reprocess();
|
|
#endif
|
|
|
|
status_t storeMetaDataInBuffers(bool enable);
|
|
|
|
// Use external locking for graphic buffers
|
|
void setExternalLocking(bool extBuffLocking);
|
|
|
|
//@}
|
|
|
|
/*--------------------Internal Member functions - Public---------------------------------*/
|
|
|
|
public:
|
|
/** @name internalFunctionsPublic */
|
|
//@{
|
|
|
|
/** Constructor of CameraHal */
|
|
CameraHal(int cameraId);
|
|
|
|
// Destructor of CameraHal
|
|
~CameraHal();
|
|
|
|
/** Initialize CameraHal */
|
|
status_t initialize(CameraProperties::Properties*);
|
|
|
|
/** Deinitialize CameraHal */
|
|
void deinitialize();
|
|
|
|
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
|
|
|
|
//Uses the constructor timestamp as a reference to calcluate the
|
|
// elapsed time
|
|
static void PPM(const char *);
|
|
//Uses a user provided timestamp as a reference to calcluate the
|
|
// elapsed time
|
|
static void PPM(const char *, struct timeval*, ...);
|
|
|
|
#endif
|
|
|
|
/** Free image bufs */
|
|
status_t freeImageBufs();
|
|
|
|
//Signals the end of image capture
|
|
status_t signalEndImageCapture();
|
|
|
|
//Events
|
|
static void eventCallbackRelay(CameraHalEvent* event);
|
|
void eventCallback(CameraHalEvent* event);
|
|
void setEventProvider(int32_t eventMask, MessageNotifier * eventProvider);
|
|
|
|
static const char* getPixelFormatConstant(const char* parameters_format);
|
|
static size_t calculateBufferSize(const char* parameters_format, int width, int height);
|
|
static void getXYFromOffset(unsigned int *x, unsigned int *y,
|
|
unsigned int offset, unsigned int stride,
|
|
const char* format);
|
|
static unsigned int getBPP(const char* format);
|
|
static bool parsePair(const char *str, int *first, int *second, char delim);
|
|
|
|
/*--------------------Internal Member functions - Private---------------------------------*/
|
|
private:
|
|
|
|
/** @name internalFunctionsPrivate */
|
|
//@{
|
|
|
|
/** Set the camera parameters specific to Video Recording. */
|
|
bool setVideoModeParameters(const android::CameraParameters&);
|
|
|
|
/** Reset the camera parameters specific to Video Recording. */
|
|
bool resetVideoModeParameters();
|
|
|
|
/** Restart the preview with setParameter. */
|
|
status_t restartPreview();
|
|
|
|
status_t parseResolution(const char *resStr, int &width, int &height);
|
|
|
|
void insertSupportedParams();
|
|
|
|
/** Allocate preview data buffers */
|
|
status_t allocPreviewDataBufs(size_t size, size_t bufferCount);
|
|
|
|
/** Free preview data buffers */
|
|
status_t freePreviewDataBufs();
|
|
|
|
/** Allocate preview buffers */
|
|
status_t allocPreviewBufs(int width, int height, const char* previewFormat, unsigned int bufferCount, unsigned int &max_queueable);
|
|
|
|
/** Allocate video buffers */
|
|
status_t allocVideoBufs(uint32_t width, uint32_t height, uint32_t bufferCount);
|
|
|
|
/** Allocate image capture buffers */
|
|
status_t allocImageBufs(unsigned int width, unsigned int height, size_t length,
|
|
const char* previewFormat, unsigned int bufferCount);
|
|
|
|
/** Allocate Raw buffers */
|
|
status_t allocRawBufs(int width, int height, const char* previewFormat, int bufferCount);
|
|
|
|
/** Free preview buffers */
|
|
status_t freePreviewBufs();
|
|
|
|
/** Free video bufs */
|
|
status_t freeVideoBufs(CameraBuffer *bufs);
|
|
|
|
/** Free RAW bufs */
|
|
status_t freeRawBufs();
|
|
|
|
//Check if a given resolution is supported by the current camera
|
|
//instance
|
|
bool isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions);
|
|
|
|
//Check if a given variable frame rate range is supported by the current camera
|
|
//instance
|
|
bool isFpsRangeValid(int fpsMin, int fpsMax, const char *supportedFpsRanges);
|
|
|
|
//Check if a given parameter is supported by the current camera
|
|
// instance
|
|
bool isParameterValid(const char *param, const char *supportedParams);
|
|
bool isParameterValid(int param, const char *supportedParams);
|
|
status_t doesSetParameterNeedUpdate(const char *new_param, const char *old_params, bool &update);
|
|
|
|
/** Initialize default parameters */
|
|
void initDefaultParameters();
|
|
|
|
void dumpProperties(CameraProperties::Properties& cameraProps);
|
|
|
|
status_t startImageBracketing();
|
|
|
|
status_t stopImageBracketing();
|
|
|
|
void setShutter(bool enable);
|
|
|
|
void forceStopPreview();
|
|
|
|
void resetPreviewRes(android::CameraParameters *params);
|
|
|
|
// Internal __takePicture function - used in public takePicture() and reprocess()
|
|
int __takePicture(const char* params, struct timeval *captureStart = NULL);
|
|
//@}
|
|
|
|
status_t setTapoutLocked(struct preview_stream_ops *out);
|
|
status_t releaseTapoutLocked(struct preview_stream_ops *out);
|
|
status_t setTapinLocked(struct preview_stream_ops *in);
|
|
status_t releaseTapinLocked(struct preview_stream_ops *in);
|
|
|
|
static SocFamily getSocFamily();
|
|
|
|
#ifdef MOTOROLA_CAMERA
|
|
// I2C read write utility to support factory test commands
|
|
bool i2cRW(int read_size, int write_size, unsigned char *read_data, unsigned char *write_data);
|
|
|
|
// get best flash intensity level for the current battery level
|
|
unsigned int getFlashIntensity(void);
|
|
#endif
|
|
/*----------Member variables - Public ---------------------*/
|
|
public:
|
|
int32_t mMsgEnabled;
|
|
bool mRecordEnabled;
|
|
nsecs_t mCurrentTime;
|
|
bool mFalsePreview;
|
|
bool mPreviewEnabled;
|
|
uint32_t mTakePictureQueue;
|
|
bool mBracketingEnabled;
|
|
bool mBracketingRunning;
|
|
//User shutter override
|
|
bool mShutterEnabled;
|
|
bool mMeasurementEnabled;
|
|
//Google's parameter delimiter
|
|
static const char PARAMS_DELIMITER[];
|
|
|
|
CameraAdapter *mCameraAdapter;
|
|
android::sp<AppCallbackNotifier> mAppCallbackNotifier;
|
|
android::sp<DisplayAdapter> mDisplayAdapter;
|
|
android::sp<MemoryManager> mMemoryManager;
|
|
|
|
android::Vector< android::sp<DisplayAdapter> > mOutAdapters;
|
|
android::Vector< android::sp<DisplayAdapter> > mInAdapters;
|
|
|
|
// TODO(XXX): Even though we support user setting multiple BufferSourceAdapters now
|
|
// only one tap in surface and one tap out surface is supported at a time.
|
|
android::sp<DisplayAdapter> mBufferSourceAdapter_In;
|
|
android::sp<DisplayAdapter> mBufferSourceAdapter_Out;
|
|
|
|
#ifdef OMAP_ENHANCEMENT_CPCAM
|
|
preview_stream_extended_ops_t * mExtendedPreviewStreamOps;
|
|
#endif
|
|
|
|
android::sp<android::IMemoryHeap> mPictureHeap;
|
|
|
|
int* mGrallocHandles;
|
|
bool mFpsRangeChangedByApp;
|
|
|
|
|
|
int mRawWidth;
|
|
int mRawHeight;
|
|
bool mRawCapture;
|
|
|
|
|
|
///static member vars
|
|
|
|
static const int SW_SCALING_FPS_LIMIT;
|
|
|
|
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
|
|
|
|
//Timestamp from the CameraHal constructor
|
|
static struct timeval ppm_start;
|
|
//Timestamp of the autoFocus command
|
|
static struct timeval mStartFocus;
|
|
//Timestamp of the startPreview command
|
|
static struct timeval mStartPreview;
|
|
//Timestamp of the takePicture command
|
|
static struct timeval mStartCapture;
|
|
|
|
#endif
|
|
|
|
/*----------Member variables - Private ---------------------*/
|
|
private:
|
|
bool mDynamicPreviewSwitch;
|
|
//keeps paused state of display
|
|
bool mDisplayPaused;
|
|
|
|
#ifdef OMAP_ENHANCEMENT_VTC
|
|
bool mTunnelSetup;
|
|
bool mVTCUseCase;
|
|
#endif
|
|
|
|
//Index of current camera adapter
|
|
int mCameraIndex;
|
|
|
|
mutable android::Mutex mLock;
|
|
|
|
android::sp<SensorListener> mSensorListener;
|
|
|
|
void* mCameraAdapterHandle;
|
|
|
|
android::CameraParameters mParameters;
|
|
bool mPreviewRunning;
|
|
bool mPreviewStateOld;
|
|
bool mRecordingEnabled;
|
|
EventProvider *mEventProvider;
|
|
|
|
CameraBuffer *mPreviewDataBuffers;
|
|
uint32_t *mPreviewDataOffsets;
|
|
int mPreviewDataFd;
|
|
int mPreviewDataLength;
|
|
CameraBuffer *mImageBuffers;
|
|
uint32_t *mImageOffsets;
|
|
int mImageFd;
|
|
int mImageLength;
|
|
unsigned int mImageCount;
|
|
CameraBuffer *mPreviewBuffers;
|
|
uint32_t *mPreviewOffsets;
|
|
int mPreviewLength;
|
|
int mPreviewFd;
|
|
CameraBuffer *mVideoBuffers;
|
|
uint32_t *mVideoOffsets;
|
|
int mVideoFd;
|
|
int mVideoLength;
|
|
|
|
int mBracketRangePositive;
|
|
int mBracketRangeNegative;
|
|
|
|
///@todo Rename this as preview buffer provider
|
|
BufferProvider *mBufProvider;
|
|
BufferProvider *mVideoBufProvider;
|
|
|
|
|
|
CameraProperties::Properties* mCameraProperties;
|
|
|
|
bool mPreviewStartInProgress;
|
|
bool mPreviewInitializationDone;
|
|
|
|
bool mSetPreviewWindowCalled;
|
|
|
|
uint32_t mPreviewWidth;
|
|
uint32_t mPreviewHeight;
|
|
int32_t mMaxZoomSupported;
|
|
|
|
int mVideoWidth;
|
|
int mVideoHeight;
|
|
|
|
android::String8 mCapModeBackup;
|
|
|
|
bool mExternalLocking;
|
|
|
|
const SocFamily mSocFamily;
|
|
};
|
|
|
|
} // namespace Camera
|
|
} // namespace Ti
|
|
|
|
#endif
|