GL: Implement EGL_ANDROID_get_frame_timestamps.

BUG=angleproject:2936

Change-Id: I758d797d185b2de330cce3401bfeef76c7df590e
Reviewed-on: https://chromium-review.googlesource.com/c/1302836
Commit-Queue: Geoff Lang <[email protected]>
Reviewed-by: Yuly Novikov <[email protected]>

Author: vonture

scripts/run_code_generation_hashes.json

@@ -84,17 +84,17 @@
   "Vulkan mandatory format support table:src/libANGLE/renderer/vulkan/vk_mandatory_format_support_data.json":
     "fa2bd54c1bb0ab2cf1d386061a4bc5c5",
   "Vulkan mandatory format support table:third_party/vulkan-headers/src/registry/vk.xml":
-    "36d0ec2733888108d2acb56134df6b22",
+    "cd73387d7cdaa5d403eab411194342b3",
   "packed enum:src/common/gen_packed_gl_enums.py":
     "a9b1c38b4e4d8a1038e743be323f1a51",
   "packed enum:src/common/packed_egl_enums.json":
-    "0389a8a565ccee99163bd0cf3ca146d3",
+    "5f591d220ee53b6e54a27d1523a3ab79",
   "packed enum:src/common/packed_gl_enums.json":
     "7338a2a11c679aeb8efe2b415dbd4810",
   "proc table:src/libGLESv2/gen_proc_table.py":
     "027bfd5a8a8dffe91f492bf199029cde",
   "proc table:src/libGLESv2/proc_table_data.json":
-    "9bc7a48223f99e16f11b14ccaeedb09d",
+    "78d7d15862b563adf3fe957672ca1845",
   "uniform type:src/common/gen_uniform_type_table.py":
     "59cb4ffd0f584c4bd37f2f4ff59a2b93"
 }

src/common/PackedEGLEnums_autogen.cpp

@@ -15,6 +15,38 @@
 namespace egl
 {
 
+template <>
+CompositorTiming FromEGLenum<CompositorTiming>(EGLenum from)
+{
+    switch (from)
+    {
+        case EGL_COMPOSITE_DEADLINE_ANDROID:
+            return CompositorTiming::CompositeDeadline;
+        case EGL_COMPOSITE_INTERVAL_ANDROID:
+            return CompositorTiming::CompositInterval;
+        case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
+            return CompositorTiming::CompositToPresentLatency;
+        default:
+            return CompositorTiming::InvalidEnum;
+    }
+}
+
+EGLenum ToEGLenum(CompositorTiming from)
+{
+    switch (from)
+    {
+        case CompositorTiming::CompositeDeadline:
+            return EGL_COMPOSITE_DEADLINE_ANDROID;
+        case CompositorTiming::CompositInterval:
+            return EGL_COMPOSITE_INTERVAL_ANDROID;
+        case CompositorTiming::CompositToPresentLatency:
+            return EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID;
+        default:
+            UNREACHABLE();
+            return 0;
+    }
+}
+
 template <>
 MessageType FromEGLenum<MessageType>(EGLenum from)
 {
@@ -131,4 +163,60 @@ EGLenum ToEGLenum(TextureFormat from)
     }
 }
 
+template <>
+Timestamp FromEGLenum<Timestamp>(EGLenum from)
+{
+    switch (from)
+    {
+        case EGL_REQUESTED_PRESENT_TIME_ANDROID:
+            return Timestamp::RequestedPresentTime;
+        case EGL_RENDERING_COMPLETE_TIME_ANDROID:
+            return Timestamp::RenderingCompleteTime;
+        case EGL_COMPOSITION_LATCH_TIME_ANDROID:
+            return Timestamp::CompositionLatchTime;
+        case EGL_FIRST_COMPOSITION_START_TIME_ANDROID:
+            return Timestamp::FirstCompositionStartTime;
+        case EGL_LAST_COMPOSITION_START_TIME_ANDROID:
+            return Timestamp::LastCompositionStartTime;
+        case EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID:
+            return Timestamp::FirstCompositionGPUFinishedTime;
+        case EGL_DISPLAY_PRESENT_TIME_ANDROID:
+            return Timestamp::DisplayPresentTime;
+        case EGL_DEQUEUE_READY_TIME_ANDROID:
+            return Timestamp::DequeueReadyTime;
+        case EGL_READS_DONE_TIME_ANDROID:
+            return Timestamp::ReadsDoneTime;
+        default:
+            return Timestamp::InvalidEnum;
+    }
+}
+
+EGLenum ToEGLenum(Timestamp from)
+{
+    switch (from)
+    {
+        case Timestamp::RequestedPresentTime:
+            return EGL_REQUESTED_PRESENT_TIME_ANDROID;
+        case Timestamp::RenderingCompleteTime:
+            return EGL_RENDERING_COMPLETE_TIME_ANDROID;
+        case Timestamp::CompositionLatchTime:
+            return EGL_COMPOSITION_LATCH_TIME_ANDROID;
+        case Timestamp::FirstCompositionStartTime:
+            return EGL_FIRST_COMPOSITION_START_TIME_ANDROID;
+        case Timestamp::LastCompositionStartTime:
+            return EGL_LAST_COMPOSITION_START_TIME_ANDROID;
+        case Timestamp::FirstCompositionGPUFinishedTime:
+            return EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID;
+        case Timestamp::DisplayPresentTime:
+            return EGL_DISPLAY_PRESENT_TIME_ANDROID;
+        case Timestamp::DequeueReadyTime:
+            return EGL_DEQUEUE_READY_TIME_ANDROID;
+        case Timestamp::ReadsDoneTime:
+            return EGL_READS_DONE_TIME_ANDROID;
+        default:
+            UNREACHABLE();
+            return 0;
+    }
+}
+
 }  // namespace egl

