2014-12-09  Philippe Normand  <pnormand@igalia.com>

        [GStreamer] GstGL support in the video sink

        https://bugs.webkit.org/show_bug.cgi?id=138562

        Reviewed by NOBODY (OOPS!).

        * Source/cmake/FindGStreamer.cmake: Lookup the GstGL library and headers.

        * Source/cmake/OptionsGTK.cmake: Turn on the USE(GSTREAMER_GL)

        macro if GstGL was found.

2014-12-09  Philippe Normand  <pnormand@igalia.com>

        [GStreamer] GstGL support in the video sink

        https://bugs.webkit.org/show_bug.cgi?id=138562

        Reviewed by NOBODY (OOPS!).

        If a recent enough (>= 1.5) GStreamer version is available then

        the video sink will use the GstGL library to embed a GL texture in

        each GstBuffer to be rendered via the TextureMapper. In this

        scenario a GPU-GPU texture copy will be performed. For this to be

        possible the GL context used within WebKit needs to be shared with

        the GL context used by GstGL. For now we support only the GLX/X11

        sharing context.

        No new tests, existing media tests will cover this change once the

        buildbots have GStreamer >= 1.5.

        * PlatformGTK.cmake: Use GstGL library for the build.

        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:

        (WebCore::MediaPlayerPrivateGStreamerBase::updateTexture): Do a

        GPU-GPU texture if the buffer already has a GL texture available.

        * platform/graphics/gstreamer/VideoSinkGStreamer.cpp:

        (_WebKitVideoSinkPrivate::_WebKitVideoSinkPrivate): Use a mutex

        and condition so as to get the WebKit GL context from the main thread.

        (_WebKitVideoSinkPrivate::~_WebKitVideoSinkPrivate):

        (wrapGLContextCallback): Wrap the WebKit GL context in a GstGL context.

        (webkitVideoSinkStop): Free buffer pool and pre-allocated buffer.

        (webkitVideoSinkSetCaps): Create the GstGLUpload that will take

        care of updating the buffer's texture and update caps accordingly.

        (webkitVideoSinkPrepare): Update the buffer's texture before rendering.

        (webkitVideoSinkProposeAllocation): Prepare a buffer pool, set the

        GL context up and update the meta informations supported by the sink.

        (webkitVideoSinkSetContext): Pass-through the context to GstGL.

        (webkitVideoSinkQuery): Basic support for context queries.

        (webkit_video_sink_class_init):

    if (USE_GSTREAMER_GL)

        list(APPEND WebCore_INCLUDE_DIRECTORIES

            ${GSTREAMER_GL_INCLUDE_DIRS}

        )

        list(APPEND WebCore_LIBRARIES

            ${GSTREAMER_GL_LIBRARIES}

        )

    endif ()

#if USE(GSTREAMER_GL)

#define GST_USE_UNSTABLE_API

#include <gst/gl/gstglmemory.h>

#undef GST_USE_UNSTABLE_API

#endif

    const BitmapTextureGL* textureGL = static_cast<const BitmapTextureGL*>(texture.get());

    uint32_t textureID = textureGL->id();

#if USE(GSTREAMER_GL)

    GstMemory* bufferMemory;

    if (gst_buffer_n_memory(buffer) >= 1) {

        if ((bufferMemory = gst_buffer_peek_memory(buffer, 0)) && gst_is_gl_memory(bufferMemory)) {

            GstGLMemory* glMemory = reinterpret_cast<GstGLMemory*>(bufferMemory);

            GstVideoGLTextureType textureType = gst_gl_texture_type_from_format(glMemory->context, GST_VIDEO_INFO_FORMAT(&videoInfo), 0);

            GstMapInfo mapInfo;

            if (!gst_memory_map(bufferMemory, &mapInfo, static_cast<GstMapFlags>(GST_MAP_READ | GST_MAP_GL))) {

                gst_gl_context_set_error(glMemory->context, "Failed to map intermediate memory");

                return nullptr;

            }

            gboolean copied = gst_gl_memory_copy_into_texture(glMemory, textureID, textureType, size.width(), size.height(), GST_VIDEO_INFO_PLANE_STRIDE(&videoInfo, 0), true /* respecify */);

            gst_memory_unmap(bufferMemory, &mapInfo);

            if (copied)

                return texture;

            WARN_MEDIA_MESSAGE("Texture copy failed, trying fallback slow path.");

        }

    }

#endif

#include <gst/video/gstvideopool.h>

#include <wtf/gobject/GUniquePtr.h>

#if USE(GSTREAMER_GL)

#define GST_USE_UNSTABLE_API

#include <gst/gl/gstglcontext.h>

#include <gst/gl/gstgldisplay.h>

#undef GST_USE_UNSTABLE_API

#if GST_GL_HAVE_PLATFORM_EGL

#include <gst/gl/egl/gsteglimagememory.h>

#endif

#include <gst/gl/gstglutils.h>

#if PLATFORM(X11)

#include <gst/gl/x11/gstgldisplay_x11.h>

