Add support for EGL_ANDROID_presentation_time.

src/libANGLE/Caps.cpp

@@ -1313,7 +1313,8 @@ DisplayExtensions::DisplayExtensions()
       programCacheControl(false),
       robustResourceInitialization(false),
       iosurfaceClientBuffer(false),
-      createContextExtensionsEnabled(false)
+      createContextExtensionsEnabled(false),
+      presentationTime(false)
 {
 }
 
@@ -1360,6 +1361,7 @@ std::vector<std::string> DisplayExtensions::getStrings() const
     InsertExtensionString("EGL_ANGLE_robust_resource_initialization",            robustResourceInitialization,       &extensionStrings);
     InsertExtensionString("EGL_ANGLE_iosurface_client_buffer",                   iosurfaceClientBuffer,              &extensionStrings);
     InsertExtensionString("EGL_ANGLE_create_context_extensions_enabled",         createContextExtensionsEnabled,     &extensionStrings);
+    InsertExtensionString("EGL_ANDROID_presentation_time",                       presentationTime,                   &extensionStrings);
     // TODO(jmadill): Enable this when complete.
     //InsertExtensionString("KHR_create_context_no_error",                       createContextNoError,               &extensionStrings);
     // clang-format on

src/libANGLE/Caps.h

@@ -770,6 +770,9 @@ struct DisplayExtensions
 
     // EGL_ANGLE_create_context_extensions_enabled
     bool createContextExtensionsEnabled;
+
+    // EGL_ANDROID_presentation_time
+    bool presentationTime;
 };
 
 struct DeviceExtensions

src/libANGLE/Surface.cpp

@@ -257,6 +257,11 @@ Error Surface::postSubBuffer(const gl::Context *context,
     return mImplementation->postSubBuffer(context, x, y, width, height);
 }
 
+Error Surface::setPresentationTime(EGLnsecsANDROID time)
+{
+    return mImplementation->setPresentationTime(time);
+}
+
 Error Surface::querySurfacePointerANGLE(EGLint attribute, void **value)
 {
     return mImplementation->querySurfacePointerANGLE(attribute, value);

src/libANGLE/Surface.h

@@ -62,6 +62,7 @@ class Surface : public gl::FramebufferAttachmentObject
                         EGLint y,
                         EGLint width,
                         EGLint height);
+    Error setPresentationTime(EGLnsecsANDROID time);
     Error querySurfacePointerANGLE(EGLint attribute, void **value);
     Error bindTexImage(const gl::Context *context, gl::Texture *texture, EGLint buffer);
     Error releaseTexImage(const gl::Context *context, EGLint buffer);

src/libANGLE/renderer/SurfaceImpl.cpp

@@ -25,4 +25,10 @@ egl::Error SurfaceImpl::swapWithDamage(const gl::Context *context, EGLint *rects
     return egl::EglBadSurface() << "swapWithDamage implementation missing.";
 }
 
+egl::Error SurfaceImpl::setPresentationTime(EGLnsecsANDROID time)
+{
+    UNREACHABLE();
+    return egl::EglBadSurface() << "setPresentationTime implementation missing.";
+}
+
 }  // namespace rx

src/libANGLE/renderer/SurfaceImpl.h

@@ -55,6 +55,7 @@ class SurfaceImpl : public FramebufferAttachmentObjectImpl
                                      EGLint y,
                                      EGLint width,
                                      EGLint height) = 0;
+    virtual egl::Error setPresentationTime(EGLnsecsANDROID time);
     virtual egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) = 0;
     virtual egl::Error bindTexImage(const gl::Context *context,
                                     gl::Texture *texture,

src/libANGLE/renderer/gl/egl/DisplayEGL.cpp

@@ -105,6 +105,7 @@ void DisplayEGL::generateExtensions(egl::DisplayExtensions *outExtensions) const
 
     outExtensions->postSubBuffer = false;  // Since SurfaceEGL::postSubBuffer is not implemented
     outExtensions->swapBuffersWithDamage = mEGL->hasExtension("EGL_KHR_swap_buffers_with_damage");
+    outExtensions->presentationTime      = mEGL->hasExtension("EGL_ANDROID_presentation_time");
 
     // Contexts are virtualized so textures can be shared globally
     outExtensions->displayTextureShareGroup = true;

src/libANGLE/renderer/gl/egl/FunctionsEGL.cpp

@@ -64,7 +64,9 @@ struct FunctionsEGL::EGLDispatchTable
           destroySyncKHRPtr(nullptr),
           getSyncAttribKHRPtr(nullptr),
 
-          swapBuffersWithDamageKHRPtr(nullptr)
+          swapBuffersWithDamageKHRPtr(nullptr),
+
+          presentationTimeANDROIDPtr(nullptr)
     {
     }
 
@@ -103,6 +105,9 @@ struct FunctionsEGL::EGLDispatchTable
 
     // EGL_KHR_swap_buffers_with_damage
     PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC swapBuffersWithDamageKHRPtr;
+
+    // EGL_ANDROID_presentation_time
+    PFNEGLPRESENTATIONTIMEANDROIDPROC presentationTimeANDROIDPtr;
 };
 
 FunctionsEGL::FunctionsEGL()