src/common/PackedEGLEnums_autogen.h

@@ -24,6 +24,20 @@ namespace egl
 template <typename Enum>
 Enum FromEGLenum(EGLenum from);
 
+enum class CompositorTiming : uint8_t
+{
+    CompositeDeadline        = 0,
+    CompositInterval         = 1,
+    CompositToPresentLatency = 2,
+
+    InvalidEnum = 3,
+    EnumCount   = 3,
+};
+
+template <>
+CompositorTiming FromEGLenum<CompositorTiming>(EGLenum from);
+EGLenum ToEGLenum(CompositorTiming from);
+
 enum class MessageType : uint8_t
 {
     Critical = 0,
@@ -71,6 +85,26 @@ template <>
 TextureFormat FromEGLenum<TextureFormat>(EGLenum from);
 EGLenum ToEGLenum(TextureFormat from);
 
+enum class Timestamp : uint8_t
+{
+    RequestedPresentTime            = 0,
+    RenderingCompleteTime           = 1,
+    CompositionLatchTime            = 2,
+    FirstCompositionStartTime       = 3,
+    LastCompositionStartTime        = 4,
+    FirstCompositionGPUFinishedTime = 5,
+    DisplayPresentTime              = 6,
+    DequeueReadyTime                = 7,
+    ReadsDoneTime                   = 8,
+
+    InvalidEnum = 9,
+    EnumCount   = 9,
+};
+
+template <>
+Timestamp FromEGLenum<Timestamp>(EGLenum from);
+EGLenum ToEGLenum(Timestamp from);
+
 }  // namespace egl
 
 #endif  // COMMON_PACKEDEGLENUMS_AUTOGEN_H_

src/common/packed_egl_enums.json

@@ -21,5 +21,23 @@
         "Error": "EGL_DEBUG_MSG_ERROR_KHR",
         "Warn": "EGL_DEBUG_MSG_WARN_KHR",
         "Info": "EGL_DEBUG_MSG_INFO_KHR"
+    },
+    "CompositorTiming":
+    {
+        "CompositeDeadline": "EGL_COMPOSITE_DEADLINE_ANDROID",
+        "CompositInterval": "EGL_COMPOSITE_INTERVAL_ANDROID",
+        "CompositToPresentLatency": "EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID"
+    },
+    "Timestamp":
+    {
+        "RequestedPresentTime": "EGL_REQUESTED_PRESENT_TIME_ANDROID",
+        "RenderingCompleteTime": "EGL_RENDERING_COMPLETE_TIME_ANDROID",
+        "CompositionLatchTime": "EGL_COMPOSITION_LATCH_TIME_ANDROID",
+        "FirstCompositionStartTime": "EGL_FIRST_COMPOSITION_START_TIME_ANDROID",
+        "LastCompositionStartTime": "EGL_LAST_COMPOSITION_START_TIME_ANDROID",
+        "FirstCompositionGPUFinishedTime": "EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID",
+        "DisplayPresentTime": "EGL_DISPLAY_PRESENT_TIME_ANDROID",
+        "DequeueReadyTime": "EGL_DEQUEUE_READY_TIME_ANDROID",
+        "ReadsDoneTime": "EGL_READS_DONE_TIME_ANDROID"
     }
 }

src/libANGLE/Caps.cpp

@@ -1362,7 +1362,8 @@ DisplayExtensions::DisplayExtensions()
       createContextExtensionsEnabled(false),
       presentationTime(false),
       blobCache(false),
-      imageNativeBuffer(false)
+      imageNativeBuffer(false),
+      getFrameTimestamps(false)
 {
 }
 
@@ -1413,6 +1414,7 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_ANDROID_presentation_time",                       presentationTime,                   &extensionStrings);
     InsertExtensionString("EGL_ANDROID_blob_cache",                              blobCache,                          &extensionStrings);
     InsertExtensionString("EGL_ANDROID_image_native_buffer",                     imageNativeBuffer,                  &extensionStrings);
+    InsertExtensionString("EGL_ANDROID_get_frame_timestamps",                    getFrameTimestamps,                 &extensionStrings);
     // TODO(jmadill): Enable this when complete.
     //InsertExtensionString("KHR_create_context_no_error",                       createContextNoError,               &extensionStrings);
     // clang-format on

src/libANGLE/Caps.h

@@ -813,6 +813,9 @@ struct DisplayExtensions
 
     // EGL_ANDROID_image_native_buffer
     bool imageNativeBuffer;
