diff options
Diffstat (limited to 'camera/inc/BaseCameraAdapter.h')
| -rw-r--r-- | camera/inc/BaseCameraAdapter.h | 308 |
1 files changed, 308 insertions, 0 deletions
diff --git a/camera/inc/BaseCameraAdapter.h b/camera/inc/BaseCameraAdapter.h new file mode 100644 index 0000000..ffe0492 --- /dev/null +++ b/camera/inc/BaseCameraAdapter.h @@ -0,0 +1,308 @@ +/* + * 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 BASE_CAMERA_ADAPTER_H +#define BASE_CAMERA_ADAPTER_H + +#include "CameraHal.h" + +namespace Ti { +namespace Camera { + +struct LUT { + const char * userDefinition; + int halDefinition; +}; + +struct LUTtypeHAL{ + int size; + const LUT *Table; +}; + +class BaseCameraAdapter : public CameraAdapter +{ + +public: + + BaseCameraAdapter(); + virtual ~BaseCameraAdapter(); + + ///Initialzes the camera adapter creates any resources required + virtual status_t initialize(CameraProperties::Properties*) = 0; + + virtual int setErrorHandler(ErrorNotifier *errorNotifier); + + //Message/Frame notification APIs + virtual void enableMsgType(int32_t msgs, frame_callback callback=NULL, event_callback eventCb=NULL, void* cookie=NULL); + virtual void disableMsgType(int32_t msgs, void* cookie); + virtual void returnFrame(CameraBuffer * frameBuf, CameraFrame::FrameType frameType); + virtual void addFramePointers(CameraBuffer *frameBuf, void *y_uv); + virtual void removeFramePointers(); + + //APIs to configure Camera adapter and get the current parameter set + virtual status_t setParameters(const android::CameraParameters& params) = 0; + virtual void getParameters(android::CameraParameters& params) = 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 ); + + virtual status_t registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data); + + virtual status_t registerEndCaptureCallback(end_image_capture_callback callback, void *user_data); + + //Retrieves the current Adapter state + virtual AdapterState getState(); + //Retrieves the next Adapter state + virtual AdapterState getNextState(); + + virtual status_t setSharedAllocator(camera_request_memory shmem_alloc) { mSharedAllocator = shmem_alloc; return NO_ERROR; }; + + // Rolls the state machine back to INTIALIZED_STATE from the current state + virtual status_t rollbackToInitializedState(); + +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); + virtual status_t commitState(); + virtual status_t rollbackState(); + + // Retrieves the current Adapter state - for internal use (not locked) + virtual status_t getState(AdapterState &state); + // Retrieves the next Adapter state - for internal use (not locked) + virtual status_t getNextState(AdapterState &state); + + //-----------Interface that needs to be implemented by deriving classes -------------------- + + //Should be implmented by deriving classes in order to start image capture + virtual status_t takePicture(); + + //Should be implmented by deriving classes in order to start image capture + virtual status_t stopImageCapture(); + + //Should be implmented by deriving classes in order to start temporal bracketing + virtual status_t startBracketing(int range); + + //Should be implemented by deriving classes in order to stop temporal bracketing + virtual status_t stopBracketing(); + + //Should be implemented by deriving classes in oder to initiate autoFocus + virtual status_t autoFocus(); + + //Should be implemented by deriving classes in oder to initiate autoFocus + virtual status_t cancelAutoFocus(); + + //Should be called by deriving classes in order to do some bookkeeping + virtual status_t startVideoCapture(); + + //Should be called by deriving classes in order to do some bookkeeping + virtual status_t stopVideoCapture(); + + //Should be implemented by deriving classes in order to start camera preview + virtual status_t startPreview(); + + //Should be implemented by deriving classes in order to stop camera preview + virtual status_t stopPreview(); + + //Should be implemented by deriving classes in order to start smooth zoom + virtual status_t startSmoothZoom(int targetIdx); + + //Should be implemented by deriving classes in order to stop smooth zoom + virtual status_t stopSmoothZoom(); + + //Should be implemented by deriving classes in order to stop smooth zoom + virtual status_t useBuffers(CameraMode mode, CameraBuffer* bufArr, int num, size_t length, unsigned int queueable); + + //Should be implemented by deriving classes in order queue a released buffer in CameraAdapter + virtual status_t fillThisBuffer(CameraBuffer* frameBuf, CameraFrame::FrameType frameType); + + //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 + virtual status_t getFrameSize(size_t &width, size_t &height); + + //API to get required data frame size + virtual status_t getFrameDataSize(size_t &dataFrameSize, size_t bufferCount); + + //API to get required picture buffers size with the current configuration in CameraParameters + virtual status_t getPictureBufferSize(CameraFrame &frame, size_t bufferCount); + + // Should be implemented by deriving classes in order to start face detection + // ( if supported ) + virtual status_t startFaceDetection(); + + // Should be implemented by deriving classes in order to stop face detection + // ( if supported ) + virtual status_t stopFaceDetection(); + + virtual status_t switchToExecuting(); + + virtual status_t setupTunnel(uint32_t SliceHeight, uint32_t EncoderHandle, uint32_t width, uint32_t height); + + virtual status_t destroyTunnel(); + + virtual status_t cameraPreviewInitialization(); + + // Receive orientation events from CameraHal + virtual void onOrientationEvent(uint32_t orientation, uint32_t tilt); + + // ---------------------Interface ends----------------------------------- + + status_t notifyFocusSubscribers(CameraHalEvent::FocusStatus status); + status_t notifyShutterSubscribers(); + status_t notifyZoomSubscribers(int zoomIdx, bool targetReached); + status_t notifyMetadataSubscribers(android::sp<CameraMetadataResult> &meta); + + //Send the frame to subscribers + status_t sendFrameToSubscribers(CameraFrame *frame); + + //Resets the refCount for this particular frame + status_t resetFrameRefCount(CameraFrame &frame); + + //A couple of helper functions + void setFrameRefCountByType(CameraBuffer* frameBuf, CameraFrame::FrameType frameType, int refCount); + int getFrameRefCount(CameraBuffer* frameBuf); + int getFrameRefCountByType(CameraBuffer* frameBuf, CameraFrame::FrameType frameType); + int setInitFrameRefCount(CameraBuffer* buf, unsigned int mask); + static const char* getLUTvalue_translateHAL(int Value, LUTtypeHAL LUT); + +// private member functions +private: + status_t __sendFrameToSubscribers(CameraFrame* frame, + android::KeyedVector<int, frame_callback> *subscribers, + CameraFrame::FrameType frameType); + status_t rollbackToPreviousState(); + +// protected data types and variables +protected: + enum FrameState { + STOPPED = 0, + RUNNING + }; + + enum FrameCommands { + START_PREVIEW = 0, + START_RECORDING, + RETURN_FRAME, + STOP_PREVIEW, + STOP_RECORDING, + DO_AUTOFOCUS, + TAKE_PICTURE, + FRAME_EXIT + }; + + enum AdapterCommands { + ACK = 0, + ERROR + }; + +#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS + + struct timeval mStartFocus; + struct timeval mStartCapture; + +#endif + + mutable android::Mutex mReturnFrameLock; + + //Lock protecting the Adapter state + mutable android::Mutex mLock; + AdapterState mAdapterState; + AdapterState mNextState; + + //Different frame subscribers get stored using these + android::KeyedVector<int, frame_callback> mFrameSubscribers; + android::KeyedVector<int, frame_callback> mSnapshotSubscribers; + android::KeyedVector<int, frame_callback> mFrameDataSubscribers; + android::KeyedVector<int, frame_callback> mVideoSubscribers; + android::KeyedVector<int, frame_callback> mVideoInSubscribers; + android::KeyedVector<int, frame_callback> mImageSubscribers; + android::KeyedVector<int, frame_callback> mRawSubscribers; + android::KeyedVector<int, event_callback> mFocusSubscribers; + android::KeyedVector<int, event_callback> mZoomSubscribers; + android::KeyedVector<int, event_callback> mShutterSubscribers; + android::KeyedVector<int, event_callback> mMetadataSubscribers; + + //Preview buffer management data + CameraBuffer *mPreviewBuffers; + int mPreviewBufferCount; + size_t mPreviewBuffersLength; + android::KeyedVector<CameraBuffer *, int> mPreviewBuffersAvailable; + mutable android::Mutex mPreviewBufferLock; + + //Snapshot buffer management data + android::KeyedVector<CameraBuffer *, int> mSnapshotBuffersAvailable; + mutable android::Mutex mSnapshotBufferLock; + + //Video buffer management data + CameraBuffer *mVideoBuffers; + android::KeyedVector<CameraBuffer *, int> mVideoBuffersAvailable; + int mVideoBuffersCount; + size_t mVideoBuffersLength; + mutable android::Mutex mVideoBufferLock; + + //Image buffer management data + CameraBuffer *mCaptureBuffers; + android::KeyedVector<CameraBuffer *, int> mCaptureBuffersAvailable; + int mCaptureBuffersCount; + size_t mCaptureBuffersLength; + mutable android::Mutex mCaptureBufferLock; + + //Metadata buffermanagement + CameraBuffer *mPreviewDataBuffers; + android::KeyedVector<CameraBuffer *, int> mPreviewDataBuffersAvailable; + int mPreviewDataBuffersCount; + size_t mPreviewDataBuffersLength; + mutable android::Mutex mPreviewDataBufferLock; + + //Video input buffer management data (used for reproc pipe) + CameraBuffer *mVideoInBuffers; + android::KeyedVector<CameraBuffer *, int> mVideoInBuffersAvailable; + mutable android::Mutex mVideoInBufferLock; + + Utils::MessageQueue mFrameQ; + Utils::MessageQueue mAdapterQ; + mutable android::Mutex mSubscriberLock; + ErrorNotifier *mErrorNotifier; + release_image_buffers_callback mReleaseImageBuffersCallback; + end_image_capture_callback mEndImageCaptureCallback; + void *mReleaseData; + void *mEndCaptureData; + bool mRecording; + + camera_request_memory mSharedAllocator; + + uint32_t mFramesWithDucati; + uint32_t mFramesWithDisplay; + uint32_t mFramesWithEncoder; + +#ifdef CAMERAHAL_DEBUG + android::Mutex mBuffersWithDucatiLock; + android::KeyedVector<int, bool> mBuffersWithDucati; +#endif + + android::KeyedVector<void *, CameraFrame *> mFrameQueue; +}; + +} // namespace Camera +} // namespace Ti + +#endif //BASE_CAMERA_ADAPTER_H + + |