1#ifndef ANDROID_DVR_SERVICES_DISPLAYD_DISPLAY_SURFACE_H_
2#define ANDROID_DVR_SERVICES_DISPLAYD_DISPLAY_SURFACE_H_
3
4#include <pdx/file_handle.h>
5#include <pdx/service.h>
6#include <private/dvr/buffer_hub_queue_client.h>
7#include <private/dvr/display_protocol.h>
8#include <private/dvr/ring_buffer.h>
9
10#include <functional>
11#include <iterator>
12#include <memory>
13#include <string>
14#include <vector>
15
16#include "acquired_buffer.h"
17
18namespace android {
19namespace dvr {
20
21class DisplayService;
22
23enum class SurfaceType {
24  Direct,
25  Application,
26};
27
28class DisplaySurface : public pdx::Channel {
29 public:
30  static pdx::Status<std::shared_ptr<DisplaySurface>> Create(
31      DisplayService* service, int surface_id, int process_id, int user_id,
32      const display::SurfaceAttributes& attributes);
33
34  ~DisplaySurface() override;
35
36  DisplayService* service() const { return service_; }
37  SurfaceType surface_type() const { return surface_type_; }
38  int surface_id() const { return surface_id_; }
39  int process_id() const { return process_id_; }
40  int user_id() const { return user_id_; }
41
42  bool visible() const { return visible_; }
43  int z_order() const { return z_order_; }
44
45  const display::SurfaceAttributes& attributes() const { return attributes_; }
46  display::SurfaceUpdateFlags update_flags() const { return update_flags_; }
47
48  virtual std::vector<int32_t> GetQueueIds() const { return {}; }
49
50  bool IsUpdatePending() const {
51    return update_flags_.value() != display::SurfaceUpdateFlags::None;
52  }
53
54 protected:
55  DisplaySurface(DisplayService* service, SurfaceType surface_type,
56                 int surface_id, int process_id, int user_id);
57
58  // Utility to retrieve a shared pointer to this channel as the desired derived
59  // type.
60  template <
61      typename T = DisplaySurface,
62      typename = std::enable_if_t<std::is_base_of<DisplaySurface, T>::value>>
63  std::shared_ptr<T> Self() {
64    return std::static_pointer_cast<T>(shared_from_this());
65  }
66
67  virtual pdx::Status<pdx::LocalChannelHandle> OnCreateQueue(
68      pdx::Message& message, const ProducerQueueConfig& config) = 0;
69
70  // Registers a consumer queue with the event dispatcher in DisplayService. The
71  // OnQueueEvent callback below is called to handle queue events.
72  pdx::Status<void> RegisterQueue(
73      const std::shared_ptr<ConsumerQueue>& consumer_queue);
74  pdx::Status<void> UnregisterQueue(
75      const std::shared_ptr<ConsumerQueue>& consumer_queue);
76
77  // Called by the event dispatcher in DisplayService when a registered queue
78  // event triggers. Executes on the event dispatcher thread.
79  virtual void OnQueueEvent(
80      const std::shared_ptr<ConsumerQueue>& consumer_queue, int events);
81
82  void SurfaceUpdated(display::SurfaceUpdateFlags update_flags);
83  void ClearUpdate();
84
85  // Synchronizes access to mutable state below between message dispatch thread
86  // and frame post thread.
87  mutable std::mutex lock_;
88
89 private:
90  friend class DisplayService;
91  friend class DisplayManagerService;
92
93  // Dispatches display surface messages to the appropriate handlers. This
94  // handler runs on the VrFlinger message dispatch thread.
95  pdx::Status<void> HandleMessage(pdx::Message& message);
96
97  pdx::Status<void> OnSetAttributes(
98      pdx::Message& message, const display::SurfaceAttributes& attributes);
99  pdx::Status<display::SurfaceInfo> OnGetSurfaceInfo(pdx::Message& message);
100
101  DisplayService* service_;
102  SurfaceType surface_type_;
103  int surface_id_;
104  int process_id_;
105  int user_id_;
106
107  display::SurfaceAttributes attributes_;
108  display::SurfaceUpdateFlags update_flags_ = display::SurfaceUpdateFlags::None;
109
110  // Subset of attributes that may be interpreted by the display service.
111  bool visible_ = false;
112  int z_order_ = 0;
113
114  DisplaySurface(const DisplaySurface&) = delete;
115  void operator=(const DisplaySurface&) = delete;
116};
117
118class ApplicationDisplaySurface : public DisplaySurface {
119 public:
120  ApplicationDisplaySurface(DisplayService* service, int surface_id,
121                            int process_id, int user_id)
122      : DisplaySurface(service, SurfaceType::Application, surface_id,
123                       process_id, user_id) {}
124
125  std::shared_ptr<ConsumerQueue> GetQueue(int32_t queue_id);
126  std::vector<int32_t> GetQueueIds() const override;
127
128 private:
129  pdx::Status<pdx::LocalChannelHandle> OnCreateQueue(
130      pdx::Message& message, const ProducerQueueConfig& config) override;
131  void OnQueueEvent(const std::shared_ptr<ConsumerQueue>& consumer_queue,
132                    int events) override;
133
134  // Accessed by both message dispatch thread and epoll event thread.
135  std::unordered_map<int32_t, std::shared_ptr<ConsumerQueue>> consumer_queues_;
136};
137
138class DirectDisplaySurface : public DisplaySurface {
139 public:
140  DirectDisplaySurface(DisplayService* service, int surface_id, int process_id,
141                       int user_id)
142      : DisplaySurface(service, SurfaceType::Direct, surface_id, process_id,
143                       user_id),
144        acquired_buffers_(kMaxPostedBuffers),
145        metadata_(nullptr) {}
146  std::vector<int32_t> GetQueueIds() const override;
147  bool IsBufferAvailable();
148  bool IsBufferPosted();
149  AcquiredBuffer AcquireCurrentBuffer();
150
151  // Get the newest buffer. Up to one buffer will be skipped. If a buffer is
152  // skipped, it will be stored in skipped_buffer if non null.
153  AcquiredBuffer AcquireNewestAvailableBuffer(AcquiredBuffer* skipped_buffer);
154
155 private:
156  pdx::Status<pdx::LocalChannelHandle> OnCreateQueue(
157      pdx::Message& message, const ProducerQueueConfig& config) override;
158  void OnQueueEvent(const std::shared_ptr<ConsumerQueue>& consumer_queue,
159                    int events) override;
160
161  // The capacity of the pending buffer queue. Should be enough to hold all the
162  // buffers of this DisplaySurface, although in practice only 1 or 2 frames
163  // will be pending at a time.
164  static constexpr int kSurfaceBufferMaxCount = 4;
165  static constexpr int kSurfaceViewMaxCount = 4;
166  static constexpr int kMaxPostedBuffers =
167      kSurfaceBufferMaxCount * kSurfaceViewMaxCount;
168
169  // Returns whether a frame is available without locking the mutex.
170  bool IsFrameAvailableNoLock() const;
171
172  // Dequeue all available buffers from the consumer queue.
173  void DequeueBuffersLocked();
174
175  // In a triple-buffered surface, up to kMaxPostedBuffers buffers may be
176  // posted and pending.
177  RingBuffer<AcquiredBuffer> acquired_buffers_;
178
179  std::shared_ptr<ConsumerQueue> direct_queue_;
180
181  // Stores metadata when it dequeue buffers from consumer queue.
182  std::unique_ptr<uint8_t[]> metadata_;
183};
184
185}  // namespace dvr
186}  // namespace android
187
188#endif  // ANDROID_DVR_SERVICES_DISPLAYD_DISPLAY_SURFACE_H_
189