#endif

#include "GLContext.h"

#if USE(GLX)

#include "GLContextGLX.h"

#endif

#endif // USE(GSTREAMER_GL)

#if USE(GSTREAMER_GL)

        g_mutex_init(&contextMutex);

        g_cond_init(&contextCondition);

#endif

#if USE(GSTREAMER_GL)

        g_mutex_clear(&contextMutex);

        g_cond_clear(&contextCondition);

#endif

#if USE(GSTREAMER_GL)

    GstCaps* glCaps;

    GstBufferPool* pool;

    GstGLDisplay* display;

    GstGLContext* context;

    GstGLContext* otherContext;

    GMutex contextMutex;

    GCond contextCondition;

    GstGLUpload* upload;

    GstBuffer* nextBuffer;

#endif

#if USE(GSTREAMER_GL)

gboolean wrapGLContextCallback(gpointer userData)

{

    WebKitVideoSink* sink = reinterpret_cast<WebKitVideoSink*>(userData);

    WebKitVideoSinkPrivate* priv = sink->priv;

    GMutexLocker<GMutex> lock(priv->contextMutex);

    GError* error = nullptr;

    if (!priv->display)

        priv->display = gst_gl_display_new();

    if (!priv->otherContext) {

        GLContext* webkitContext = GLContext::sharingContext();

#if PLATFORM(X11)

        Display* display = GLContext::sharedX11Display();

        GLXContext* glxSharingContext = reinterpret_cast<GLXContext*>(webkitContext->platformContext());

        GstGLDisplayX11* gstGLDisplay = gst_gl_display_x11_new_with_display(display);

        GstGLPlatform platform = GST_GL_PLATFORM_GLX;

        GstGLAPI glApi = gst_gl_context_get_current_gl_api(nullptr, nullptr);

        if (glxSharingContext)

            priv->otherContext = gst_gl_context_new_wrapped(GST_GL_DISPLAY(gstGLDisplay), reinterpret_cast<guintptr>(glxSharingContext), platform, glApi);

#endif

    }

    if (!priv->context) {

        priv->context = gst_gl_context_new(priv->display);

        if (!gst_gl_context_create(priv->context, priv->otherContext, &error)) {

            GST_ELEMENT_ERROR(sink, RESOURCE, NOT_FOUND, ("%s", error->message), (nullptr));

            gst_object_unref(priv->context);

            priv->context = nullptr;

            g_cond_signal(&priv->contextCondition);

            return FALSE;

        }

    }

    g_cond_signal(&priv->contextCondition);

    return FALSE;

}

#endif

#endif

#if USE(GSTREAMER_GL)

    GMutexLocker<GMutex> lock(priv->contextMutex);

    GThreadSafeMainLoopSource timeoutSource;

    gst_object_ref(sink);

    timeoutSource.schedule("[WebKit][gst] GL context wrap", std::function<void()>(std::bind(wrapGLContextCallback, sink)), G_PRIORITY_DEFAULT, [sink] {

        gst_object_unref(sink);

    });

    g_cond_wait(&sink->priv->contextCondition, &sink->priv->contextMutex);

    if (priv->upload)

        gst_object_unref(priv->upload);

    priv->upload = gst_gl_upload_new(priv->context);

    GstCapsFeatures* glFeatures = gst_caps_features_from_string(GST_CAPS_FEATURE_MEMORY_GL_MEMORY);

    if (priv->glCaps)

        gst_caps_unref(priv->glCaps);

    priv->glCaps = gst_caps_copy(caps);

    gst_caps_set_features(priv->glCaps, 0, glFeatures);

    gst_gl_upload_set_caps(priv->upload, caps, priv->glCaps);

#endif

#if USE(GSTREAMER_GL)

static GstFlowReturn webkitVideoSinkPrepare(GstBaseSink* baseSink, GstBuffer* buffer)

{

    WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink);

    WebKitVideoSinkPrivate* priv = sink->priv;

    GstBuffer* nextBuffer = nullptr;

    GstVideoFrame glFrame;

    GstVideoInfo glInfo;

    if (!gst_gl_upload_perform_with_buffer(priv->upload, buffer, &nextBuffer)) {

        GST_ELEMENT_ERROR(sink, RESOURCE, NOT_FOUND, ("%s", "Failed to upload buffer"), (nullptr));

        return GST_FLOW_ERROR;

    }

    gst_video_info_from_caps(&glInfo, priv->glCaps);

    if (!gst_video_frame_map(&glFrame, &glInfo, nextBuffer, static_cast<GstMapFlags>(GST_MAP_READ | GST_MAP_GL))) {

        gst_buffer_unref(nextBuffer);

        GST_ELEMENT_ERROR(sink, RESOURCE, NOT_FOUND, ("%s", "Failed to upload buffer"), (nullptr));

        return GST_FLOW_ERROR;

    }

    gst_buffer_replace(&priv->nextBuffer, nextBuffer);

    gst_buffer_unref(nextBuffer);

    gst_video_frame_unmap(&glFrame);

    return GST_FLOW_OK;

}

