bufferhub_rpc.h revision 044963e1dd0479035b6e5f2c6bd618bde7143710
1#ifndef ANDROID_DVR_BUFFERHUB_RPC_H_ 2#define ANDROID_DVR_BUFFERHUB_RPC_H_ 3 4#include <cutils/native_handle.h> 5#include <gui/BufferQueueDefs.h> 6#include <sys/types.h> 7 8#include <pdx/channel_handle.h> 9#include <pdx/file_handle.h> 10#include <pdx/rpc/remote_method.h> 11#include <pdx/rpc/serializable.h> 12#include <private/dvr/ion_buffer.h> 13 14namespace android { 15namespace dvr { 16 17template <typename FileHandleType> 18class NativeBufferHandle { 19 public: 20 NativeBufferHandle() { Clear(); } 21 NativeBufferHandle(const IonBuffer& buffer, int id) 22 : id_(id), 23 stride_(buffer.stride()), 24 width_(buffer.width()), 25 height_(buffer.height()), 26 format_(buffer.format()), 27 producer_usage_(buffer.usage()), 28 consumer_usage_(buffer.usage()) { 29 // Populate the fd and int vectors: native_handle->data[] is an array of fds 30 // followed by an array of opaque ints. 31 const int fd_count = buffer.handle()->numFds; 32 const int int_count = buffer.handle()->numInts; 33 for (int i = 0; i < fd_count; i++) { 34 fds_.emplace_back(FileHandleType::AsDuplicate(buffer.handle()->data[i])); 35 } 36 for (int i = 0; i < int_count; i++) { 37 opaque_ints_.push_back(buffer.handle()->data[fd_count + i]); 38 } 39 } 40 NativeBufferHandle(NativeBufferHandle&& other) = default; 41 NativeBufferHandle& operator=(NativeBufferHandle&& other) = default; 42 43 // Imports the native handle into the given IonBuffer instance. 44 int Import(IonBuffer* buffer) { 45 // This is annoying, but we need to convert the vector of FileHandles into a 46 // vector of ints for the Import API. 47 std::vector<int> fd_ints; 48 for (const auto& fd : fds_) 49 fd_ints.push_back(fd.Get()); 50 51 // TODO(b/37881101) Get rid of producer/consumer usage. 52 const int ret = 53 buffer->Import(fd_ints.data(), fd_ints.size(), opaque_ints_.data(), 54 opaque_ints_.size(), width_, height_, stride_, format_, 55 (producer_usage_ | consumer_usage_)); 56 if (ret < 0) 57 return ret; 58 59 // Import succeeded, release the file handles which are now owned by the 60 // IonBuffer and clear members. 61 for (auto& fd : fds_) 62 fd.Release(); 63 opaque_ints_.clear(); 64 Clear(); 65 66 return 0; 67 } 68 69 int id() const { return id_; } 70 size_t IntCount() const { return opaque_ints_.size(); } 71 size_t FdCount() const { return fds_.size(); } 72 73 private: 74 int id_; 75 uint32_t stride_; 76 uint32_t width_; 77 uint32_t height_; 78 uint32_t format_; 79 uint64_t producer_usage_; 80 uint64_t consumer_usage_; 81 std::vector<int> opaque_ints_; 82 std::vector<FileHandleType> fds_; 83 84 void Clear() { 85 id_ = -1; 86 stride_ = width_ = height_ = format_ = producer_usage_ = consumer_usage_ = 87 0; 88 } 89 90 PDX_SERIALIZABLE_MEMBERS(NativeBufferHandle<FileHandleType>, id_, stride_, 91 width_, height_, format_, producer_usage_, 92 consumer_usage_, opaque_ints_, fds_); 93 94 NativeBufferHandle(const NativeBufferHandle&) = delete; 95 void operator=(const NativeBufferHandle&) = delete; 96}; 97 98using BorrowedNativeBufferHandle = NativeBufferHandle<pdx::BorrowedHandle>; 99using LocalNativeBufferHandle = NativeBufferHandle<pdx::LocalHandle>; 100 101template <typename FileHandleType> 102class FenceHandle { 103 public: 104 FenceHandle() = default; 105 explicit FenceHandle(int fence) : fence_{fence} {} 106 explicit FenceHandle(FileHandleType&& fence) : fence_{std::move(fence)} {} 107 FenceHandle(FenceHandle&&) = default; 108 FenceHandle& operator=(FenceHandle&&) = default; 109 110 explicit operator bool() const { return fence_.IsValid(); } 111 112 const FileHandleType& get() const { fence_; } 113 FileHandleType&& take() { return std::move(fence_); } 114 115 int get_fd() const { return fence_.Get(); } 116 void close() { fence_.Close(); } 117 118 FenceHandle<pdx::BorrowedHandle> borrow() const { 119 return FenceHandle<pdx::BorrowedHandle>(fence_.Borrow()); 120 } 121 122 private: 123 FileHandleType fence_; 124 125 PDX_SERIALIZABLE_MEMBERS(FenceHandle<FileHandleType>, fence_); 126 127 FenceHandle(const FenceHandle&) = delete; 128 void operator=(const FenceHandle&) = delete; 129}; 130 131using LocalFence = FenceHandle<pdx::LocalHandle>; 132using BorrowedFence = FenceHandle<pdx::BorrowedHandle>; 133 134struct QueueInfo { 135 size_t meta_size_bytes; 136 int id; 137 138 private: 139 PDX_SERIALIZABLE_MEMBERS(QueueInfo, meta_size_bytes, id); 140}; 141 142struct UsagePolicy { 143 uint64_t producer_set_mask; 144 uint64_t producer_clear_mask; 145 uint64_t producer_deny_set_mask; 146 uint64_t producer_deny_clear_mask; 147 uint64_t consumer_set_mask; 148 uint64_t consumer_clear_mask; 149 uint64_t consumer_deny_set_mask; 150 uint64_t consumer_deny_clear_mask; 151 152 private: 153 PDX_SERIALIZABLE_MEMBERS(UsagePolicy, producer_set_mask, producer_clear_mask, 154 producer_deny_set_mask, producer_deny_clear_mask, 155 consumer_set_mask, consumer_clear_mask, 156 consumer_deny_set_mask, consumer_deny_clear_mask); 157}; 158 159// BufferHub Service RPC interface. Defines the endpoints, op codes, and method 160// type signatures supported by bufferhubd. 161struct BufferHubRPC { 162 // Service path. 163 static constexpr char kClientPath[] = "system/buffer_hub/client"; 164 165 // |BufferHubQueue| will keep track of at most this value of buffers. 166 // Attempts at runtime to increase the number of buffers past this 167 // will fail. Note that the value is in sync with |android::BufferQueue|, so 168 // that slot id can be shared between |android::dvr::BufferHubQueueProducer| 169 // and |android::BufferQueueProducer| which both implements the same 170 // interface: |android::IGraphicBufferProducer|. 171 static constexpr size_t kMaxQueueCapacity = 172 android::BufferQueueDefs::NUM_BUFFER_SLOTS; 173 174 // Op codes. 175 enum { 176 kOpCreateBuffer = 0, 177 kOpCreatePersistentBuffer, 178 kOpGetPersistentBuffer, 179 kOpGetBuffer, 180 kOpGetBuffers, 181 kOpNewConsumer, 182 kOpProducerMakePersistent, 183 kOpProducerRemovePersistence, 184 kOpProducerPost, 185 kOpProducerGain, 186 kOpConsumerAcquire, 187 kOpConsumerRelease, 188 kOpConsumerSetIgnore, 189 kOpCreateProducerQueue, 190 kOpCreateConsumerQueue, 191 kOpGetQueueInfo, 192 kOpProducerQueueAllocateBuffers, 193 kOpProducerQueueDetachBuffer, 194 kOpConsumerQueueImportBuffers, 195 }; 196 197 // Aliases. 198 using MetaData = pdx::rpc::BufferWrapper<std::uint8_t*>; 199 using LocalChannelHandle = pdx::LocalChannelHandle; 200 using LocalHandle = pdx::LocalHandle; 201 using Void = pdx::rpc::Void; 202 203 // Methods. 204 PDX_REMOTE_METHOD(CreateBuffer, kOpCreateBuffer, 205 void(uint32_t width, uint32_t height, uint32_t format, 206 uint64_t producer_usage, uint64_t consumer_usage, 207 size_t meta_size_bytes, size_t slice_count)); 208 PDX_REMOTE_METHOD(CreatePersistentBuffer, kOpCreatePersistentBuffer, 209 void(const std::string& name, int user_id, int group_id, 210 uint32_t width, uint32_t height, uint32_t format, 211 uint64_t producer_usage, uint64_t consumer_usage, 212 size_t meta_size_bytes, size_t slice_count)); 213 PDX_REMOTE_METHOD(GetPersistentBuffer, kOpGetPersistentBuffer, 214 void(const std::string& name)); 215 PDX_REMOTE_METHOD(GetBuffer, kOpGetBuffer, 216 NativeBufferHandle<LocalHandle>(unsigned index)); 217 PDX_REMOTE_METHOD(GetBuffers, kOpGetBuffers, 218 std::vector<NativeBufferHandle<LocalHandle>>(Void)); 219 PDX_REMOTE_METHOD(NewConsumer, kOpNewConsumer, LocalChannelHandle(Void)); 220 PDX_REMOTE_METHOD(ProducerMakePersistent, kOpProducerMakePersistent, 221 void(const std::string& name, int user_id, int group_id)); 222 PDX_REMOTE_METHOD(ProducerRemovePersistence, kOpProducerRemovePersistence, 223 void(Void)); 224 PDX_REMOTE_METHOD(ProducerPost, kOpProducerPost, 225 void(LocalFence acquire_fence, MetaData)); 226 PDX_REMOTE_METHOD(ProducerGain, kOpProducerGain, LocalFence(Void)); 227 PDX_REMOTE_METHOD(ConsumerAcquire, kOpConsumerAcquire, 228 std::pair<LocalFence, MetaData>(std::size_t metadata_size)); 229 PDX_REMOTE_METHOD(ConsumerRelease, kOpConsumerRelease, 230 void(LocalFence release_fence)); 231 PDX_REMOTE_METHOD(ConsumerSetIgnore, kOpConsumerSetIgnore, void(bool ignore)); 232 233 // Buffer Queue Methods. 234 PDX_REMOTE_METHOD(CreateProducerQueue, kOpCreateProducerQueue, 235 QueueInfo(size_t meta_size_bytes, 236 const UsagePolicy& usage_policy)); 237 PDX_REMOTE_METHOD(CreateConsumerQueue, kOpCreateConsumerQueue, 238 LocalChannelHandle(Void)); 239 PDX_REMOTE_METHOD(GetQueueInfo, kOpGetQueueInfo, QueueInfo(Void)); 240 PDX_REMOTE_METHOD(ProducerQueueAllocateBuffers, 241 kOpProducerQueueAllocateBuffers, 242 std::vector<std::pair<LocalChannelHandle, size_t>>( 243 uint32_t width, uint32_t height, uint32_t format, 244 uint64_t producer_usage, uint64_t consumer_usage, 245 size_t slice_count, size_t buffer_count)); 246 PDX_REMOTE_METHOD(ProducerQueueDetachBuffer, kOpProducerQueueDetachBuffer, 247 void(size_t slot)); 248 PDX_REMOTE_METHOD(ConsumerQueueImportBuffers, kOpConsumerQueueImportBuffers, 249 std::vector<std::pair<LocalChannelHandle, size_t>>(Void)); 250}; 251 252} // namespace dvr 253} // namespace android 254 255#endif // ANDROID_DVR_BUFFERHUB_RPC_H_ 256