Home | History | Annotate | Download | only in libvrflinger 
      1 #include "display_surface.h"
      2 
      3 #include <private/android_filesystem_config.h>
      4 #include <utils/Trace.h>
      5 
      6 #include <private/dvr/trusted_uids.h>
      7 
      8 #include "display_service.h"
      9 #include "hardware_composer.h"
     10 
     11 #define LOCAL_TRACE 1
     12 
     13 using android::dvr::display::DisplayProtocol;
     14 using android::pdx::BorrowedChannelHandle;
     15 using android::pdx::ErrorStatus;
     16 using android::pdx::LocalChannelHandle;
     17 using android::pdx::LocalHandle;
     18 using android::pdx::Message;
     19 using android::pdx::RemoteChannelHandle;
     20 using android::pdx::Status;
     21 using android::pdx::rpc::DispatchRemoteMethod;
     22 using android::pdx::rpc::IfAnyOf;
     23 
     24 namespace android {
     25 namespace dvr {
     26 
     27 DisplaySurface::DisplaySurface(DisplayService* service,
     28                                SurfaceType surface_type, int surface_id,
     29                                int process_id, int user_id,
     30                                const display::SurfaceAttributes& attributes)
     31     : service_(service),
     32       surface_type_(surface_type),
     33       surface_id_(surface_id),
     34       process_id_(process_id),
     35       user_id_(user_id),
     36       attributes_(attributes),
     37       update_flags_(display::SurfaceUpdateFlags::NewSurface) {}
     38 
     39 DisplaySurface::~DisplaySurface() {
     40   ALOGD_IF(LOCAL_TRACE,
     41            "DisplaySurface::~DisplaySurface: surface_id=%d process_id=%d",
     42            surface_id(), process_id());
     43 }
     44 
     45 Status<void> DisplaySurface::HandleMessage(pdx::Message& message) {
     46   switch (message.GetOp()) {
     47     case DisplayProtocol::SetAttributes::Opcode:
     48       DispatchRemoteMethod<DisplayProtocol::SetAttributes>(
     49           *this, &DisplaySurface::OnSetAttributes, message);
     50       break;
     51 
     52     case DisplayProtocol::GetSurfaceInfo::Opcode:
     53       DispatchRemoteMethod<DisplayProtocol::GetSurfaceInfo>(
     54           *this, &DisplaySurface::OnGetSurfaceInfo, message);
     55       break;
     56 
     57     case DisplayProtocol::CreateQueue::Opcode:
     58       DispatchRemoteMethod<DisplayProtocol::CreateQueue>(
     59           *this, &DisplaySurface::OnCreateQueue, message);
     60       break;
     61   }
     62 
     63   return {};
     64 }
     65 
     66 Status<void> DisplaySurface::OnSetAttributes(
     67     pdx::Message& /*message*/, const display::SurfaceAttributes& attributes) {
     68   display::SurfaceUpdateFlags update_flags;
     69 
     70   for (const auto& attribute : attributes) {
     71     const auto& key = attribute.first;
     72     const auto* variant = &attribute.second;
     73     bool invalid_value = false;
     74     bool visibility_changed = false;
     75 
     76     // Catch attributes that have significance to the display service.
     77     switch (key) {
     78       case display::SurfaceAttribute::ZOrder:
     79         invalid_value = !IfAnyOf<int32_t, int64_t, float>::Call(
     80             variant, [&](const auto& value) {
     81               if (z_order_ != value) {
     82                 visibility_changed = true;
     83                 z_order_ = value;
     84               }
     85             });
     86         break;
     87       case display::SurfaceAttribute::Visible:
     88         invalid_value = !IfAnyOf<int32_t, int64_t, bool>::Call(
     89             variant, [&](const auto& value) {
     90               if (visible_ != value) {
     91                 visibility_changed = true;
     92                 visible_ = value;
     93               }
     94             });
     95         break;
     96     }
     97 
     98     if (invalid_value) {
     99       ALOGW(
    100           "DisplaySurface::OnClientSetAttributes: Failed to set display "
    101           "surface attribute '%d' because of incompatible type: %d",
    102           key, variant->index());
    103     } else {
    104       // Only update the attribute map with valid values.
    105       attributes_[attribute.first] = attribute.second;
    106 
    107       // All attribute changes generate a notification, even if the value
    108       // doesn't change. Visibility attributes set a flag only if the value
    109       // changes.
    110       update_flags.Set(display::SurfaceUpdateFlags::AttributesChanged);
    111       if (visibility_changed)
    112         update_flags.Set(display::SurfaceUpdateFlags::VisibilityChanged);
    113     }
    114   }
    115 
    116   SurfaceUpdated(update_flags);
    117   return {};
    118 }
    119 
    120 void DisplaySurface::SurfaceUpdated(display::SurfaceUpdateFlags update_flags) {
    121   ALOGD_IF(TRACE,
    122            "DisplaySurface::SurfaceUpdated: surface_id=%d update_flags=0x%x",
    123            surface_id(), update_flags.value());
    124 
    125   update_flags_.Set(update_flags);
    126   service()->SurfaceUpdated(surface_type(), update_flags_);
    127 }
    128 
    129 void DisplaySurface::ClearUpdate() {
    130   ALOGD_IF(TRACE, "DisplaySurface::ClearUpdate: surface_id=%d", surface_id());
    131   update_flags_ = display::SurfaceUpdateFlags::None;
    132 }
    133 
    134 Status<display::SurfaceInfo> DisplaySurface::OnGetSurfaceInfo(
    135     Message& /*message*/) {
    136   ALOGD_IF(
    137       TRACE,
    138       "DisplaySurface::OnGetSurfaceInfo: surface_id=%d visible=%d z_order=%d",
    139       surface_id(), visible(), z_order());
    140   return {{surface_id(), visible(), z_order()}};
    141 }
    142 
    143 Status<void> DisplaySurface::RegisterQueue(
    144     const std::shared_ptr<ConsumerQueue>& consumer_queue) {
    145   ALOGD_IF(TRACE, "DisplaySurface::RegisterQueue: surface_id=%d queue_id=%d",
    146            surface_id(), consumer_queue->id());
    147   // Capture references for the lambda to work around apparent clang bug.
    148   // TODO(eieio): Figure out if there is a clang bug or C++11 ambiguity when
    149   // capturing self and consumer_queue by copy in the following case:
    150   //    auto self = Self();
    151   //    [self, consumer_queue](int events) {
    152   //        self->OnQueueEvent(consuemr_queue, events); }
    153   //
    154   struct State {
    155     std::shared_ptr<DisplaySurface> surface;
    156     std::shared_ptr<ConsumerQueue> queue;
    157   };
    158   State state{Self(), consumer_queue};
    159 
    160   return service()->AddEventHandler(
    161       consumer_queue->queue_fd(), EPOLLIN | EPOLLHUP | EPOLLET,
    162       [state](int events) {
    163         state.surface->OnQueueEvent(state.queue, events);
    164       });
    165 }
    166 
    167 Status<void> DisplaySurface::UnregisterQueue(
    168     const std::shared_ptr<ConsumerQueue>& consumer_queue) {
    169   ALOGD_IF(TRACE, "DisplaySurface::UnregisterQueue: surface_id=%d queue_id=%d",
    170            surface_id(), consumer_queue->id());
    171   return service()->RemoveEventHandler(consumer_queue->queue_fd());
    172 }
    173 
    174 void DisplaySurface::OnQueueEvent(
    175     const std::shared_ptr<ConsumerQueue>& /*consumer_queue*/, int /*events*/) {
    176   ALOGE(
    177       "DisplaySurface::OnQueueEvent: ERROR base virtual method should not be "
    178       "called!!!");
    179 }
    180 
    181 std::shared_ptr<ConsumerQueue> ApplicationDisplaySurface::GetQueue(
    182     int32_t queue_id) {
    183   ALOGD_IF(TRACE,
    184            "ApplicationDisplaySurface::GetQueue: surface_id=%d queue_id=%d",
    185            surface_id(), queue_id);
    186 
    187   auto search = consumer_queues_.find(queue_id);
    188   if (search != consumer_queues_.end())
    189     return search->second;
    190   else
    191     return nullptr;
    192 }
    193 
    194 std::vector<int32_t> ApplicationDisplaySurface::GetQueueIds() const {
    195   std::vector<int32_t> queue_ids;
    196   for (const auto& entry : consumer_queues_)
    197     queue_ids.push_back(entry.first);
    198   return queue_ids;
    199 }
    200 
    201 Status<LocalChannelHandle> ApplicationDisplaySurface::OnCreateQueue(
    202     Message& /*message*/, size_t meta_size_bytes) {
    203   ATRACE_NAME("ApplicationDisplaySurface::OnCreateQueue");
    204   ALOGD_IF(TRACE,
    205            "ApplicationDisplaySurface::OnCreateQueue: surface_id=%d, "
    206            "meta_size_bytes=%zu",
    207            surface_id(), meta_size_bytes);
    208 
    209   std::lock_guard<std::mutex> autolock(lock_);
    210   auto producer = ProducerQueue::Create(meta_size_bytes);
    211   if (!producer) {
    212     ALOGE(
    213         "ApplicationDisplaySurface::OnCreateQueue: Failed to create producer "
    214         "queue!");
    215     return ErrorStatus(ENOMEM);
    216   }
    217 
    218   std::shared_ptr<ConsumerQueue> consumer =
    219       producer->CreateSilentConsumerQueue();
    220   auto status = RegisterQueue(consumer);
    221   if (!status) {
    222     ALOGE(
    223         "ApplicationDisplaySurface::OnCreateQueue: Failed to register consumer "
    224         "queue: %s",
    225         status.GetErrorMessage().c_str());
    226     return status.error_status();
    227   }
    228 
    229   consumer_queues_[consumer->id()] = std::move(consumer);
    230 
    231   SurfaceUpdated(display::SurfaceUpdateFlags::BuffersChanged);
    232   return std::move(producer->GetChannelHandle());
    233 }
    234 
    235 void ApplicationDisplaySurface::OnQueueEvent(
    236     const std::shared_ptr<ConsumerQueue>& consumer_queue, int events) {
    237   ALOGD_IF(TRACE,
    238            "ApplicationDisplaySurface::OnQueueEvent: queue_id=%d events=%x",
    239            consumer_queue->id(), events);
    240 
    241   // Always give the queue a chance to handle its internal bookkeeping.
    242   consumer_queue->HandleQueueEvents();
    243 
    244   // Check for hangup and remove a queue that is no longer needed.
    245   std::lock_guard<std::mutex> autolock(lock_);
    246   if (consumer_queue->hung_up()) {
    247     ALOGD_IF(TRACE, "ApplicationDisplaySurface::OnQueueEvent: Removing queue.");
    248     UnregisterQueue(consumer_queue);
    249     auto search = consumer_queues_.find(consumer_queue->id());
    250     if (search != consumer_queues_.end()) {
    251       consumer_queues_.erase(search);
    252     } else {
    253       ALOGE(
    254           "ApplicationDisplaySurface::OnQueueEvent: Failed to find queue_id=%d",
    255           consumer_queue->id());
    256     }
    257     SurfaceUpdated(display::SurfaceUpdateFlags::BuffersChanged);
    258   }
    259 }
    260 
    261 Status<LocalChannelHandle> DirectDisplaySurface::OnCreateQueue(
    262     Message& /*message*/, size_t meta_size_bytes) {
    263   ATRACE_NAME("DirectDisplaySurface::OnCreateQueue");
    264   ALOGD_IF(
    265       TRACE,
    266       "DirectDisplaySurface::OnCreateQueue: surface_id=%d meta_size_bytes=%zu",
    267       surface_id(), meta_size_bytes);
    268 
    269   std::lock_guard<std::mutex> autolock(lock_);
    270   if (!direct_queue_) {
    271     auto producer = ProducerQueue::Create(meta_size_bytes);
    272     if (!producer) {
    273       ALOGE(
    274           "DirectDisplaySurface::OnCreateQueue: Failed to create producer "
    275           "queue!");
    276       return ErrorStatus(ENOMEM);
    277     }
    278 
    279     direct_queue_ = producer->CreateConsumerQueue();
    280     auto status = RegisterQueue(direct_queue_);
    281     if (!status) {
    282       ALOGE(
    283           "DirectDisplaySurface::OnCreateQueue: Failed to register consumer "
    284           "queue: %s",
    285           status.GetErrorMessage().c_str());
    286       return status.error_status();
    287     }
    288 
    289     return std::move(producer->GetChannelHandle());
    290   } else {
    291     return ErrorStatus(EALREADY);
    292   }
    293 }
    294 
    295 void DirectDisplaySurface::OnQueueEvent(
    296     const std::shared_ptr<ConsumerQueue>& consumer_queue, int events) {
    297   ALOGD_IF(TRACE, "DirectDisplaySurface::OnQueueEvent: queue_id=%d events=%x",
    298            consumer_queue->id(), events);
    299 
    300   // Always give the queue a chance to handle its internal bookkeeping.
    301   consumer_queue->HandleQueueEvents();
    302 
    303   // Check for hangup and remove a queue that is no longer needed.
    304   std::lock_guard<std::mutex> autolock(lock_);
    305   if (consumer_queue->hung_up()) {
    306     ALOGD_IF(TRACE, "DirectDisplaySurface::OnQueueEvent: Removing queue.");
    307     UnregisterQueue(consumer_queue);
    308     direct_queue_ = nullptr;
    309   }
    310 }
    311 
    312 void DirectDisplaySurface::DequeueBuffersLocked() {
    313   if (direct_queue_ == nullptr) {
    314     ALOGE(
    315         "DirectDisplaySurface::DequeueBuffersLocked: Consumer queue is not "
    316         "initialized.");
    317     return;
    318   }
    319 
    320   while (true) {
    321     LocalHandle acquire_fence;
    322     size_t slot;
    323     auto buffer_status = direct_queue_->Dequeue(0, &slot, &acquire_fence);
    324     if (!buffer_status) {
    325       ALOGD_IF(
    326           TRACE && buffer_status.error() == ETIMEDOUT,
    327           "DirectDisplaySurface::DequeueBuffersLocked: All buffers dequeued.");
    328       ALOGE_IF(buffer_status.error() != ETIMEDOUT,
    329                "DirectDisplaySurface::DequeueBuffersLocked: Failed to dequeue "
    330                "buffer: %s",
    331                buffer_status.GetErrorMessage().c_str());
    332       return;
    333     }
    334     auto buffer_consumer = buffer_status.take();
    335 
    336     if (!visible()) {
    337       ATRACE_NAME("DropFrameOnInvisibleSurface");
    338       ALOGD_IF(TRACE,
    339                "DirectDisplaySurface::DequeueBuffersLocked: Discarding "
    340                "buffer_id=%d on invisible surface.",
    341                buffer_consumer->id());
    342       buffer_consumer->Discard();
    343       continue;
    344     }
    345 
    346     if (acquired_buffers_.IsFull()) {
    347       ALOGE(
    348           "DirectDisplaySurface::DequeueBuffersLocked: Posted buffers full, "
    349           "overwriting.");
    350       acquired_buffers_.PopBack();
    351     }
    352 
    353     acquired_buffers_.Append(
    354         AcquiredBuffer(buffer_consumer, std::move(acquire_fence)));
    355   }
    356 }
    357 
    358 AcquiredBuffer DirectDisplaySurface::AcquireCurrentBuffer() {
    359   std::lock_guard<std::mutex> autolock(lock_);
    360   DequeueBuffersLocked();
    361 
    362   if (acquired_buffers_.IsEmpty()) {
    363     ALOGE(
    364         "DirectDisplaySurface::AcquireCurrentBuffer: attempt to acquire buffer "
    365         "when none are posted.");
    366     return AcquiredBuffer();
    367   }
    368   AcquiredBuffer buffer = std::move(acquired_buffers_.Front());
    369   acquired_buffers_.PopFront();
    370   ALOGD_IF(TRACE, "DirectDisplaySurface::AcquireCurrentBuffer: buffer: %p",
    371            buffer.buffer().get());
    372   return buffer;
    373 }
    374 
    375 AcquiredBuffer DirectDisplaySurface::AcquireNewestAvailableBuffer(
    376     AcquiredBuffer* skipped_buffer) {
    377   std::lock_guard<std::mutex> autolock(lock_);
    378   DequeueBuffersLocked();
    379 
    380   AcquiredBuffer buffer;
    381   int frames = 0;
    382   // Basic latency stopgap for when the application misses a frame:
    383   // If the application recovers on the 2nd or 3rd (etc) frame after
    384   // missing, this code will skip frames to catch up by checking if
    385   // the next frame is also available.
    386   while (!acquired_buffers_.IsEmpty() &&
    387          acquired_buffers_.Front().IsAvailable()) {
    388     // Capture the skipped buffer into the result parameter.
    389     // Note that this API only supports skipping one buffer per vsync.
    390     if (frames > 0 && skipped_buffer)
    391       *skipped_buffer = std::move(buffer);
    392     ++frames;
    393     buffer = std::move(acquired_buffers_.Front());
    394     acquired_buffers_.PopFront();
    395     if (frames == 2)
    396       break;
    397   }
    398   ALOGD_IF(TRACE,
    399            "DirectDisplaySurface::AcquireNewestAvailableBuffer: buffer: %p",
    400            buffer.buffer().get());
    401   return buffer;
    402 }
    403 
    404 bool DirectDisplaySurface::IsBufferAvailable() {
    405   std::lock_guard<std::mutex> autolock(lock_);
    406   DequeueBuffersLocked();
    407 
    408   return !acquired_buffers_.IsEmpty() &&
    409          acquired_buffers_.Front().IsAvailable();
    410 }
    411 
    412 bool DirectDisplaySurface::IsBufferPosted() {
    413   std::lock_guard<std::mutex> autolock(lock_);
    414   DequeueBuffersLocked();
    415 
    416   return !acquired_buffers_.IsEmpty();
    417 }
    418 
    419 Status<std::shared_ptr<DisplaySurface>> DisplaySurface::Create(
    420     DisplayService* service, int surface_id, int process_id, int user_id,
    421     const display::SurfaceAttributes& attributes) {
    422   bool direct = false;
    423   auto search = attributes.find(display::SurfaceAttribute::Direct);
    424   if (search != attributes.end()) {
    425     if (!IfAnyOf<int32_t, int64_t, bool, float>::Get(&search->second,
    426                                                      &direct)) {
    427       ALOGE(
    428           "DisplaySurface::Create: Invalid type for SurfaceAttribute::Direct!");
    429       return ErrorStatus(EINVAL);
    430     }
    431   }
    432 
    433   ALOGD_IF(TRACE,
    434            "DisplaySurface::Create: surface_id=%d process_id=%d user_id=%d "
    435            "direct=%d",
    436            surface_id, process_id, user_id, direct);
    437 
    438   if (direct) {
    439     const bool trusted = user_id == AID_ROOT || IsTrustedUid(user_id);
    440     if (trusted) {
    441       return {std::shared_ptr<DisplaySurface>{new DirectDisplaySurface(
    442           service, surface_id, process_id, user_id, attributes)}};
    443     } else {
    444       ALOGE(
    445           "DisplaySurface::Create: Direct surfaces may only be created by "
    446           "trusted UIDs: user_id=%d",
    447           user_id);
    448       return ErrorStatus(EPERM);
    449     }
    450   } else {
    451     return {std::shared_ptr<DisplaySurface>{new ApplicationDisplaySurface(
    452         service, surface_id, process_id, user_id, attributes)}};
    453   }
    454 }
    455 
    456 }  // namespace dvr
    457 }  // namespace android
    458