Add DaydreamVR native libraries and services
Upstreaming the main VR system components from master-dreamos-dev
into goog/master.
Bug: None
Test: `m -j32` succeeds. Sailfish boots and basic_vr sample app works
Change-Id: I853015872afc443aecee10411ef2d6b79184d051
diff --git a/services/vr/bufferhubd/producer_channel.h b/services/vr/bufferhubd/producer_channel.h
new file mode 100644
index 0000000..e7ca459
--- /dev/null
+++ b/services/vr/bufferhubd/producer_channel.h
@@ -0,0 +1,109 @@
+#ifndef ANDROID_DVR_BUFFERHUBD_PRODUCER_CHANNEL_H_
+#define ANDROID_DVR_BUFFERHUBD_PRODUCER_CHANNEL_H_
+
+#include "buffer_hub.h"
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include <pdx/channel_handle.h>
+#include <pdx/file_handle.h>
+#include <pdx/rpc/buffer_wrapper.h>
+#include <private/dvr/bufferhub_rpc.h>
+#include <private/dvr/ion_buffer.h>
+
+namespace android {
+namespace dvr {
+
+// The buffer changes ownership according to the following sequence:
+// POST -> ACQUIRE/RELEASE (all consumers) -> GAIN (producer acquires) -> POST
+
+// The producer channel is owned by a single app that writes into buffers and
+// calls POST when drawing is complete. This channel has a set of consumer
+// channels associated with it that are waiting for notifications.
+class ProducerChannel : public BufferHubChannel {
+ public:
+ using Message = pdx::Message;
+ using BorrowedHandle = pdx::BorrowedHandle;
+ using RemoteChannelHandle = pdx::RemoteChannelHandle;
+ template <typename T>
+ using BufferWrapper = pdx::rpc::BufferWrapper<T>;
+
+ static std::shared_ptr<ProducerChannel> Create(
+ BufferHubService* service, int channel_id, int width, int height,
+ int format, int usage, size_t meta_size_bytes, size_t slice_count,
+ int* error);
+
+ ~ProducerChannel() override;
+
+ bool HandleMessage(Message& message) override;
+ void HandleImpulse(Message& message) override;
+
+ BufferInfo GetBufferInfo() const override;
+
+ NativeBufferHandle<BorrowedHandle> OnGetBuffer(Message& message,
+ unsigned index);
+ std::vector<NativeBufferHandle<BorrowedHandle>> OnGetBuffers(
+ Message& message);
+
+ RemoteChannelHandle CreateConsumer(Message& message);
+ RemoteChannelHandle OnNewConsumer(Message& message);
+
+ std::pair<BorrowedFence, BufferWrapper<std::uint8_t*>> OnConsumerAcquire(
+ Message& message, std::size_t metadata_size);
+ int OnConsumerRelease(Message& message, LocalFence release_fence);
+
+ void OnConsumerIgnored();
+
+ void AddConsumer(ConsumerChannel* channel);
+ void RemoveConsumer(ConsumerChannel* channel);
+
+ bool CheckAccess(int euid, int egid);
+ bool CheckParameters(int width, int height, int format, int usage,
+ size_t meta_size_bytes, size_t slice_count);
+
+ int OnProducerMakePersistent(Message& message, const std::string& name,
+ int user_id, int group_id);
+ int OnRemovePersistence(Message& message);
+
+ private:
+ std::vector<ConsumerChannel*> consumer_channels_;
+ // This counts the number of consumers left to process this buffer. If this is
+ // zero then the producer can re-acquire ownership.
+ int pending_consumers_;
+
+ std::vector<IonBuffer> slices_;
+
+ bool producer_owns_;
+ LocalFence post_fence_;
+ LocalFence returned_fence_;
+ size_t meta_size_bytes_;
+ std::unique_ptr<uint8_t[]> meta_;
+
+ static constexpr int kNoCheckId = -1;
+ static constexpr int kUseCallerId = 0;
+ static constexpr int kRootId = 0;
+
+ // User and group id to check when obtaining a persistent buffer.
+ int owner_user_id_ = kNoCheckId;
+ int owner_group_id_ = kNoCheckId;
+
+ std::string name_;
+
+ ProducerChannel(BufferHubService* service, int channel, int width, int height,
+ int format, int usage, size_t meta_size_bytes,
+ size_t slice_count, int* error);
+
+ int OnProducerPost(Message& message, LocalFence acquire_fence,
+ BufferWrapper<std::vector<std::uint8_t>> metadata);
+ LocalFence OnProducerGain(Message& message);
+
+ ProducerChannel(const ProducerChannel&) = delete;
+ void operator=(const ProducerChannel&) = delete;
+};
+
+} // namespace dvr
+} // namespace android
+
+#endif // ANDROID_DVR_BUFFERHUBD_PRODUCER_CHANNEL_H_