1 #ifndef ANDROID_DVR_NATIVE_BUFFER_H_ 2 #define ANDROID_DVR_NATIVE_BUFFER_H_ 3 4 #include <EGL/egl.h> 5 #include <EGL/eglext.h> 6 #include <log/log.h> 7 #include <system/window.h> 8 #include <ui/ANativeObjectBase.h> 9 #include <utils/RefBase.h> 10 11 #include <private/dvr/buffer_hub_client.h> 12 13 namespace android { 14 namespace dvr { 15 16 // ANativeWindowBuffer is the abstraction Android HALs and frameworks use to 17 // pass around hardware graphics buffers. The following classes implement this 18 // abstraction with different DVR backing buffers, all of which provide 19 // different semantics on top of ion/gralloc buffers. 20 21 // An implementation of ANativeWindowBuffer backed by an IonBuffer. 22 class NativeBuffer 23 : public android::ANativeObjectBase<ANativeWindowBuffer, NativeBuffer, 24 android::LightRefBase<NativeBuffer>> { 25 public: 26 static constexpr int kEmptyFence = -1; 27 NativeBuffer(const std::shared_ptr<IonBuffer> & buffer)28 explicit NativeBuffer(const std::shared_ptr<IonBuffer>& buffer) 29 : BASE(), buffer_(buffer), fence_(kEmptyFence) { 30 ANativeWindowBuffer::width = buffer->width(); 31 ANativeWindowBuffer::height = buffer->height(); 32 ANativeWindowBuffer::stride = buffer->stride(); 33 ANativeWindowBuffer::format = buffer->format(); 34 ANativeWindowBuffer::usage = buffer->usage(); 35 handle = buffer_->handle(); 36 } 37 ~NativeBuffer()38 virtual ~NativeBuffer() {} 39 buffer()40 std::shared_ptr<IonBuffer> buffer() { return buffer_; } fence()41 int fence() const { return fence_.Get(); } 42 SetFence(int fence)43 void SetFence(int fence) { fence_.Reset(fence); } 44 45 private: 46 friend class android::LightRefBase<NativeBuffer>; 47 48 std::shared_ptr<IonBuffer> buffer_; 49 pdx::LocalHandle fence_; 50 51 NativeBuffer(const NativeBuffer&) = delete; 52 void operator=(NativeBuffer&) = delete; 53 }; 54 55 // NativeBufferProducer is an implementation of ANativeWindowBuffer backed by a 56 // BufferProducer. 57 class NativeBufferProducer : public android::ANativeObjectBase< 58 ANativeWindowBuffer, NativeBufferProducer, 59 android::LightRefBase<NativeBufferProducer>> { 60 public: 61 static constexpr int kEmptyFence = -1; 62 NativeBufferProducer(const std::shared_ptr<BufferProducer> & buffer,EGLDisplay display,uint32_t surface_buffer_index)63 NativeBufferProducer(const std::shared_ptr<BufferProducer>& buffer, 64 EGLDisplay display, uint32_t surface_buffer_index) 65 : BASE(), 66 buffer_(buffer), 67 surface_buffer_index_(surface_buffer_index), 68 display_(display) { 69 ANativeWindowBuffer::width = buffer_->width(); 70 ANativeWindowBuffer::height = buffer_->height(); 71 ANativeWindowBuffer::stride = buffer_->stride(); 72 ANativeWindowBuffer::format = buffer_->format(); 73 ANativeWindowBuffer::usage = buffer_->usage(); 74 handle = buffer_->native_handle(); 75 } 76 NativeBufferProducer(const std::shared_ptr<BufferProducer> & buffer)77 explicit NativeBufferProducer(const std::shared_ptr<BufferProducer>& buffer) 78 : NativeBufferProducer(buffer, nullptr, 0) {} 79 ~NativeBufferProducer()80 virtual ~NativeBufferProducer() { 81 for (EGLImageKHR egl_image : egl_images_) { 82 if (egl_image != EGL_NO_IMAGE_KHR) 83 eglDestroyImageKHR(display_, egl_image); 84 } 85 } 86 image_khr(int index)87 EGLImageKHR image_khr(int index) const { return egl_images_[index]; } buffer()88 std::shared_ptr<BufferProducer> buffer() const { return buffer_; } release_fence()89 int release_fence() const { return release_fence_.Get(); } surface_buffer_index()90 uint32_t surface_buffer_index() const { return surface_buffer_index_; } 91 92 // Return the release fence, passing ownership to the caller. ClaimReleaseFence()93 pdx::LocalHandle ClaimReleaseFence() { return std::move(release_fence_); } 94 95 // Post the buffer consumer, closing the acquire and release fences. Post(int acquire_fence,uint64_t sequence)96 int Post(int acquire_fence, uint64_t sequence) { 97 release_fence_.Close(); 98 return buffer_->Post(pdx::LocalHandle(acquire_fence), sequence); 99 } 100 101 // Gain the buffer producer, closing the previous release fence if valid. Gain()102 int Gain() { return buffer_->Gain(&release_fence_); } 103 104 // Asynchronously gain the buffer, closing the previous release fence. GainAsync()105 int GainAsync() { 106 release_fence_.Close(); 107 return buffer_->GainAsync(); 108 } 109 110 private: 111 friend class android::LightRefBase<NativeBufferProducer>; 112 113 std::shared_ptr<BufferProducer> buffer_; 114 pdx::LocalHandle release_fence_; 115 std::vector<EGLImageKHR> egl_images_; 116 uint32_t surface_buffer_index_; 117 EGLDisplay display_; 118 119 NativeBufferProducer(const NativeBufferProducer&) = delete; 120 void operator=(NativeBufferProducer&) = delete; 121 }; 122 123 // NativeBufferConsumer is an implementation of ANativeWindowBuffer backed by a 124 // BufferConsumer. 125 class NativeBufferConsumer : public android::ANativeObjectBase< 126 ANativeWindowBuffer, NativeBufferConsumer, 127 android::LightRefBase<NativeBufferConsumer>> { 128 public: 129 static constexpr int kEmptyFence = -1; 130 NativeBufferConsumer(const std::shared_ptr<BufferConsumer> & buffer)131 explicit NativeBufferConsumer(const std::shared_ptr<BufferConsumer>& buffer) 132 : BASE(), buffer_(buffer), acquire_fence_(kEmptyFence), sequence_(0) { 133 ANativeWindowBuffer::width = buffer_->width(); 134 ANativeWindowBuffer::height = buffer_->height(); 135 ANativeWindowBuffer::stride = buffer_->stride(); 136 ANativeWindowBuffer::format = buffer_->format(); 137 ANativeWindowBuffer::usage = buffer_->usage(); 138 handle = buffer_->native_handle(); 139 } 140 ~NativeBufferConsumer()141 virtual ~NativeBufferConsumer() {} 142 buffer()143 std::shared_ptr<BufferConsumer> buffer() const { return buffer_; } acquire_fence()144 int acquire_fence() const { return acquire_fence_.Get(); } sequence()145 uint64_t sequence() const { return sequence_; } 146 147 // Return the acquire fence, passing ownership to the caller. ClaimAcquireFence()148 pdx::LocalHandle ClaimAcquireFence() { return std::move(acquire_fence_); } 149 150 // Acquire the underlying buffer consumer, closing the previous acquire fence 151 // if valid. Acquire()152 int Acquire() { return buffer_->Acquire(&acquire_fence_, &sequence_); } 153 154 // Release the buffer consumer, closing the acquire and release fences if 155 // valid. Release(int release_fence)156 int Release(int release_fence) { 157 acquire_fence_.Close(); 158 sequence_ = 0; 159 return buffer_->Release(pdx::LocalHandle(release_fence)); 160 } 161 162 private: 163 friend class android::LightRefBase<NativeBufferConsumer>; 164 165 std::shared_ptr<BufferConsumer> buffer_; 166 pdx::LocalHandle acquire_fence_; 167 uint64_t sequence_; 168 169 NativeBufferConsumer(const NativeBufferConsumer&) = delete; 170 void operator=(NativeBufferConsumer&) = delete; 171 }; 172 173 } // namespace dvr 174 } // namespace android 175 176 #endif // ANDROID_DVR_NATIVE_BUFFER_H_ 177