@@ -187,6 +192,11 @@ egl::Error FunctionsEGL::initialize(EGLNativeDisplayType nativeDisplay)
         ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->swapBuffersWithDamageKHRPtr, eglSwapBuffersWithDamageKHR);
     }
 
+    if (hasExtension("EGL_ANDROID_presentation_time"))
+    {
+        ANGLE_GET_PROC_OR_ERROR(&mFnPtrs->presentationTimeANDROIDPtr, eglPresentationTimeANDROID);
+    }
+
 #undef ANGLE_GET_PROC_OR_ERROR
 
     return egl::NoError();
@@ -354,4 +364,9 @@ EGLBoolean FunctionsEGL::swapBuffersWithDamageKHR(EGLSurface surface,
 {
     return mFnPtrs->swapBuffersWithDamageKHRPtr(mEGLDisplay, surface, rects, n_rects);
 }
+
+EGLBoolean FunctionsEGL::presentationTimeANDROID(EGLSurface surface, EGLnsecsANDROID time) const
+{
+    return mFnPtrs->presentationTimeANDROIDPtr(mEGLDisplay, surface, time);
+}
 }  // namespace rx

src/libANGLE/renderer/gl/egl/FunctionsEGL.h

@@ -77,6 +77,8 @@ class FunctionsEGL
 
     EGLBoolean swapBuffersWithDamageKHR(EGLSurface surface, EGLint *rects, EGLint n_rects) const;
 
+    EGLBoolean presentationTimeANDROID(EGLSurface surface, EGLnsecsANDROID time) const;
+
   private:
     // So as to isolate from angle we do not include angleutils.h and cannot
     // use angle::NonCopyable so we replicated it here instead.

src/libANGLE/renderer/gl/egl/SurfaceEGL.cpp

@@ -63,6 +63,16 @@ egl::Error SurfaceEGL::postSubBuffer(const gl::Context *context,
     return egl::EglBadSurface();
 }
 
+egl::Error SurfaceEGL::setPresentationTime(EGLnsecsANDROID time)
+{
+    EGLBoolean success = mEGL->presentationTimeANDROID(mSurface, time);
+    if (success == EGL_FALSE)
+    {
+        return egl::Error(mEGL->getError(), "eglPresentationTimeANDROID failed");
+    }
+    return egl::NoError();
+}
+
 egl::Error SurfaceEGL::querySurfacePointerANGLE(EGLint attribute, void **value)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/gl/egl/SurfaceEGL.h

@@ -31,6 +31,7 @@ class SurfaceEGL : public SurfaceGL
                              EGLint y,
                              EGLint width,
                              EGLint height) override;