+
+    // EGL_ANDROID_get_frame_timestamps
+    bool getFrameTimestamps;
 };
 
 struct DeviceExtensions

src/libANGLE/Surface.cpp

@@ -26,7 +26,7 @@ namespace egl
 {
 
 SurfaceState::SurfaceState(const egl::Config *configIn, const AttributeMap &attributesIn)
-    : label(nullptr), config(configIn), attributes(attributesIn)
+    : label(nullptr), config(configIn), attributes(attributesIn), timestampsEnabled(false)
 {
 }
 
@@ -169,6 +169,12 @@ Error Surface::initialize(const Display *display)
         }
     }
 
+    if (mType == EGL_WINDOW_BIT && display->getExtensions().getFrameTimestamps)
+    {
+        mState.supportedCompositorTimings = mImplementation->getSupportedCompositorTimings();
+        mState.supportedTimestamps        = mImplementation->getSupportedTimestamps();
+    }
+
     return NoError();
 }
 
@@ -481,6 +487,47 @@ void Surface::setInitState(const gl::ImageIndex & /*imageIndex*/, gl::InitState
     mInitState = initState;
 }
 
+void Surface::setTimestampsEnabled(bool enabled)
+{
+    mImplementation->setTimestampsEnabled(enabled);
+    mState.timestampsEnabled = enabled;
+}
+
+bool Surface::isTimestampsEnabled() const
+{
+    return mState.timestampsEnabled;
+}
+
+const SupportedCompositorTiming &Surface::getSupportedCompositorTimings() const
+{
+    return mState.supportedCompositorTimings;
+}
+
+Error Surface::getCompositorTiming(EGLint numTimestamps,
+                                   const EGLint *names,
+                                   EGLnsecsANDROID *values) const
+{
+    return mImplementation->getCompositorTiming(numTimestamps, names, values);
+}
+
+Error Surface::getNextFrameId(EGLuint64KHR *frameId) const
+{
+    return mImplementation->getNextFrameId(frameId);
+}
+
+const SupportedTimestamps &Surface::getSupportedTimestamps() const
+{
+    return mState.supportedTimestamps;
+}
+
+Error Surface::getFrameTimestamps(EGLuint64KHR frameId,
+                                  EGLint numTimestamps,
+                                  const EGLint *timestamps,
+                                  EGLnsecsANDROID *values) const
+{
+    return mImplementation->getFrameTimestamps(frameId, numTimestamps, timestamps, values);
+}
+
 WindowSurface::WindowSurface(rx::EGLImplFactory *implFactory,
                              const egl::Config *config,
                              EGLNativeWindowType window,

src/libANGLE/Surface.h

@@ -40,13 +40,20 @@ namespace egl
 class Display;
 struct Config;
 
+using SupportedCompositorTiming = angle::PackedEnumBitSet<CompositorTiming>;
+using SupportedTimestamps       = angle::PackedEnumBitSet<Timestamp>;
+
 struct SurfaceState final : private angle::NonCopyable
 {
     SurfaceState(const egl::Config *configIn, const AttributeMap &attributesIn);
 
     EGLLabelKHR label;
     const egl::Config *config;
     AttributeMap attributes;
+
+    bool timestampsEnabled;
+    SupportedCompositorTiming supportedCompositorTimings;
+    SupportedTimestamps supportedTimestamps;
 };
 
 class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
@@ -140,6 +147,22 @@ class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
 
     const gl::Format &getBindTexImageFormat() const { return mColorFormat; }
 
+    // EGL_ANDROID_get_frame_timestamps entry points
+    void setTimestampsEnabled(bool enabled);
+    bool isTimestampsEnabled() const;
+
+    const SupportedCompositorTiming &getSupportedCompositorTimings() const;
+    Error getCompositorTiming(EGLint numTimestamps,
+                              const EGLint *names,
+                              EGLnsecsANDROID *values) const;
+
+    Error getNextFrameId(EGLuint64KHR *frameId) const;
+    const SupportedTimestamps &getSupportedTimestamps() const;
+    Error getFrameTimestamps(EGLuint64KHR frameId,
+                             EGLint numTimestamps,
+                             const EGLint *timestamps,
+                             EGLnsecsANDROID *values) const;
+
   protected:
     Surface(EGLint surfaceType,
             const egl::Config *config,

src/libANGLE/queryutils.cpp

@@ -2988,6 +2988,9 @@ void QuerySurfaceAttrib(const Surface *surface, EGLint attribute, EGLint *value)
         case EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
             *value = surface->isRobustResourceInitEnabled();
             break;
+        case EGL_TIMESTAMPS_ANDROID:
+            *value = surface->isTimestampsEnabled();
+            break;
         default:
             UNREACHABLE();
             break;
@@ -3013,6 +3016,9 @@ void SetSurfaceAttrib(Surface *surface, EGLint attribute, EGLint value)
         case EGL_HEIGHT:
             surface->setFixedHeight(value);
             break;
+        case EGL_TIMESTAMPS_ANDROID:
+            surface->setTimestampsEnabled(value != EGL_FALSE);
+            break;
         default:
             UNREACHABLE();
             break;