Home | History | Annotate | Download | only in dvr 
      1 #ifndef ANDROID_DVR_BUFFERHUBD_BUFFER_HUB_H_
      2 #define ANDROID_DVR_BUFFERHUBD_BUFFER_HUB_H_
      3 
      4 #include <memory>
      5 #include <string>
      6 #include <unordered_map>
      7 
      8 #include <hardware/gralloc.h>
      9 #include <pdx/service.h>
     10 #include <private/dvr/bufferhub_rpc.h>
     11 
     12 namespace android {
     13 namespace dvr {
     14 
     15 class BufferHubService;
     16 class ConsumerChannel;
     17 class ProducerChannel;
     18 class ConsumerQueueChannel;
     19 class ProducerQueueChannel;
     20 
     21 class BufferHubChannel : public pdx::Channel {
     22  public:
     23   enum ChannelType {
     24     kProducerType,
     25     kConsumerType,
     26     kDetachedBufferType,
     27     kProducerQueueType,
     28     kConsumerQueueType,
     29   };
     30 
     31   BufferHubChannel(BufferHubService* service, int buffer_id, int channel_id,
     32                    ChannelType channel_type)
     33       : service_(service),
     34         buffer_id_(buffer_id),
     35         channel_id_(channel_id),
     36         channel_type_(channel_type) {}
     37   virtual ~BufferHubChannel() {}
     38 
     39   virtual bool HandleMessage(pdx::Message& message) = 0;
     40   virtual void HandleImpulse(pdx::Message& message) = 0;
     41 
     42   // Captures buffer info for use by BufferHubService::DumpState().
     43   struct BufferInfo {
     44     // Common data field shared by ProducerBuffer and ProducerQueue.
     45     int id = -1;
     46     int type = -1;
     47     size_t consumer_count = 0;
     48 
     49     // Data field for producer buffer.
     50     uint32_t width = 0;
     51     uint32_t height = 0;
     52     uint32_t layer_count = 0;
     53     uint32_t format = 0;
     54     uint64_t usage = 0;
     55     uint64_t state = 0;
     56     uint64_t signaled_mask = 0;
     57     uint64_t index = 0;
     58 
     59     // Data filed for producer queue.
     60     size_t capacity = 0;
     61     UsagePolicy usage_policy{0, 0, 0, 0};
     62 
     63     BufferInfo(int id, size_t consumer_count, uint32_t width, uint32_t height,
     64                uint32_t layer_count, uint32_t format, uint64_t usage,
     65                uint64_t state, uint64_t signaled_mask, uint64_t index)
     66         : id(id),
     67           type(kProducerType),
     68           consumer_count(consumer_count),
     69           width(width),
     70           height(height),
     71           layer_count(layer_count),
     72           format(format),
     73           usage(usage),
     74           state(state),
     75           signaled_mask(signaled_mask),
     76           index(index) {}
     77 
     78     BufferInfo(int id, size_t consumer_count, size_t capacity,
     79                const UsagePolicy& usage_policy)
     80         : id(id),
     81           type(kProducerQueueType),
     82           consumer_count(consumer_count),
     83           capacity(capacity),
     84           usage_policy(usage_policy) {}
     85 
     86     BufferInfo() {}
     87   };
     88 
     89   // Returns the buffer info for this buffer.
     90   virtual BufferInfo GetBufferInfo() const = 0;
     91 
     92   // Signal the client fd that an ownership change occurred using POLLIN.
     93   void SignalAvailable();
     94 
     95   // Clear the ownership change event.
     96   void ClearAvailable();
     97 
     98   // Signal hangup event.
     99   void Hangup();
    100 
    101   BufferHubService* service() const { return service_; }
    102   ChannelType channel_type() const { return channel_type_; }
    103   int buffer_id() const { return buffer_id_; }
    104 
    105   int channel_id() const { return channel_id_; }
    106 
    107   bool signaled() const { return signaled_; }
    108 
    109  private:
    110   BufferHubService* service_;
    111 
    112   // Static id of the buffer for logging and informational purposes. This id
    113   // does not change for the life of the buffer.
    114   // TODO(eieio): Consider using an id allocator instead of the originating
    115   // channel id; channel ids wrap after 2^31 ids, but this is not a problem in
    116   // general because channel ids are not used for any lookup in this service.
    117   int buffer_id_;
    118 
    119   // The channel id of the buffer.
    120   int channel_id_;
    121 
    122   bool signaled_;
    123 
    124   ChannelType channel_type_;
    125 
    126   BufferHubChannel(const BufferHubChannel&) = delete;
    127   void operator=(const BufferHubChannel&) = delete;
    128 };
    129 
    130 class BufferHubService : public pdx::ServiceBase<BufferHubService> {
    131  public:
    132   BufferHubService();
    133   ~BufferHubService() override;
    134 
    135   pdx::Status<void> HandleMessage(pdx::Message& message) override;
    136   void HandleImpulse(pdx::Message& message) override;
    137 
    138   bool IsInitialized() const override;
    139   std::string DumpState(size_t max_length) override;
    140 
    141  private:
    142   friend BASE;
    143 
    144   pdx::Status<void> OnCreateBuffer(pdx::Message& message, uint32_t width,
    145                                    uint32_t height, uint32_t format,
    146                                    uint64_t usage, size_t meta_size_bytes);
    147   pdx::Status<QueueInfo> OnCreateProducerQueue(
    148       pdx::Message& message, const ProducerQueueConfig& producer_config,
    149       const UsagePolicy& usage_policy);
    150 
    151   BufferHubService(const BufferHubService&) = delete;
    152   void operator=(const BufferHubService&) = delete;
    153 };
    154 
    155 }  // namespace dvr
    156 }  // namespace android
    157 
    158 #endif  // ANDROID_DVR_BUFFERHUBD_BUFFER_HUB_H_
    159