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