| /* |
| * Copyright (C) 2013-2017 Intel Corporation |
| * Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd |
| * |
| * 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 _CAMERA3_HAL_CAMERA_BUFFER_H_ |
| #define _CAMERA3_HAL_CAMERA_BUFFER_H_ |
| |
| #include <utils/Errors.h> |
| #include <hardware/camera3.h> |
| #include "Camera3V4l2Format.h" |
| #include "UtilityMacros.h" |
| #include <camera_buffer_manager.h> |
| #include <memory> |
| #include <vector> |
| |
| NAMESPACE_DECLARATION { |
| |
| // Forward declaration to avoid extra include |
| class CameraStream; |
| |
| /** |
| * \class CameraBuffer |
| * |
| * This class is the buffer abstraction in the HAL. It can store buffers |
| * provided by the framework or buffers allocated by the HAL. |
| * Allocation in the HAL can be done via gralloc, malloc or mmap |
| * in case of mmap the memory cannot be freed |
| */ |
| class CameraBuffer { |
| public: |
| enum BufferType { |
| BUF_TYPE_HANDLE, |
| BUF_TYPE_MALLOC, |
| BUF_TYPE_MMAP, |
| }; |
| |
| public: |
| /* Convert NV12M/NV21M buffer to NV12/NV21 of heap buffer. Debug only. */ |
| static std::shared_ptr<CameraBuffer> |
| ConvertNVXXMToNVXXAsHeapBuffer(std::shared_ptr<CameraBuffer> input); |
| |
| static std::shared_ptr<CameraBuffer> |
| allocateHeapBuffer(int w, |
| int h, |
| int s, |
| int v4l2Fmt, |
| int cameraId, |
| int dataSizeOverride = 0); |
| |
| static std::shared_ptr<CameraBuffer> |
| allocateHandleBuffer(int w, |
| int h, |
| int gfxFmt, |
| int usage, |
| int cameraId); |
| |
| static std::shared_ptr<CameraBuffer> |
| createMMapBuffer(int w, int h, int s, int fd, |
| int lengthY, int lengthUV, int v4l2fmt, int offsetY, |
| int offsetUV, int prot, int flags); |
| |
| public: |
| /** |
| * default constructor |
| * Used for buffers coming from the framework. The wrapper is initialized |
| * using the method init |
| */ |
| CameraBuffer(); |
| |
| /** |
| * initialization for the wrapper around the framework buffers |
| */ |
| status_t init(const camera3_stream_buffer *aBuffer, int cameraId); |
| |
| /** |
| * initialization for the fake framework buffer (allocated by the HAL) |
| */ |
| status_t init(const camera3_stream_t* stream, buffer_handle_t buffer, |
| int cameraId); |
| |
| /** |
| * deinitialization for the wrapper around the framework buffers |
| */ |
| status_t deinit(); |
| |
| /** |
| * no need to delete a buffer since it is RefBase'd. Buffer will be deleted |
| * when no reference to it exist. |
| */ |
| ~CameraBuffer(); |
| |
| |
| void* data() { return mDataPtr; }; |
| void* dataY() { return mDataPtr; }; |
| void* dataUV() { return mDataPtrUV; }; |
| |
| status_t lock(); |
| status_t lock(int flags); |
| status_t unlock(); |
| |
| bool isRegistered() const { return mRegistered; }; |
| bool isLocked() const { return mLocked; }; |
| buffer_handle_t * getBufferHandle() { return &mHandle; }; |
| status_t waitOnAcquireFence(); |
| |
| void dump(); |
| void dumpImage(const int type, const char *name); |
| void dumpImage(const char *name); |
| void dumpImage(const void *data, const void* dataUV, |
| const int size, int sizeUV, int width, int height, |
| const char *name); |
| CameraStream * getOwner() const { return mOwner; } |
| int width() {return mWidth; } |
| int height() {return mHeight; } |
| int stride() {return mStride; } |
| unsigned int size() {return mSize; } |
| unsigned int sizeY() {return mSizeY; } |
| unsigned int sizeUV() {return mSizeUV; } |
| int format() {return mFormat; } |
| int v4l2Fmt() {return mV4L2Fmt; } |
| struct timeval timeStamp() {return mTimestamp; } |
| int64_t timeStampNano() { return TIMEVAL2NSECS(&mTimestamp); } |
| void setTimeStamp(struct timeval timestamp) {mTimestamp = timestamp; } |
| void setRequestId(int requestId) {mRequestID = requestId; } |
| int requestId() {return mRequestID; } |
| status_t getFence(camera3_stream_buffer* buf); |
| int dmaBufFd(int plane = 0); |
| int dmaBufFdOffset(int plane = 0); |
| int status() { return mUserBuffer.status; } |
| int cameraId() { return mCameraId; } |
| BufferType type() { return mType; } |
| bool nonContiguousYandUV() { return mNonContiguousYandUV; } |
| |
| protected: |
| /** |
| * constructor for the HAL-allocated buffer |
| * These are used via the utility methods. |
| */ |
| CameraBuffer(int w, int h, int s, int v4l2fmt, void* usrPtr, int cameraId, int dataSizeOverride = 0); |
| CameraBuffer(int w, int h, int s, int fd, int v4l2fmt, |
| std::vector<int> length, std::vector<int> offset, |
| int prot, int flags); |
| |
| private: |
| status_t registerBuffer(); |
| status_t deregisterBuffer(); |
| |
| private: |
| camera3_stream_buffer_t mUserBuffer; /*!< Original structure passed by request */ |
| int mWidth; |
| int mHeight; |
| unsigned int mSize; /*!< size in bytes, this is filled when we |
| lock the buffer */ |
| unsigned int mSizeY; /*!< size Y plane in bytes, this is filled when we |
| lock the buffer */ |
| unsigned int mSizeUV; /*!< size UV plane in bytes, this is filled when we |
| lock the buffer */ |
| int mFormat; /*!< HAL PIXEL fmt */ |
| int mV4L2Fmt; /*!< V4L2 fourcc format code */ |
| int mStride; |
| int mUsage; |
| struct timeval mTimestamp; |
| bool mInit; /*!< Boolean to check the integrity of the |
| buffer when it is created*/ |
| bool mLocked; /*!< Use to track the lock status */ |
| bool mRegistered; /*!< Use to track the buffer register status */ |
| |
| BufferType mType; |
| cros::CameraBufferManager* mGbmBufferManager; |
| buffer_handle_t mHandle; |
| buffer_handle_t* mHandlePtr; |
| CameraStream *mOwner; /*!< Stream this buffer belongs to */ |
| void* mDataPtr; /*!< if locked, here is the vaddr of Y */ |
| void* mDataPtrUV; /*!< if locked, here is the vaddr of UV */ |
| int mRequestID; /*!< this is filled by hw streams after |
| calling putframe */ |
| int mCameraId; |
| bool mNonContiguousYandUV; /*!< Whether Y and UV are non contiguous planes */ |
| }; |
| |
| |
| } NAMESPACE_DECLARATION_END |
| |
| #endif // _CAMERA3_HAL_CAMERA_BUFFER_H_ |