Attachment 369494 Details for Bug 132869 – WIP

[patch] WIP

bug-132869-20190509183714.patch (text/plain), 29.94 KB, created by Zan Dobersek on 2019-05-09 09:37:15 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Zan Dobersek

Created: 2019-05-09 09:37:15 PDT

Size: 29.94 KB

patch

obsolete

>Subversion Revision: 245096
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 5bc103ec2476ec9d2b97eb98c1f35519c47fe62d..943e466addd13f53d93b102ac5ad66b11a6a3b31 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,34 @@
>+2019-05-09  Zan Dobersek  <zdobersek@igalia.com>
>+
>+        [Texmap] Add support to upload more color formats into the texture
>+        https://bugs.webkit.org/show_bug.cgi?id=132869
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests (OOPS!).
>+
>+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
>+        (WebCore::GstVideoFrameHolder::GstVideoFrameHolder):
>+        (WebCore::GstVideoFrameHolder::hasMappedTextures const):
>+        (WebCore::GstVideoFrameHolder::videoFrame const):
>+        (WebCore::MediaPlayerPrivateGStreamerBase::pushTextureToCompositor):
>+        * platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp:
>+        (WebCore::VideoTextureCopierGStreamer::VideoTextureCopierGStreamer):
>+        * platform/graphics/texmap/TextureMapperGL.cpp:
>+        (WebCore::optionsForFilterType):
>+        (WebCore::TextureMapperGL::drawTexture):
>+        (WebCore::TextureMapperGL::drawTextureYUV):
>+        * platform/graphics/texmap/TextureMapperGL.h:
>+        * platform/graphics/texmap/TextureMapperPlatformLayerBuffer.cpp:
>+        (WebCore::TextureMapperPlatformLayerBuffer::TextureMapperPlatformLayerBuffer):
>+        (WebCore::TextureMapperPlatformLayerBuffer::~TextureMapperPlatformLayerBuffer):
>+        (WebCore::TextureMapperPlatformLayerBuffer::clone):
>+        (WebCore::TextureMapperPlatformLayerBuffer::paintToTextureMapper):
>+        * platform/graphics/texmap/TextureMapperPlatformLayerBuffer.h:
>+        * platform/graphics/texmap/TextureMapperShaderProgram.cpp:
>+        (WebCore::TextureMapperShaderProgram::create):
>+        * platform/graphics/texmap/TextureMapperShaderProgram.h:
>+
> 2019-05-08  Carlos Garcia Campos  <cgarcia@igalia.com>
> 
>         REGRESSION(r239915): [FreeType] White space skipped when rendering plain text with noto CJK font
>diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
>index 5cb5f7536ac3cefe1e16c98fe967021130a6df74..7b5fb4d5320eb6d95b3d676afffd407e40ed501d 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
>@@ -55,11 +55,11 @@
> 
> #if USE(GSTREAMER_GL)
> #if G_BYTE_ORDER == G_LITTLE_ENDIAN
>-#define GST_GL_CAPS_FORMAT "{ BGRx, BGRA }"
>+#define GST_GL_CAPS_FORMAT "{ BGRx, BGRA, I420 }"
> #define TEXTURE_MAPPER_COLOR_CONVERT_FLAG TextureMapperGL::ShouldConvertTextureBGRAToRGBA
> #define TEXTURE_COPIER_COLOR_CONVERT_FLAG VideoTextureCopierGStreamer::ColorConversion::ConvertBGRAToRGBA
> #else
>-#define GST_GL_CAPS_FORMAT "{ xRGB, ARGB }"
>+#define GST_GL_CAPS_FORMAT "{ xRGB, ARGB, I420 }"
> #define TEXTURE_MAPPER_COLOR_CONVERT_FLAG TextureMapperGL::ShouldConvertTextureARGBToRGBA
> #define TEXTURE_COPIER_COLOR_CONVERT_FLAG VideoTextureCopierGStreamer::ColorConversion::ConvertARGBToRGBA
> #endif
>@@ -151,7 +151,7 @@ static int greatestCommonDivisor(int a, int b)
> #if USE(TEXTURE_MAPPER_GL)
> class GstVideoFrameHolder : public TextureMapperPlatformLayerBuffer::UnmanagedBufferDataHolder {
> public:
>-    explicit GstVideoFrameHolder(GstSample* sample, TextureMapperGL::Flags flags, bool gstGLEnabled)
>+    explicit GstVideoFrameHolder(GstGLContext* context, GstSample* sample, TextureMapperGL::Flags flags, bool gstGLEnabled)
>     {
>         GstVideoInfo videoInfo;
>         if (UNLIKELY(!getSampleVideoInfo(sample, videoInfo)))
>@@ -168,8 +168,10 @@ public:
> 
>         if (gstGLEnabled) {
>             m_isMapped = gst_video_frame_map(&m_videoFrame, &videoInfo, m_buffer, static_cast<GstMapFlags>(GST_MAP_READ | GST_MAP_GL));
>-            if (m_isMapped)
>+            if (m_isMapped) {
>                 m_textureID = *reinterpret_cast<GLuint*>(m_videoFrame.data[0]);
>+                m_hasMappedTextures = true;
>+            }
>         } else
> #else
>         UNUSED_PARAM(flags);
>@@ -198,6 +200,8 @@ public:
>     bool hasAlphaChannel() const { return m_hasAlphaChannel; }
>     TextureMapperGL::Flags flags() const { return m_flags; }
>     GLuint textureID() const { return m_textureID; }
>+    bool hasMappedTextures() const { return m_hasMappedTextures; }
>+    const GstVideoFrame& videoFrame() const { return m_videoFrame; }
> 
>     void updateTexture(BitmapTextureGL& texture)
>     {
>@@ -225,6 +229,7 @@ private:
>     TextureMapperGL::Flags m_flags { };
>     GLuint m_textureID { 0 };
>     bool m_isMapped { false };
>+    bool m_hasMappedTextures { false };
> };
> #endif
> 
>@@ -712,12 +717,47 @@ void MediaPlayerPrivateGStreamerBase::pushTextureToCompositor()
>             if (!proxy.isActive())
>                 return;
> 
>-            std::unique_ptr<GstVideoFrameHolder> frameHolder = std::make_unique<GstVideoFrameHolder>(m_sample.get(), m_textureMapperFlags, !m_usingFallbackVideoSink);
>+            std::unique_ptr<GstVideoFrameHolder> frameHolder = std::make_unique<GstVideoFrameHolder>(m_glContext.get(), m_sample.get(), m_textureMapperFlags, !m_usingFallbackVideoSink);
>+
>+            using Buffer = TextureMapperPlatformLayerBuffer;
>+            std::unique_ptr<Buffer> layerBuffer;
>+            if (frameHolder->hasMappedTextures()) {
>+                auto& videoFrame = frameHolder->videoFrame();
>+                [&] {
>+                    if (GST_VIDEO_INFO_IS_RGB(&videoFrame.info)) {
>+                        if (GST_VIDEO_INFO_N_PLANES(&videoFrame.info) != 1)
>+                            return;
>+
>+                        layerBuffer = std::make_unique<Buffer>(
>+                            Buffer::TextureVariant { Buffer::RGBTexture {
>+                                    *static_cast<GLuint*>(videoFrame.data[0])
>+                                } }, frameHolder->size(), frameHolder->flags(), GraphicsContext3D::RGBA);
>+                        return;
>+                    }
>+
>+                    if (GST_VIDEO_INFO_IS_YUV(&videoFrame.info)) {
>+                        if (GST_VIDEO_INFO_N_PLANES(&videoFrame.info) != 3)
>+                            return;
>+
>+                        if (m_videoDecoderPlatform == WebKitGstVideoDecoderPlatform::ImxVPU) {
>+                            layerBuffer = std::make_unique<Buffer>(
>+                                Buffer::TextureVariant { Buffer::RGBTexture {
>+                                        *static_cast<GLuint*>(videoFrame.data[0])
>+                                    } }, frameHolder->size(), frameHolder->flags(), GraphicsContext3D::RGBA);
>+                        } else {
>+                            layerBuffer = std::make_unique<Buffer>(
>+                                Buffer::TextureVariant { Buffer::YUVTexture {
>+                                        *static_cast<GLuint*>(videoFrame.data[0]),
>+                                        *static_cast<GLuint*>(videoFrame.data[1]),
>+                                        *static_cast<GLuint*>(videoFrame.data[2])
>+                                    } }, frameHolder->size(), frameHolder->flags(), GraphicsContext3D::RGBA);
>+                        }
>+                    }
>+                }();
>+
>+                if (!layerBuffer)
>+                    return;
> 
>-            GLuint textureID = frameHolder->textureID();
>-            std::unique_ptr<TextureMapperPlatformLayerBuffer> layerBuffer;
>-            if (textureID) {
>-                layerBuffer = std::make_unique<TextureMapperPlatformLayerBuffer>(textureID, frameHolder->size(), frameHolder->flags(), GraphicsContext3D::RGBA);
>                 layerBuffer->setUnmanagedBufferDataHolder(WTFMove(frameHolder));
>             } else {
>                 layerBuffer = proxy.getAvailableBuffer(frameHolder->size(), GL_DONT_CARE);
>@@ -914,7 +954,7 @@ bool MediaPlayerPrivateGStreamerBase::copyVideoTextureToPlatformTexture(Graphics
>     if (!GST_IS_SAMPLE(m_sample.get()))
>         return false;
> 
>-    std::unique_ptr<GstVideoFrameHolder> frameHolder = std::make_unique<GstVideoFrameHolder>(m_sample.get(), m_textureMapperFlags, true);
>+    std::unique_ptr<GstVideoFrameHolder> frameHolder = std::make_unique<GstVideoFrameHolder>(m_glContext.get(), m_sample.get(), m_textureMapperFlags, true);
> 
>     auto textureID = frameHolder->textureID();
>     if (!textureID)
>diff --git a/Source/WebCore/platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp b/Source/WebCore/platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp
>index 135333ea1b515eb5f5101cba56dbd672d80837df..c42d916b0f71bb1f3655bb61dadc9926e460158b 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/VideoTextureCopierGStreamer.cpp
>@@ -35,7 +35,7 @@ VideoTextureCopierGStreamer::VideoTextureCopierGStreamer(ColorConversion colorCo
>     ASSERT(previousContext);
>     PlatformDisplay::sharedDisplayForCompositing().sharingGLContext()->makeContextCurrent();
> 
>-    m_shaderProgram = TextureMapperShaderProgram::create(TextureMapperShaderProgram::Texture);
>+    m_shaderProgram = TextureMapperShaderProgram::create(TextureMapperShaderProgram::TextureRGB);
> 
>     glGenFramebuffers(1, &m_framebuffer);
>     glGenTextures(1, &m_resultTexture);
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
>index 974b8578b88aa6435091e8b0c38bb2db710ef102..5f4ce23e025052ae4ffe896fd2eb975417f36c62 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.cpp
>@@ -319,21 +319,21 @@ static TextureMapperShaderProgram::Options optionsForFilterType(FilterOperation:
> {
>     switch (type) {
>     case FilterOperation::GRAYSCALE:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::GrayscaleFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::GrayscaleFilter;
>     case FilterOperation::SEPIA:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::SepiaFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::SepiaFilter;
>     case FilterOperation::SATURATE:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::SaturateFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::SaturateFilter;
>     case FilterOperation::HUE_ROTATE:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::HueRotateFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::HueRotateFilter;
>     case FilterOperation::INVERT:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::InvertFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::InvertFilter;
>     case FilterOperation::BRIGHTNESS:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::BrightnessFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::BrightnessFilter;
>     case FilterOperation::CONTRAST:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::ContrastFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::ContrastFilter;
>     case FilterOperation::OPACITY:
>-        return TextureMapperShaderProgram::Texture | TextureMapperShaderProgram::OpacityFilter;
>+        return TextureMapperShaderProgram::TextureRGB | TextureMapperShaderProgram::OpacityFilter;
>     case FilterOperation::BLUR:
>         return TextureMapperShaderProgram::BlurFilter;
>     case FilterOperation::DROP_SHADOW:
>@@ -470,7 +470,7 @@ void TextureMapperGL::drawTexture(GLuint texture, Flags flags, const IntSize& te
>         && exposedEdges == AllEdges
>         && !modelViewMatrix.mapQuad(targetRect).isRectilinear();
> 
>-    TextureMapperShaderProgram::Options options = TextureMapperShaderProgram::Texture;
>+    TextureMapperShaderProgram::Options options = TextureMapperShaderProgram::TextureRGB;
>     if (useRect)
>         options |= TextureMapperShaderProgram::Rect;
>     if (opacity < 1)
>@@ -504,6 +504,114 @@ void TextureMapperGL::drawTexture(GLuint texture, Flags flags, const IntSize& te
>     drawTexturedQuadWithProgram(program.get(), texture, flags, textureSize, targetRect, modelViewMatrix, opacity);
> }
> 
>+void TextureMapperGL::drawTextureYUV(const std::array<GLuint,3>& textures, Flags flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges)
>+{
>+    bool useRect = flags & ShouldUseARBTextureRect;
>+    bool useAntialiasing = m_enableEdgeDistanceAntialiasing
>+        && exposedEdges == AllEdges
>+        && !modelViewMatrix.mapQuad(targetRect).isRectilinear();
>+
>+    TextureMapperShaderProgram::Options options = TextureMapperShaderProgram::TextureYUV;
>+    if (useRect)
>+        options |= TextureMapperShaderProgram::Rect;
>+    if (opacity < 1)
>+        options |= TextureMapperShaderProgram::Opacity;
>+    if (useAntialiasing) {
>+        options |= TextureMapperShaderProgram::Antialiasing;
>+        flags |= ShouldAntialias;
>+    }
>+    if (wrapMode() == RepeatWrap && !m_contextAttributes.supportsNPOTTextures)
>+        options |= TextureMapperShaderProgram::ManualRepeat;
>+
>+    RefPtr<FilterOperation> filter = data().filterInfo ? data().filterInfo->filter: 0;
>+    GLuint filterContentTextureID = 0;
>+
>+    if (filter) {
>+        if (data().filterInfo->contentTexture)
>+            filterContentTextureID = toBitmapTextureGL(data().filterInfo->contentTexture.get())->id();
>+        options |= optionsForFilterType(filter->type(), data().filterInfo->pass);
>+        if (filter->affectsOpacity())
>+            flags |= ShouldBlend;
>+    }
>+
>+    if (useAntialiasing || opacity < 1)
>+        flags |= ShouldBlend;
>+
>+    Ref<TextureMapperShaderProgram> program = data().getShaderProgram(options);
>+
>+    if (filter)
>+        prepareFilterProgram(program.get(), *filter.get(), data().filterInfo->pass, textureSize, filterContentTextureID);
>+
>+    {
>+        glUseProgram(program->programID());
>+        {
>+            GLenum target = flags & ShouldUseARBTextureRect ? GLenum(GL_TEXTURE_RECTANGLE_ARB) : GLenum(GL_TEXTURE_2D);
>+            std::array<GLuint, 3> samplers = {
>+                    program->samplerYLocation(),
>+                    program->samplerULocation(),
>+                    program->samplerVLocation(),
>+                };
>+
>+            for (unsigned i : { 0, 1, 2 }) {
>+                glActiveTexture(GL_TEXTURE0 + i);
>+                glBindTexture(target, textures[i]);
>+                glUniform1i(samplers[i], i);
>+
>+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
>+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
>+                if (wrapMode() == RepeatWrap && m_contextAttributes.supportsNPOTTextures) {
>+                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
>+                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
>+                } else {
>+                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>+                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
>+                }
>+            }
>+        }
>+
>+        TransformationMatrix patternTransform = this->patternTransform();
>+        if (flags & ShouldRotateTexture90) {
>+            patternTransform.rotate(-90);
>+            patternTransform.translate(-1, 0);
>+        }
>+        if (flags & ShouldRotateTexture180) {
>+            patternTransform.rotate(180);
>+            patternTransform.translate(-1, -1);
>+        }
>+        if (flags & ShouldRotateTexture270) {
>+            patternTransform.rotate(-270);
>+            patternTransform.translate(0, -1);
>+        }
>+        if (flags & ShouldFlipTexture)
>+            patternTransform.flipY();
>+        if (flags & ShouldUseARBTextureRect)
>+            patternTransform.scaleNonUniform(textureSize.width(), textureSize.height());
>+        if (flags & ShouldFlipTexture)
>+            patternTransform.translate(0, -1);
>+
>+        program->setMatrix(program->textureSpaceMatrixLocation(), patternTransform);
>+        program->setMatrix(program->textureColorSpaceMatrixLocation(), colorSpaceMatrixForFlags(flags));
>+        glUniform1f(program->opacityLocation(), opacity);
>+
>+        if (opacity < 1)
>+            flags |= ShouldBlend;
>+
>+        draw(targetRect, modelViewMatrix, program, GL_TRIANGLE_FAN, flags);
>+
>+        {
>+            GLenum target = flags & ShouldUseARBTextureRect ? GLenum(GL_TEXTURE_RECTANGLE_ARB) : GLenum(GL_TEXTURE_2D);
>+
>+            for (unsigned i : { 0, 1, 2 }) {
>+                glBindTexture(target, textures[i]);
>+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
>+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
>+            }
>+
>+            glBindTexture(target, 0);
>+        }
>+    }
>+}
>+
> void TextureMapperGL::drawSolidColor(const FloatRect& rect, const TransformationMatrix& matrix, const Color& color, bool isBlendingAllowed)
> {
>     Flags flags = 0;
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h
>index ca056af66030ed1eed92fa5c2a28da90cb34eb6a..b2302a0b38be24db46bb9b3f8ae66a7ca9b0fb9d 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperGL.h
>@@ -30,6 +30,7 @@
> #include "TextureMapperContextAttributes.h"
> #include "TextureMapperGLHeaders.h"
> #include "TransformationMatrix.h"
>+#include <array>
> 
> namespace WebCore {
> 
>@@ -64,6 +65,7 @@ public:
>     void drawNumber(int number, const Color&, const FloatPoint&, const TransformationMatrix&) override;
>     void drawTexture(const BitmapTexture&, const FloatRect&, const TransformationMatrix&, float opacity, unsigned exposedEdges) override;
>     virtual void drawTexture(GLuint texture, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges = AllEdges);
>+    void drawTextureYUV(const std::array<GLuint, 3>& textures, Flags, const IntSize& textureSize, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity, unsigned exposedEdges = AllEdges);
>     void drawSolidColor(const FloatRect&, const TransformationMatrix&, const Color&, bool) override;
>     void clearColor(const Color&) override;
> 
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.cpp
>index 7afdf30a05bca5397b8018bfebd89e0e1da50333..51171374a88b7b387de254858bf448588306a163 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.cpp
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.cpp
>@@ -35,20 +35,40 @@ namespace WebCore {
> 
> TextureMapperPlatformLayerBuffer::TextureMapperPlatformLayerBuffer(RefPtr<BitmapTexture>&& texture, TextureMapperGL::Flags flags)
>     : m_texture(WTFMove(texture))
>-    , m_textureID(0)
>+    , m_variant(RGBTexture { 0 })
>     , m_extraFlags(flags)
>     , m_hasManagedTexture(true)
> {
> }
> 
>+#if 0
> TextureMapperPlatformLayerBuffer::TextureMapperPlatformLayerBuffer(GLuint textureID, const IntSize& size, TextureMapperGL::Flags flags, GLint internalFormat)
>-    : m_textureID(textureID)
>+    : m_variant(RGBTexture { textureID })
>     , m_size(size)
>     , m_internalFormat(internalFormat)
>     , m_extraFlags(flags)
>     , m_hasManagedTexture(false)
> {
> }
>+#endif
>+
>+TextureMapperPlatformLayerBuffer::TextureMapperPlatformLayerBuffer(GLuint textureID, const IntSize& size, TextureMapperGL::Flags flags, GLint internalFormat)
>+    : TextureMapperPlatformLayerBuffer({ RGBTexture { textureID } }, size, flags, internalFormat)
>+{
>+}
>+
>+TextureMapperPlatformLayerBuffer::TextureMapperPlatformLayerBuffer(TextureVariant&& variant, const IntSize& size, TextureMapperGL::Flags flags, GLint internalFormat)
>+    : m_variant(WTFMove(variant))
>+    , m_size(size)
>+    , m_internalFormat(internalFormat)
>+    , m_extraFlags(flags)
>+    , m_hasManagedTexture(false)
>+{
>+}
>+
>+TextureMapperPlatformLayerBuffer::~TextureMapperPlatformLayerBuffer()
>+{
>+}
> 
> bool TextureMapperPlatformLayerBuffer::canReuseWithoutReset(const IntSize& size, GLint internalFormat)
> {
>@@ -57,14 +77,24 @@ bool TextureMapperPlatformLayerBuffer::canReuseWithoutReset(const IntSize& size,
> 
> std::unique_ptr<TextureMapperPlatformLayerBuffer> TextureMapperPlatformLayerBuffer::clone()
> {
>-    if (m_hasManagedTexture || !m_textureID) {
>+    if (m_hasManagedTexture) {
>         notImplemented();
>         return nullptr;
>     }
>-    auto texture = BitmapTextureGL::create(TextureMapperContextAttributes::get(), m_internalFormat);
>-    texture->reset(m_size);
>-    static_cast<BitmapTextureGL&>(texture.get()).copyFromExternalTexture(m_textureID);
>-    return std::make_unique<TextureMapperPlatformLayerBuffer>(WTFMove(texture), m_extraFlags);
>+
>+    return WTF::switchOn(m_variant,
>+        [&](const RGBTexture& texture)
>+        {
>+            auto clonedTexture = BitmapTextureGL::create(TextureMapperContextAttributes::get(), m_internalFormat);
>+            clonedTexture->reset(m_size);
>+            static_cast<BitmapTextureGL&>(clonedTexture.get()).copyFromExternalTexture(texture.id);
>+            return std::make_unique<TextureMapperPlatformLayerBuffer>(WTFMove(clonedTexture), m_extraFlags);
>+        },
>+        [](const YUVTexture&)
>+        {
>+            notImplemented();
>+            return nullptr;
>+        });
> }
> 
> void TextureMapperPlatformLayerBuffer::paintToTextureMapper(TextureMapper& textureMapper, const FloatRect& targetRect, const TransformationMatrix& modelViewMatrix, float opacity)
>@@ -86,8 +116,17 @@ void TextureMapperPlatformLayerBuffer::paintToTextureMapper(TextureMapper& textu
>         return;
>     }
> 
>-    ASSERT(m_textureID);
>-    texmapGL.drawTexture(m_textureID, m_extraFlags, m_size, targetRect, modelViewMatrix, opacity);
>+    WTF::switchOn(m_variant,
>+        [&](const RGBTexture& texture)
>+        {
>+            ASSERT(texture.id);
>+            texmapGL.drawTexture(texture.id, m_extraFlags, m_size, targetRect, modelViewMatrix, opacity);
>+        },
>+        [&](const YUVTexture& texture)
>+        {
>+            texmapGL.drawTextureYUV(std::array<GLuint, 3> { texture.y, texture.u, texture.v },
>+                m_extraFlags, m_size, targetRect, modelViewMatrix, opacity);
>+        });
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.h b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.h
>index d100e24ad131649794b90692e6612a37ab7c9aeb..e2a8b8c09291eeebe59f3215f21a0ded28bf8cff 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.h
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerBuffer.h
>@@ -31,6 +31,7 @@
> #include "TextureMapperGLHeaders.h"
> #include "TextureMapperPlatformLayer.h"
> #include <wtf/MonotonicTime.h>
>+#include <wtf/Variant.h>
> 
> namespace WebCore {
> 
>@@ -39,9 +40,20 @@ class TextureMapperPlatformLayerBuffer : public TextureMapperPlatformLayer {
>     WTF_MAKE_FAST_ALLOCATED();
> public:
>     TextureMapperPlatformLayerBuffer(RefPtr<BitmapTexture>&&, TextureMapperGL::Flags = 0);
>+
>     TextureMapperPlatformLayerBuffer(GLuint textureID, const IntSize&, TextureMapperGL::Flags, GLint internalFormat);
>+    struct RGBTexture {
>+        GLuint id;
>+    };
>+    struct YUVTexture {
>+        GLuint y;
>+        GLuint u;
>+        GLuint v;
>+    };
>+    using TextureVariant = WTF::Variant<RGBTexture, YUVTexture>;
>+    TextureMapperPlatformLayerBuffer(TextureVariant&&, const IntSize&, TextureMapperGL::Flags, GLint internalFormat);
> 
>-    virtual ~TextureMapperPlatformLayerBuffer() = default;
>+    virtual ~TextureMapperPlatformLayerBuffer();
> 
>     void paintToTextureMapper(TextureMapper&, const FloatRect&, const TransformationMatrix& modelViewMatrix = TransformationMatrix(), float opacity = 1.0) final;
> 
>@@ -78,6 +90,7 @@ private:
>     RefPtr<BitmapTexture> m_texture;
>     MonotonicTime m_timeLastUsed;
> 
>+    TextureVariant m_variant;
>     GLuint m_textureID;
>     IntSize m_size;
>     GLint m_internalFormat;
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.cpp
>index c714f6d78c1cf1a61d4dff6b420521b02ecd7c50..eb4e77bc79024732ce14df3dbd96ce921cef5db5 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.cpp
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.cpp
>@@ -185,8 +185,12 @@ void TextureMapperPlatformLayerProxy::swapBuffer()
>     m_currentBuffer = WTFMove(m_pendingBuffer);
>     m_targetLayer->setContentsLayer(m_currentBuffer.get());
> 
>-    if (prevBuffer && prevBuffer->hasManagedTexture())
>-        appendToUnusedBuffers(WTFMove(prevBuffer));
>+    if (prevBuffer) {
>+        if (prevBuffer->hasManagedTexture())
>+            appendToUnusedBuffers(WTFMove(prevBuffer));
>+        else
>+            m_prevBuffer = WTFMove(prevBuffer);
>+    }
> }
> 
> void TextureMapperPlatformLayerProxy::dropCurrentBufferWhilePreservingTexture(bool shouldWait)
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.h b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.h
>index d38e6c21f61fb40795c9655334d1f0c35643dadf..b3760986acdb8aef6fd15a12a822cf1cbe3ae2d0 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.h
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperPlatformLayerProxy.h
>@@ -83,6 +83,7 @@ private:
> 
>     std::unique_ptr<TextureMapperPlatformLayerBuffer> m_currentBuffer;
>     std::unique_ptr<TextureMapperPlatformLayerBuffer> m_pendingBuffer;
>+    std::unique_ptr<TextureMapperPlatformLayerBuffer> m_prevBuffer;
> 
>     Lock m_lock;
> 
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp b/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp
>index e1c97fe42f7db7eb20d0cc13c0442f596cfc19e5..46c1ff58a839442fa2ee1237276daa484370f74f 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.cpp
>@@ -207,6 +207,9 @@ static const char* fragmentTemplateGE320Vars =
> static const char* fragmentTemplateCommon =
>     STRINGIFY(
>         uniform SamplerType s_sampler;
>+        uniform SamplerType s_samplerY;
>+        uniform SamplerType s_samplerU;
>+        uniform SamplerType s_samplerV;
>         uniform sampler2D s_contentTexture;
>         uniform float u_opacity;
>         uniform float u_filterAmount;
>@@ -231,7 +234,15 @@ static const char* fragmentTemplateCommon =
> 
>         void applyManualRepeat(inout vec2 pos) { pos = fract(pos); }
> 
>-        void applyTexture(inout vec4 color, vec2 texCoord) { color = u_textureColorSpaceMatrix * SamplerFunction(s_sampler, texCoord); }
>+        void applyTextureRGB(inout vec4 color, vec2 texCoord) { color = u_textureColorSpaceMatrix * SamplerFunction(s_sampler, texCoord); }
>+        void applyTextureYUV(inout vec4 color, vec2 texCoord)
>+        {
>+            float y = SamplerFunction(s_samplerY, texCoord).r;
>+            float u = SamplerFunction(s_samplerU, texCoord).r - 0.5;
>+            float v = SamplerFunction(s_samplerV, texCoord).r - 0.5;
>+            vec4 data = vec4(y + 1.402 * v, y - 0.344 * u - 0.714 * v, y + 1.772 * u , 1);
>+            color = u_textureColorSpaceMatrix * data.bgra;
>+        }
>         void applyOpacity(inout vec4 color) { color *= u_opacity; }
>         void applyAntialiasing(inout vec4 color) { color *= antialias(); }
> 
>@@ -343,7 +354,8 @@ static const char* fragmentTemplateCommon =
>             vec4 color = vec4(1., 1., 1., 1.);
>             vec2 texCoord = transformTexCoord();
>             applyManualRepeatIfNeeded(texCoord);
>-            applyTextureIfNeeded(color, texCoord);
>+            applyTextureRGBIfNeeded(color, texCoord);
>+            applyTextureYUVIfNeeded(color, texCoord);
>             applySolidColorIfNeeded(color);
>             applyAntialiasingIfNeeded(color);
>             applyOpacityIfNeeded(color);
>@@ -369,7 +381,8 @@ Ref<TextureMapperShaderProgram> TextureMapperShaderProgram::create(TextureMapper
>         (options & TextureMapperShaderProgram::Applier) ? ENABLE_APPLIER(Applier) : DISABLE_APPLIER(Applier))
> 
>     StringBuilder optionsApplierBuilder;
>-    SET_APPLIER_FROM_OPTIONS(Texture);
>+    SET_APPLIER_FROM_OPTIONS(TextureRGB);
>+    SET_APPLIER_FROM_OPTIONS(TextureYUV);
>     SET_APPLIER_FROM_OPTIONS(Rect);
>     SET_APPLIER_FROM_OPTIONS(SolidColor);
>     SET_APPLIER_FROM_OPTIONS(Opacity);
>diff --git a/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.h b/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.h
>index 8da1e42819e0d174787b37fa0f56f41f21f26ced..9690d67d61febaceb6da726ecc33ff13ba9203da 100644
>--- a/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.h
>+++ b/Source/WebCore/platform/graphics/texmap/TextureMapperShaderProgram.h
>@@ -45,7 +45,7 @@ namespace WebCore {
> class TextureMapperShaderProgram : public RefCounted<TextureMapperShaderProgram> {
> public:
>     enum Option {
>-        Texture          = 1L << 0,
>+        TextureRGB       = 1L << 0,
>         Rect             = 1L << 1,
>         SolidColor       = 1L << 2,
>         Opacity          = 1L << 3,
>@@ -61,7 +61,8 @@ public:
>         BlurFilter       = 1L << 14,
>         AlphaBlur        = 1L << 15,
>         ContentTexture   = 1L << 16,
>-        ManualRepeat     = 1L << 17
>+        ManualRepeat     = 1L << 17,
>+        TextureYUV       = 1L << 18,
>     };
> 
>     typedef unsigned Options;
>@@ -81,6 +82,9 @@ public:
>     TEXMAP_DECLARE_UNIFORM(color)
>     TEXMAP_DECLARE_UNIFORM(expandedQuadEdgesInScreenSpace)
>     TEXMAP_DECLARE_SAMPLER(sampler)
>+    TEXMAP_DECLARE_SAMPLER(samplerY)
>+    TEXMAP_DECLARE_SAMPLER(samplerU)
>+    TEXMAP_DECLARE_SAMPLER(samplerV)
>     TEXMAP_DECLARE_SAMPLER(mask)
> 
>     TEXMAP_DECLARE_UNIFORM(filterAmount)

Actions: View | Formatted Diff | Diff

Attachments on bug 132869: 364675 | 369494 | 372694 | 376065 | 376496 | 376751 | 377333 | 377882 | 377890