Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4af37959 authored by Andrey Tuganov's avatar Andrey Tuganov
Browse files

Merged vr window manager and vr composer 

Vr window manager and vr composer are running in different threads of
the same process, communicating using a simple callback instead of binder
rpc.

Bug: 35101877
Test: Not tested.
Change-Id: I56d3cdfd3d9d60b2f2a25381a240542fd82d658f
parent 33bc71ff

services/vr/vr_window_manager/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -86,6 +86,7 @@ shared_libs := \ 
  libbinder \

  libinput \

  libhardware \

  libhwbinder \

  libsync \

  libutils \

  libgui \

services/vr/vr_window_manager/application.cpp

+2 −2
Original line number Diff line number Diff line
@@ -162,8 +162,8 @@ void Application::ProcessTasks(const std::vector<MainThreadTask>& tasks) { 
        break;

      case MainThreadTask::EnteringVrMode:

        if (!initialized_) {

          if (AllocateResources())

            ALOGE("Failed to allocate resources");

          LOG_ALWAYS_FATAL_IF(AllocateResources(),

                              "Failed to allocate resources");

        }

        break;

      case MainThreadTask::ExitingVrMode:

services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp

+8 −53
Original line number Diff line number Diff line
@@ -3,7 +3,9 @@ 
namespace android {

namespace dvr {



VrComposerView::VrComposerView() : composer_view_(nullptr) {}

VrComposerView::VrComposerView(

    std::unique_ptr<VrComposerView::Callback> callback)

    : composer_view_(nullptr), callback_(std::move(callback)) {}



VrComposerView::~VrComposerView() {

  composer_view_->UnregisterObserver(this);
@@ -14,66 +16,19 @@ void VrComposerView::Initialize(ComposerView* composer_view) { 
  composer_view_->RegisterObserver(this);

}



Return<void> VrComposerView::registerCallback(

    const sp<IVrComposerCallback>& callback) {

  callback_ = callback;

  return Void();

}



Return<void> VrComposerView::releaseFrame() {

void VrComposerView::ReleaseFrame() {

  LOG_ALWAYS_FATAL_IF(!composer_view_, "VrComposerView not initialized");

  composer_view_->ReleaseFrame();

  return Void();

}



void VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {

  std::lock_guard<std::mutex> guard(mutex_);

  if (!callback_.get()) {

    releaseFrame();

    ReleaseFrame();

    return;

  }



  std::vector<IVrComposerCallback::Layer> layers;

  std::vector<native_handle_t*> fences;

  for (size_t i = 0; i < frame.size(); ++i) {

    native_handle_t* fence;

    if (frame[i].fence->isValid()) {

      fence = native_handle_create(1, 0);

      fence->data[0] = frame[i].fence->dup();

    } else {

      fence = native_handle_create(0, 0);

    }

    fences.push_back(fence);



    layers.push_back(IVrComposerCallback::Layer{

      .buffer = hidl_handle(frame[i].buffer->getNativeBuffer()->handle),

      .fence = hidl_handle(fence),

      .display_frame = frame[i].display_frame,

      .crop = frame[i].crop,

      .blend_mode= frame[i].blend_mode,

      .alpha = frame[i].alpha,

      .type = frame[i].type,

      .app_id = frame[i].app_id,

    });

  }



  auto status =

      callback_->onNewFrame(hidl_vec<IVrComposerCallback::Layer>(layers));

  if (!status.isOk()) {

    ALOGE("Failed to send onNewFrame: %s", status.description().c_str());

    releaseFrame();

  }



  for (size_t i = 0; i < fences.size(); ++i) {

    native_handle_close(fences[i]);

    native_handle_delete(fences[i]);

  }

}



VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view) {

  return static_cast<VrComposerView*>(view);

}



IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name) {

  return new VrComposerView();

  callback_->OnNewFrame(frame);

}



}  // namespace dvr

services/vr/vr_window_manager/composer/impl/vr_composer_view.h

+12 −16
Original line number Diff line number Diff line 
#ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_

#define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_



#include <android/dvr/composer/1.0/IVrComposerCallback.h>

#include <android/dvr/composer/1.0/IVrComposerView.h>

#include <memory>



#include "vr_hwc.h"



namespace android {

namespace dvr {



using composer::V1_0::IVrComposerView;

using composer::V1_0::IVrComposerCallback;



class VrComposerView : public IVrComposerView, public ComposerView::Observer {

class VrComposerView : public ComposerView::Observer {

 public:

  class Callback {

   public:

  VrComposerView();

    virtual ~Callback() = default;

    virtual void OnNewFrame(const ComposerView::Frame& frame) = 0;

  };



  VrComposerView(std::unique_ptr<Callback> callback);

  ~VrComposerView() override;



  void Initialize(ComposerView* composer_view);



  // IVrComposerView

  Return<void> registerCallback(const sp<IVrComposerCallback>& callback)

      override;

  Return<void> releaseFrame() override;

  void ReleaseFrame();



  // ComposerView::Observer

  void OnNewFrame(const ComposerView::Frame& frame) override;



 private:

  ComposerView* composer_view_;

  sp<IVrComposerCallback> callback_;

  std::unique_ptr<Callback> callback_;

  std::mutex mutex_;

};



VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view);



IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name);



}  // namespace dvr

}  // namespace android

services/vr/vr_window_manager/hwc_callback.cpp

+4 −16
Original line number Diff line number Diff line
@@ -62,27 +62,18 @@ HwcCallback::FrameStatus GetFrameStatus(const HwcCallback::Frame& frame) { 


}  // namespace



HwcCallback::HwcCallback(IVrComposerView* composer_view, Client* client)

    : composer_view_(composer_view),

      client_(client) {

  composer_view_->registerCallback(this);

HwcCallback::HwcCallback(Client* client) : client_(client) {

}



HwcCallback::~HwcCallback() {

  composer_view_->registerCallback(nullptr);

}



Return<void> HwcCallback::onNewFrame(

    const hidl_vec<IVrComposerCallback::Layer>& frame) {



void HwcCallback::OnNewFrame(const ComposerView::Frame& frame) {

  std::vector<HwcLayer> hwc_frame(frame.size());

  for (size_t i = 0; i < frame.size(); ++i) {

    int fence = frame[i].fence.getNativeHandle()->numFds ?

        dup(frame[i].fence.getNativeHandle()->data[0]) : -1;



    hwc_frame[i] = HwcLayer{

      .fence = new Fence(fence),

      .buffer = GetBufferFromHandle(frame[i].buffer.getNativeHandle()),

      .fence = frame[i].fence,

      .buffer = frame[i].buffer,

      .crop = frame[i].crop,

      .display_frame = frame[i].display_frame,

      .blending = static_cast<int32_t>(frame[i].blend_mode),
@@ -92,10 +83,7 @@ Return<void> HwcCallback::onNewFrame( 
    };

  }



  std::lock_guard<std::mutex> guard(mutex_);

  client_->OnFrame(std::make_unique<Frame>(std::move(hwc_frame)));



  return Void();

}



HwcCallback::Frame::Frame(std::vector<HwcLayer>&& layers)