/* * Copyright (C) 2008 The Android Open Source Project * * 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_INTERFACE_H #define ANDROID_HARDWARE_CAMERA_HARDWARE_INTERFACE_H #include #include #include #include #include #include #include #include #include #include #include namespace android { typedef void (*notify_callback)(int32_t msgType, int32_t ext1, int32_t ext2, void* user); typedef void (*data_callback)(int32_t msgType, const sp &dataPtr, camera_frame_metadata_t *metadata, void* user); typedef void (*data_callback_timestamp)(nsecs_t timestamp, int32_t msgType, const sp &dataPtr, void *user); struct HandleTimestampMessage { nsecs_t timestamp; const sp dataPtr; }; typedef void (*data_callback_timestamp_batch)( int32_t msgType, const std::vector&, void* user); /** * CameraHardwareInterface.h defines the interface to the * camera hardware abstraction layer, used for setting and getting * parameters, live previewing, and taking pictures. It is used for * HAL devices with version CAMERA_DEVICE_API_VERSION_1_0 only. * * It is a referenced counted interface with RefBase as its base class. * CameraService calls openCameraHardware() to retrieve a strong pointer to the * instance of this interface and may be called multiple times. The * following steps describe a typical sequence: * * -# After CameraService calls openCameraHardware(), getParameters() and * setParameters() are used to initialize the camera instance. * -# startPreview() is called. * * Prior to taking a picture, CameraService often calls autofocus(). When auto * focusing has completed, the camera instance sends a CAMERA_MSG_FOCUS notification, * which informs the application whether focusing was successful. The camera instance * only sends this message once and it is up to the application to call autoFocus() * again if refocusing is desired. * * CameraService calls takePicture() to request the camera instance take a * picture. At this point, if a shutter, postview, raw, and/or compressed * callback is desired, the corresponding message must be enabled. Any memory * provided in a data callback must be copied if it's needed after returning. */ class CameraHardwareInterface : public virtual RefBase, public virtual hardware::camera::device::V1_0::ICameraDeviceCallback, public virtual hardware::camera::device::V1_0::ICameraDevicePreviewCallback { public: explicit CameraHardwareInterface(const char *name): mHidlDevice(nullptr), mName(name), mPreviewScalingMode(NOT_SET), mPreviewTransform(NOT_SET), mPreviewWidth(NOT_SET), mPreviewHeight(NOT_SET), mPreviewFormat(NOT_SET), mPreviewUsage(0), mPreviewSwapInterval(NOT_SET), mPreviewCrop{NOT_SET,NOT_SET,NOT_SET,NOT_SET} { } ~CameraHardwareInterface(); status_t initialize(sp manager); /** Set the ANativeWindow to which preview frames are sent */ status_t setPreviewWindow(const sp& buf); status_t setPreviewScalingMode(int scalingMode); status_t setPreviewTransform(int transform); /** Set the notification and data callbacks */ void setCallbacks(notify_callback notify_cb, data_callback data_cb, data_callback_timestamp data_cb_timestamp, data_callback_timestamp_batch data_cb_timestamp_batch, void* user); /** * 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. * * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera hal * should not rely on its client to call releaseRecordingFrame() to release * video recording frames sent out by the cameral hal before and after the * disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera hal clients must not * modify/access any video recording frame after calling * disableMsgType(CAMERA_MSG_VIDEO_FRAME). */ 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. */ status_t startPreview(); /** * Stop a previously started preview. */ void stopPreview(); /** * Returns true if preview is enabled. */ int previewEnabled(); /** * Request the camera hal to store meta data or real YUV data in * the video buffers send out via CAMERA_MSG_VIDEO_FRRAME for a * recording session. If it is not called, the default camera * hal behavior is to store real YUV data in the video buffers. * * This method should be called before startRecording() in order * to be effective. * * If meta data is stored in the video buffers, it is up to the * receiver of the video buffers to interpret the contents and * to find the actual frame data with the help of the meta data * in the buffer. How this is done is outside of the scope of * this method. * * Some camera hal may not support storing meta data in the video * buffers, but all camera hal should support storing real YUV data * in the video buffers. If the camera hal does not support storing * the meta data in the video buffers when it is requested to do * do, INVALID_OPERATION must be returned. It is very useful for * the camera hal to pass meta data rather than the actual frame * data directly to the video encoder, since the amount of the * uncompressed frame data can be very large if video size is large. * * @param enable if true to instruct the camera hal to store * meta data in the video buffers; false to instruct * the camera hal to store real YUV data in the video * buffers. * * @return OK on success. */ status_t storeMetaDataInBuffers(int enable); /** * 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 a cameral hal client via releaseRecordingFrame() before the client calls * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is camera hal's responsibility * to manage the life-cycle of the video recording frames, and the client must * not modify/access any video recording frames. */ status_t 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. * * It is camera hal client's responsibility to release video recording * frames sent out by the camera hal before the camera hal receives * a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives * the call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is camera hal's * responsibility of managing the life-cycle of the video recording * frames. */ void releaseRecordingFrame(const sp& mem); /** * Release a batch of recording frames previously returned by * CAMERA_MSG_VIDEO_FRAME. This method only supports frames that are * stored as VideoNativeHandleMetadata. * * It is camera hal client's responsibility to release video recording * frames sent out by the camera hal before the camera hal receives * a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives * the call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is camera hal's * responsibility of managing the life-cycle of the video recording * frames. */ void releaseRecordingFrameBatch(const std::vector>& frames); /** * 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. */ status_t 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. */ status_t cancelAutoFocus(); /** * Take a picture. */ status_t takePicture(); /** * Cancel a picture that was started with takePicture. Calling this * method when no picture is being taken is a no-op. */ status_t cancelPicture(); /** * Set the camera parameters. This returns BAD_VALUE if any parameter is * invalid or not supported. */ status_t setParameters(const CameraParameters ¶ms); /** Return the camera parameters. */ CameraParameters getParameters() const; /** * Send command to camera driver. */ status_t 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 */ status_t dump(int fd, const Vector& /*args*/) const; private: sp mHidlDevice; String8 mName; static void sNotifyCb(int32_t msg_type, int32_t ext1, int32_t ext2, void *user); static void sDataCb(int32_t msg_type, const camera_memory_t *data, unsigned int index, camera_frame_metadata_t *metadata, void *user); static void sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type, const camera_memory_t *data, unsigned index, void *user); // This is a utility class that combines a MemoryHeapBase and a MemoryBase // in one. Since we tend to use them in a one-to-one relationship, this is // handy. class CameraHeapMemory : public RefBase { public: CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers = 1) : mBufSize(buf_size), mNumBufs(num_buffers) { mHeap = new MemoryHeapBase(fd, buf_size * num_buffers); commonInitialization(); } explicit CameraHeapMemory(size_t buf_size, uint_t num_buffers = 1) : mBufSize(buf_size), mNumBufs(num_buffers) { mHeap = new MemoryHeapBase(buf_size * num_buffers); commonInitialization(); } void commonInitialization() { handle.data = mHeap->base(); handle.size = mBufSize * mNumBufs; handle.handle = this; mBuffers = new sp[mNumBufs]; for (uint_t i = 0; i < mNumBufs; i++) mBuffers[i] = new MemoryBase(mHeap, i * mBufSize, mBufSize); handle.release = sPutMemory; } virtual ~CameraHeapMemory() { delete [] mBuffers; } size_t mBufSize; uint_t mNumBufs; sp mHeap; sp *mBuffers; camera_memory_t handle; }; static camera_memory_t* sGetMemory(int fd, size_t buf_size, uint_t num_bufs, void *user __attribute__((unused))); static void sPutMemory(camera_memory_t *data); std::pair getBufferId(ANativeWindowBuffer* anb); void cleanupCirculatingBuffers(); /** * Implementation of android::hardware::camera::device::V1_0::ICameraDeviceCallback */ hardware::Return notifyCallback( hardware::camera::device::V1_0::NotifyCallbackMsg msgType, int32_t ext1, int32_t ext2) override; hardware::Return registerMemory( const hardware::hidl_handle& descriptor, uint32_t bufferSize, uint32_t bufferCount) override; hardware::Return unregisterMemory(uint32_t memId) override; hardware::Return dataCallback( hardware::camera::device::V1_0::DataCallbackMsg msgType, uint32_t data, uint32_t bufferIndex, const hardware::camera::device::V1_0::CameraFrameMetadata& metadata) override; hardware::Return dataCallbackTimestamp( hardware::camera::device::V1_0::DataCallbackMsg msgType, uint32_t data, uint32_t bufferIndex, int64_t timestamp) override; hardware::Return handleCallbackTimestamp( hardware::camera::device::V1_0::DataCallbackMsg msgType, const hardware::hidl_handle& frameData, uint32_t data, uint32_t bufferIndex, int64_t timestamp) override; hardware::Return handleCallbackTimestampBatch( hardware::camera::device::V1_0::DataCallbackMsg msgType, const hardware::hidl_vec< hardware::camera::device::V1_0::HandleTimestampMessage>&) override; /** * Implementation of android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback */ hardware::Return dequeueBuffer(dequeueBuffer_cb _hidl_cb) override; hardware::Return enqueueBuffer(uint64_t bufferId) override; hardware::Return cancelBuffer(uint64_t bufferId) override; hardware::Return setBufferCount(uint32_t count) override; hardware::Return setBuffersGeometry(uint32_t w, uint32_t h, hardware::graphics::common::V1_0::PixelFormat format) override; hardware::Return setCrop(int32_t left, int32_t top, int32_t right, int32_t bottom) override; hardware::Return setUsage(hardware::graphics::common::V1_0::BufferUsage usage) override; hardware::Return setSwapInterval(int32_t interval) override; hardware::Return getMinUndequeuedBufferCount( getMinUndequeuedBufferCount_cb _hidl_cb) override; hardware::Return setTimestamp(int64_t timestamp) override; sp mPreviewWindow; notify_callback mNotifyCb; data_callback mDataCb; data_callback_timestamp mDataCbTimestamp; data_callback_timestamp_batch mDataCbTimestampBatch; void *mCbUser; // Cached values for preview stream parameters static const int NOT_SET = -1; int mPreviewScalingMode; int mPreviewTransform; int mPreviewWidth; int mPreviewHeight; int mPreviewFormat; uint64_t mPreviewUsage; int mPreviewSwapInterval; android_native_rect_t mPreviewCrop; struct BufferHasher { size_t operator()(const buffer_handle_t& buf) const { if (buf == nullptr) return 0; size_t result = 1; result = 31 * result + buf->numFds; result = 31 * result + buf->numInts; int length = buf->numFds + buf->numInts; for (int i = 0; i < length; i++) { result = 31 * result + buf->data[i]; } return result; } }; struct BufferComparator { bool operator()(const buffer_handle_t& buf1, const buffer_handle_t& buf2) const { if (buf1->numFds == buf2->numFds && buf1->numInts == buf2->numInts) { int length = buf1->numFds + buf1->numInts; for (int i = 0; i < length; i++) { if (buf1->data[i] != buf2->data[i]) { return false; } } return true; } return false; } }; std::mutex mBufferIdMapLock; // protecting mBufferIdMap and mNextBufferId typedef std::unordered_map BufferIdMap; // stream ID -> per stream buffer ID map BufferIdMap mBufferIdMap; std::unordered_map mReversedBufMap; uint64_t mNextBufferId = 1; static const uint64_t BUFFER_ID_NO_BUFFER = 0; std::mutex mHidlMemPoolMapLock; // protecting mHidlMemPoolMap std::unordered_map mHidlMemPoolMap; }; }; // namespace android #endif