1 /* Copyright 2017 The Chromium OS Authors. All rights reserved. 2 * Use of this source code is governed by a BSD-style license that can be 3 * found in the LICENSE file. 4 */ 5 6 #ifndef HAL_USB_FRAME_BUFFER_H_ 7 #define HAL_USB_FRAME_BUFFER_H_ 8 9 #include <cstdint> 10 #include <memory> 11 12 #include <base/files/scoped_file.h> 13 #include <base/synchronization/lock.h> 14 #include <hardware/gralloc.h> 15 16 namespace arc { 17 18 class FrameBuffer { 19 public: 20 FrameBuffer(); 21 virtual ~FrameBuffer(); 22 23 // If mapped successfully, the address will be assigned to |data_| and return 24 // 0. Otherwise, returns -EINVAL. 25 virtual int Map() = 0; 26 27 // Unmaps the mapped address. Returns 0 for success. 28 virtual int Unmap() = 0; 29 GetData()30 uint8_t* GetData() const { return data_; } GetDataSize()31 size_t GetDataSize() const { return data_size_; } GetBufferSize()32 size_t GetBufferSize() const { return buffer_size_; } GetWidth()33 uint32_t GetWidth() const { return width_; } GetHeight()34 uint32_t GetHeight() const { return height_; } GetFourcc()35 uint32_t GetFourcc() const { return fourcc_; } 36 SetFourcc(uint32_t fourcc)37 void SetFourcc(uint32_t fourcc) { fourcc_ = fourcc; } 38 virtual int SetDataSize(size_t data_size); 39 40 protected: 41 uint8_t* data_; 42 43 // The number of bytes used in the buffer. 44 size_t data_size_; 45 46 // The number of bytes allocated in the buffer. 47 size_t buffer_size_; 48 49 // Frame resolution. 50 uint32_t width_; 51 uint32_t height_; 52 53 // This is V4L2_PIX_FMT_* in linux/videodev2.h. 54 uint32_t fourcc_; 55 }; 56 57 // AllocatedFrameBuffer is used for the buffer from hal malloc-ed. User should 58 // be aware to manage the memory. 59 class AllocatedFrameBuffer : public FrameBuffer { 60 public: 61 explicit AllocatedFrameBuffer(int buffer_size); 62 explicit AllocatedFrameBuffer(uint8_t* buffer, int buffer_size); 63 ~AllocatedFrameBuffer() override; 64 65 // No-op for the two functions. Map()66 int Map() override { return 0; } Unmap()67 int Unmap() override { return 0; } 68 SetWidth(uint32_t width)69 void SetWidth(uint32_t width) { width_ = width; } SetHeight(uint32_t height)70 void SetHeight(uint32_t height) { height_ = height; } 71 int SetDataSize(size_t data_size) override; 72 void Reset(); 73 74 private: 75 std::unique_ptr<uint8_t[]> buffer_; 76 }; 77 78 // V4L2FrameBuffer is used for the buffer from V4L2CameraDevice. Maps the fd 79 // in constructor. Unmaps and closes the fd in destructor. 80 class V4L2FrameBuffer : public FrameBuffer { 81 public: 82 V4L2FrameBuffer(base::ScopedFD fd, int buffer_size, uint32_t width, 83 uint32_t height, uint32_t fourcc); 84 // Unmaps |data_| and closes |fd_|. 85 ~V4L2FrameBuffer(); 86 87 int Map() override; 88 int Unmap() override; GetFd()89 int GetFd() const { return fd_.get(); } 90 91 private: 92 // File descriptor of V4L2 frame buffer. 93 base::ScopedFD fd_; 94 95 bool is_mapped_; 96 97 // Lock to guard |is_mapped_|. 98 base::Lock lock_; 99 }; 100 101 // GrallocFrameBuffer is used for the buffer from Android framework. Uses 102 // CameraBufferMapper to lock and unlock the buffer. 103 class GrallocFrameBuffer : public FrameBuffer { 104 public: 105 GrallocFrameBuffer(buffer_handle_t buffer, uint32_t width, uint32_t height, 106 uint32_t fourcc, uint32_t device_buffer_length, 107 uint32_t stream_usage); 108 ~GrallocFrameBuffer(); 109 110 int Map() override; 111 int Unmap() override; 112 113 private: 114 // The currently used buffer for |buffer_mapper_| operations. 115 buffer_handle_t buffer_; 116 117 // Used to import gralloc buffer. 118 const gralloc_module_t* gralloc_module_; 119 120 bool is_mapped_; 121 122 // Lock to guard |is_mapped_|. 123 base::Lock lock_; 124 125 // Camera stream and device buffer context. 126 uint32_t device_buffer_length_; 127 uint32_t stream_usage_; 128 }; 129 130 } // namespace arc 131 132 #endif // HAL_USB_FRAME_BUFFER_H_ 133