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

Commit fac40740 authored by Hendrik Wagenaar's avatar Hendrik Wagenaar
Browse files

DO NOT MERGE Remove graphics.cpp and friends 

* Delete a bunch of code that isn't used in the O2 path

Bug: 36776792
Test: Compiled
Change-Id: I4adf6ec5678a53e0850229f9dda60e8687793376
Merged-In: I4adf6ec5678a53e0850229f9dda60e8687793376
parent 31d8ab2e

libs/vr/libdisplay/Android.bp

+2 −36
Original line number Diff line number Diff line
@@ -13,15 +13,9 @@ 
// limitations under the License.



sourceFiles = [

    "native_buffer_queue.cpp",

    "display_client.cpp",

    "display_manager_client.cpp",

    "display_protocol.cpp",

    "dummy_native_window.cpp",

    "frame_history.cpp",

    "gl_fenced_flush.cpp",

    "graphics.cpp",

    "late_latch.cpp",

    "vsync_client.cpp",

]
@@ -34,9 +28,6 @@ sharedLibraries = [ 
    "libcutils",

    "liblog",

    "libutils",

    "libEGL",

    "libGLESv2",

    "libvulkan",

    "libui",

    "libgui",

    "libhardware",
@@ -45,10 +36,9 @@ sharedLibraries = [ 
]



staticLibraries = [

    "libbufferhub",

    "libbufferhubqueue",

    "libdvrcommon",

    "libdvrgraphics",

    "libbufferhubqueue",

    "libbufferhub",

    "libvrsensor",

    "libpdx_default_transport",

]
@@ -74,27 +64,3 @@ cc_library { 


    name: "libdisplay",

}
 


graphicsAppTestFiles = ["tests/graphics_app_tests.cpp"]



cc_test {

    name: "graphics_app_tests",

    tags: ["optional"],



    srcs: graphicsAppTestFiles,



    shared_libs: sharedLibraries,



    static_libs: ["libdisplay"] + staticLibraries,

}



dummyNativeWindowTestFiles = ["tests/dummy_native_window_tests.cpp"]



cc_test {

    name: "dummy_native_window_tests",

    tags: [ "optional" ],

    srcs: dummyNativeWindowTestFiles,

    shared_libs: sharedLibraries,

    static_libs: [ "libdisplay" ] + staticLibraries,

}

libs/vr/libdisplay/display_client.cpp

+0 −1
Original line number Diff line number Diff line
@@ -9,7 +9,6 @@ 
#include <mutex>



#include <private/dvr/display_protocol.h>

#include <private/dvr/late_latch.h>

#include <private/dvr/native_buffer.h>



using android::pdx::ErrorStatus;

libs/vr/libdisplay/dummy_native_window.cpp

deleted100644 → 0
+0 −80
Original line number Diff line number Diff line 
#include "include/private/dvr/dummy_native_window.h"



#include <utils/Errors.h>



namespace {

// Dummy functions required for an ANativeWindow Implementation.

int F1(struct ANativeWindow*, int) { return 0; }

int F2(struct ANativeWindow*, struct ANativeWindowBuffer**) { return 0; }

int F3(struct ANativeWindow*, struct ANativeWindowBuffer*) { return 0; }

int F4(struct ANativeWindow*, struct ANativeWindowBuffer**, int*) { return 0; }

int F5(struct ANativeWindow*, struct ANativeWindowBuffer*, int) { return 0; }

}  // anonymous namespace



namespace android {

namespace dvr {



DummyNativeWindow::DummyNativeWindow() {

  ANativeWindow::setSwapInterval = F1;

  ANativeWindow::dequeueBuffer = F4;

  ANativeWindow::cancelBuffer = F5;

  ANativeWindow::queueBuffer = F5;

  ANativeWindow::query = Query;

  ANativeWindow::perform = Perform;



  ANativeWindow::dequeueBuffer_DEPRECATED = F2;

  ANativeWindow::cancelBuffer_DEPRECATED = F3;

  ANativeWindow::lockBuffer_DEPRECATED = F3;

  ANativeWindow::queueBuffer_DEPRECATED = F3;

}



int DummyNativeWindow::Query(const ANativeWindow*, int what, int* value) {

  switch (what) {

    // This must be 1 in order for eglCreateWindowSurface to not trigger an

    // error

    case NATIVE_WINDOW_IS_VALID:

      *value = 1;

      return NO_ERROR;

    case NATIVE_WINDOW_WIDTH:

    case NATIVE_WINDOW_HEIGHT:

    case NATIVE_WINDOW_FORMAT:

    case NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS:

    case NATIVE_WINDOW_CONCRETE_TYPE:

    case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER:

    case NATIVE_WINDOW_DEFAULT_WIDTH:

    case NATIVE_WINDOW_DEFAULT_HEIGHT:

    case NATIVE_WINDOW_TRANSFORM_HINT:

      *value = 0;

      return NO_ERROR;

  }



  *value = 0;

  return BAD_VALUE;

}



int DummyNativeWindow::Perform(ANativeWindow*, int operation, ...) {

  switch (operation) {

    case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:

    case NATIVE_WINDOW_SET_BUFFERS_FORMAT:

    case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:

    case NATIVE_WINDOW_SET_USAGE:

    case NATIVE_WINDOW_CONNECT:

    case NATIVE_WINDOW_DISCONNECT:

    case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:

    case NATIVE_WINDOW_API_CONNECT:

    case NATIVE_WINDOW_API_DISCONNECT:

    case NATIVE_WINDOW_SET_BUFFER_COUNT:

    case NATIVE_WINDOW_SET_BUFFERS_DATASPACE:

    case NATIVE_WINDOW_SET_SCALING_MODE:

      return NO_ERROR;

    case NATIVE_WINDOW_LOCK:

    case NATIVE_WINDOW_UNLOCK_AND_POST:

    case NATIVE_WINDOW_SET_CROP:

    case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:

      return INVALID_OPERATION;

  }

  return NAME_NOT_FOUND;

}



}  // namespace dvr

}  // namespace android

libs/vr/libdisplay/frame_history.cpp

deleted100644 → 0
+0 −147
Original line number Diff line number Diff line 
#include <private/dvr/frame_history.h>



#include <errno.h>

#include <log/log.h>

#include <sync/sync.h>



#include <pdx/file_handle.h>

#include <private/dvr/clock_ns.h>

#include <private/dvr/sync_util.h>



using android::pdx::LocalHandle;



constexpr int kNumFramesToUseForSchedulePrediction = 10;

constexpr int kDefaultVsyncIntervalPrediction = 1;

constexpr int kMaxVsyncIntervalPrediction = 4;

constexpr int kDefaultPendingFrameBufferSize = 10;



namespace android {

namespace dvr {



FrameHistory::PendingFrame::PendingFrame()

    : start_ns(0), scheduled_vsync(0), scheduled_finish_ns(0) {}



FrameHistory::PendingFrame::PendingFrame(int64_t start_ns,

                                         uint32_t scheduled_vsync,

                                         int64_t scheduled_finish_ns,

                                         LocalHandle&& fence)

    : start_ns(start_ns), scheduled_vsync(scheduled_vsync),

      scheduled_finish_ns(scheduled_finish_ns), fence(std::move(fence)) {}



FrameHistory::FrameHistory() : FrameHistory(kDefaultPendingFrameBufferSize) {}



FrameHistory::FrameHistory(int pending_frame_buffer_size)

    : pending_frames_(pending_frame_buffer_size),

      finished_frames_(pending_frame_buffer_size),

      frame_duration_history_(kNumFramesToUseForSchedulePrediction) {}



void FrameHistory::Reset(int pending_frame_buffer_size) {

  pending_frames_.Reset(pending_frame_buffer_size);

  finished_frames_.Reset(pending_frame_buffer_size);

  frame_duration_history_.Clear();

}



void FrameHistory::OnFrameStart(uint32_t scheduled_vsync,

                                int64_t scheduled_finish_ns) {

  if (!pending_frames_.IsEmpty() && !pending_frames_.Back().fence) {

    // If we don't have a fence set for the previous frame it's because

    // OnFrameStart() was called twice in a row with no OnFrameSubmit() call. In

    // that case throw out the pending frame data for the last frame.

    pending_frames_.PopBack();

  }



  if (pending_frames_.IsFull()) {

    ALOGW("Pending frames buffer is full. Discarding pending frame data.");

  }



  pending_frames_.Append(PendingFrame(GetSystemClockNs(), scheduled_vsync,

                                      scheduled_finish_ns, LocalHandle()));

}



void FrameHistory::OnFrameSubmit(LocalHandle&& fence) {

  // Add the fence to the previous frame data in pending_frames so we can

  // track when it finishes.

  if (!pending_frames_.IsEmpty() && !pending_frames_.Back().fence) {

    if (fence && pending_frames_.Back().scheduled_vsync != UINT32_MAX)

      pending_frames_.Back().fence = std::move(fence);

    else

      pending_frames_.PopBack();

  }

}



void FrameHistory::CheckForFinishedFrames() {

  if (pending_frames_.IsEmpty())

    return;



  android::dvr::FenceInfoBuffer fence_info_buffer;

  while (!pending_frames_.IsEmpty()) {

    const auto& pending_frame = pending_frames_.Front();

    if (!pending_frame.fence) {

      // The frame hasn't been submitted yet, so there's nothing more to do

      break;

    }



    int64_t fence_signaled_time = -1;

    int fence = pending_frame.fence.Get();

    int sync_result = sync_wait(fence, 0);

    if (sync_result == 0) {

      int fence_signaled_result =

          GetFenceSignaledTimestamp(fence, &fence_info_buffer,

                                    &fence_signaled_time);

      if (fence_signaled_result < 0) {

        ALOGE("Failed getting signaled timestamp from fence");

      } else {

        // The frame is finished. Record the duration and move the frame data

        // from pending_frames_ to finished_frames_.

        DvrFrameScheduleResult schedule_result = {};

        schedule_result.vsync_count = pending_frame.scheduled_vsync;

        schedule_result.scheduled_frame_finish_ns =

            pending_frame.scheduled_finish_ns;

        schedule_result.frame_finish_offset_ns =

            fence_signaled_time - pending_frame.scheduled_finish_ns;

        finished_frames_.Append(schedule_result);

        frame_duration_history_.Append(

            fence_signaled_time - pending_frame.start_ns);

      }

      pending_frames_.PopFront();

    } else {

      if (errno != ETIME) {

        ALOGE("sync_wait on frame fence failed. fence=%d errno=%d (%s).",

              fence, errno, strerror(errno));

      }

      break;

    }

  }

}



int FrameHistory::PredictNextFrameVsyncInterval(int64_t vsync_period_ns) const {

  if (frame_duration_history_.IsEmpty())

    return kDefaultVsyncIntervalPrediction;



  double total = 0;

  for (size_t i = 0; i < frame_duration_history_.GetSize(); ++i)

    total += frame_duration_history_.Get(i);

  double avg_duration = total / frame_duration_history_.GetSize();



  return std::min(kMaxVsyncIntervalPrediction,

                  static_cast<int>(avg_duration / vsync_period_ns) + 1);

}



int FrameHistory::GetPreviousFrameResults(DvrFrameScheduleResult* results,

                                          int in_result_count) {

  int out_result_count =

      std::min(in_result_count, static_cast<int>(finished_frames_.GetSize()));

  for (int i = 0; i < out_result_count; ++i) {

    results[i] = finished_frames_.Get(0);

    finished_frames_.PopFront();

  }

  return out_result_count;

}



uint32_t FrameHistory::GetCurrentFrameVsync() const {

  return pending_frames_.IsEmpty() ?

      UINT32_MAX : pending_frames_.Back().scheduled_vsync;

}



}  // namespace dvr

}  // namespace android

libs/vr/libdisplay/gl_fenced_flush.cpp

deleted100644 → 0
+0 −39
Original line number Diff line number Diff line 
#include "include/private/dvr/gl_fenced_flush.h"



#include <EGL/eglext.h>

#include <GLES3/gl31.h>



#define ATRACE_TAG ATRACE_TAG_GRAPHICS

#include <utils/Trace.h>



#include <log/log.h>



using android::pdx::LocalHandle;



namespace android {

namespace dvr {



LocalHandle CreateGLSyncAndFlush(EGLDisplay display) {

  ATRACE_NAME("CreateGLSyncAndFlush");



  EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID,

                      EGL_NO_NATIVE_FENCE_FD_ANDROID, EGL_NONE};

  EGLSyncKHR sync_point =

      eglCreateSyncKHR(display, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);

  glFlush();

  if (sync_point == EGL_NO_SYNC_KHR) {

    ALOGE("sync_point == EGL_NO_SYNC_KHR");

    return LocalHandle();

  }

  EGLint fence_fd = eglDupNativeFenceFDANDROID(display, sync_point);

  eglDestroySyncKHR(display, sync_point);



  if (fence_fd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {

    ALOGE("fence_fd == EGL_NO_NATIVE_FENCE_FD_ANDROID");

    return LocalHandle();

  }

  return LocalHandle(fence_fd);

}



}  // namespace dvr

}  // namespace android