#endif

    GstStructure* glContext = nullptr;

#if USE(GSTREAMER_GL)

    GST_DEBUG_OBJECT(sink, "propose allocation");

    GMutexLocker<GMutex> lock(sink->priv->contextMutex);

    GThreadSafeMainLoopSource timeoutSource;

    gst_object_ref(sink);

    timeoutSource.schedule("[WebKit][gst] GL context wrap", std::function<void()>(std::bind(wrapGLContextCallback, sink)), G_PRIORITY_DEFAULT, [sink] {

        gst_object_unref(sink);

    });

    g_cond_wait(&sink->priv->contextCondition, &sink->priv->contextMutex);

    GstBufferPool* pool;

    GstAllocator* allocator = nullptr;

    GstAllocationParams params;

    GstStructure* config;

    guint size;

    if ((pool = sink->priv->pool))

        gst_object_ref(pool);

    if (pool) {

        GstCaps* pcaps;

        // We had a pool, check its caps.

        GST_DEBUG_OBJECT(sink, "check existing pool caps");

        config = gst_buffer_pool_get_config(pool);

        gst_buffer_pool_config_get_params(config, &pcaps, &size, 0, 0);

        if (!gst_caps_is_equal(caps, pcaps)) {

            GST_DEBUG_OBJECT(sink, "pool has different caps");

            // Different caps, we can't use this pool.

            gst_object_unref(pool);

            pool = nullptr;

        }

        gst_structure_free(config);

    }

    if (needPool && !pool) {

        GstVideoInfo info;

        if (!gst_video_info_from_caps(&info, caps)) {

            GST_DEBUG_OBJECT(sink, "invalid caps specified");

            return FALSE;

        }

        GST_DEBUG_OBJECT(sink, "create new pool with caps %" GST_PTR_FORMAT, caps);

        pool = gst_gl_buffer_pool_new(sink->priv->context);

        // The normal size of a frame.

        size = info.size;

        config = gst_buffer_pool_get_config(pool);

        gst_buffer_pool_config_set_params(config, caps, size, 0, 0);

        if (!gst_buffer_pool_set_config(pool, config)) {

            GST_DEBUG_OBJECT(sink, "failed setting config");

            return FALSE;

        }

    }

    if (pool) {

        gst_query_add_allocation_pool(query, pool, size, 2, 0);

        gst_object_unref(pool);

    }

    GUniquePtr<gchar> platform(gst_gl_platform_to_string(gst_gl_context_get_gl_platform(sink->priv->context)));

    GUniquePtr<gchar> glApis(gst_gl_api_to_string(gst_gl_context_get_gl_api(sink->priv->context)));

    gpointer handle = reinterpret_cast_ptr<gpointer>(gst_gl_context_get_gl_context(sink->priv->context));

    glContext = gst_structure_new("GstVideoGLTextureUploadMeta", "gst.gl.GstGLContext",

        GST_GL_TYPE_CONTEXT, sink->priv->context, "gst.gl.context.handle",

        G_TYPE_POINTER, handle, "gst.gl.context.type", G_TYPE_STRING, platform.get(),

        "gst.gl.context.apis", G_TYPE_STRING, glApis.get(), nullptr);

#endif

#if USE(GSTREAMER_GL)

static void webkitVideoSinkSetContext(GstElement* element, GstContext* context)

{

    WebKitVideoSink* sink =  WEBKIT_VIDEO_SINK(element);

    gst_gl_handle_set_context(element, context, &sink->priv->display, &sink->priv->context);

}

static gboolean webkitVideoSinkQuery(GstBaseSink* baseSink, GstQuery* query)

{

    WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink);

    gboolean result = FALSE;

    switch (GST_QUERY_TYPE(query)) {

    case GST_QUERY_CONTEXT: {

        result = gst_gl_handle_context_query(reinterpret_cast<GstElement*>(sink), query, &sink->priv->display, &sink->priv->otherContext);

        break;

    }

    default:

        result = GST_BASE_SINK_CLASS(parent_class)->query(baseSink, query);

        break;

    }

    return result;

}

#endif

#if USE(GSTREAMER_GL)

    baseSinkClass->prepare = webkitVideoSinkPrepare;

    baseSinkClass->query = webkitVideoSinkQuery;

    elementClass->set_context = webkitVideoSinkSetContext;

#endif

#  gstreamer-gl:         GSTREAMER_GL_INCLUDE_DIRS and GSTREAMER_GL_LIBRARIES

FIND_GSTREAMER_COMPONENT(GSTREAMER_GL gstreamer-gl-1.0>=1.5.0 gstgl-1.0)

    GSTREAMER_GL_INCLUDE_DIRS

    GSTREAMER_GL_LIBRARIES

    if (PC_GSTREAMER_GL_FOUND)

        add_definitions(-DWTF_USE_GSTREAMER_GL)

        set(USE_GSTREAMER_GL TRUE)

    endif ()