+    egl::Error setPresentationTime(EGLnsecsANDROID time) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
     egl::Error bindTexImage(const gl::Context *context,
                             gl::Texture *texture,

src/libANGLE/validationEGL.cpp

@@ -2293,6 +2293,24 @@ Error ValidateSwapBuffersWithDamageKHR(const Display *display,
     return NoError();
 }
 
+Error ValidatePresentationTimeANDROID(const Display *display,
+                                      const Surface *surface,
+                                      EGLnsecsANDROID time)
+{
+    ANGLE_TRY(ValidateDisplay(display));
+
+    if (!display->getExtensions().presentationTime)
+    {
+        // It is out of spec what happens when calling an extension function when the extension is
+        // not available. EGL_BAD_DISPLAY seems like a reasonable error.
+        return EglBadDisplay() << "EGL_ANDROID_presentation_time is not available.";
+    }
+
+    ANGLE_TRY(ValidateSurface(display, surface));
+
+    return NoError();
+}
+
 Error ValidateGetConfigAttrib(const Display *display, const Config *config, EGLint attribute)
 {
     ANGLE_TRY(ValidateConfig(display, config));

src/libANGLE/validationEGL.h

@@ -109,6 +109,10 @@ Error ValidateSwapBuffersWithDamageKHR(const Display *display,
                                        EGLint *rects,
                                        EGLint n_rects);
 
+Error ValidatePresentationTimeANDROID(const Display *display,
+                                      const Surface *surface,
+                                      EGLnsecsANDROID time);
+
 Error ValidateGetConfigAttrib(const Display *display, const Config *config, EGLint attribute);
 Error ValidateChooseConfig(const Display *display,
                            const AttributeMap &attribs,

src/libEGL/libEGL.cpp

@@ -392,6 +392,13 @@ EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageKHR(EGLDisplay dpy,
     return egl::SwapBuffersWithDamageKHR(dpy, surface, rects, n_rects);
 }
 
+EGLBoolean EGLAPIENTRY eglPresentationTimeANDROID(EGLDisplay dpy,
+                                                  EGLSurface surface,
+                                                  EGLnsecsANDROID time)
+{
+    return egl::PresentationTimeANDROID(dpy, surface, time);
+}
+
 EGLint EGLAPIENTRY eglProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)
 {
     return egl::ProgramCacheGetAttribANGLE(dpy, attrib);

src/libEGL/libEGL.def

@@ -65,6 +65,7 @@ EXPORTS
     eglProgramCacheResizeANGLE                  @71
     eglCreatePlatformWindowSurfaceEXT           @72
     eglCreatePlatformPixmapSurfaceEXT           @73
+    eglPresentationTimeANDROID                  @74
 
     ; 1.5 entry points
     eglCreateSync                               @38

src/libGLESv2/entry_points_egl_ext.cpp

@@ -833,6 +833,24 @@ EGLBoolean EGLAPIENTRY SwapBuffersWithDamageKHR(EGLDisplay dpy,
     return EGL_TRUE;
 }
 
+EGLBoolean EGLAPIENTRY PresentationTimeANDROID(EGLDisplay dpy,
+                                               EGLSurface surface,
+                                               EGLnsecsANDROID time)
+{
+    EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLnsecsANDROID time = %d)",
+          dpy, surface, time);
+    Thread *thread = GetCurrentThread();
+
+    Display *display    = static_cast<Display *>(dpy);
+    Surface *eglSurface = static_cast<Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidatePresentationTimeANDROID(display, eglSurface, time),
+                         EGL_FALSE);
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->setPresentationTime(time), EGL_FALSE);
+
+    return EGL_TRUE;
+}
+
 EGLint EGLAPIENTRY ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)
 {
     EVENT("(EGLDisplay dpy = 0x%0.8p, EGLenum attrib = 0x%X)", dpy, attrib);

src/libGLESv2/entry_points_egl_ext.h

@@ -101,6 +101,11 @@ ANGLE_EXPORT EGLBoolean EGLAPIENTRY SwapBuffersWithDamageKHR(EGLDisplay dpy,
                                                              EGLint *rects,
                                                              EGLint n_rects);
 
+// EGL_ANDROID_presentation_time
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY PresentationTimeANDROID(EGLDisplay dpy,
+                                                            EGLSurface surface,
+                                                            EGLnsecsANDROID time);
+
 //
 ANGLE_EXPORT EGLint EGLAPIENTRY ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib);
 ANGLE_EXPORT void EGLAPIENTRY ProgramCacheQueryANGLE(EGLDisplay dpy,

src/libGLESv2/proc_table_autogen.cpp

@@ -68,6 +68,7 @@ ProcEntry g_procTable[] = {
     {"eglInitialize", P(egl::Initialize)},
     {"eglMakeCurrent", P(egl::MakeCurrent)},
     {"eglPostSubBufferNV", P(egl::PostSubBufferNV)},
+    {"eglPresentationTimeANDROID", P(egl::PresentationTimeANDROID)},
     {"eglProgramCacheGetAttribANGLE", P(egl::ProgramCacheGetAttribANGLE)},
     {"eglProgramCachePopulateANGLE", P(egl::ProgramCachePopulateANGLE)},
     {"eglProgramCacheQueryANGLE", P(egl::ProgramCacheQueryANGLE)},
@@ -1233,5 +1234,5 @@ ProcEntry g_procTable[] = {
     {"glWeightPointerOES", P(gl::WeightPointerOES)},
     {"glWeightPointerOESContextANGLE", P(gl::WeightPointerOESContextANGLE)}};
 
-size_t g_numProcs = 1165;
+size_t g_numProcs = 1166;
 }  // namespace egl

src/libGLESv2/proc_table_data.json

@@ -828,6 +828,10 @@
         "eglSwapBuffersWithDamageKHR"
     ],
 
+    "EGL_ANDROID_presentation_time": [
+        "eglPresentationTimeANDROID"
+    ],
+
     "EGL_ANGLE_program_cache_control": [
         "eglProgramCacheGetAttribANGLE",
         "eglProgramCacheQueryANGLE",