fc8a98e8d9
On Android, SurfaceTextures provide a transform that should be applied to texture coordinates when sampling from the texture. Usually this is simply a y-flip, but sometimes it includes a scale and slight translation, eg when the video frame is contained within a larger texture. Previously we ignored this transform but performed a y-flip, meaning we rendered correctly most of the time, but not all of the time. Our first attempt to fix this was in bug 1731980. When rendering as a compositor surface with RenderCompositorOGLSWGL, we supplied the transform to CompositorOGL's shaders, which correctly fixed the bug for this rendering path. However, the attempted fix for hardware webrender in fact made things worse. As UV coordinates are supplied to webrender unnormalized, then the shaders normalize them by dividing by the actual texture size, this effectively handled the scale component of the transform. (Though not quite scaling by the correct amount, and ignoring the translation component, sometimes resulting in a pixel-wide green seam being visible at the video's edges.) When we additionally applied the transformation to the coordinates, it resulted in the scale being applied twice, and the video being rendered too far zoomed in. To make matters worse, when we received subsequent bug reports of incorrect rendering on various devices we mistakenly assumed that the devices must be buggy, rather than our code being incorrect. We therefore reverted to ignoring the transform on these devices, thereby breaking the software webrender path again. Additionally, on devices without GL_OES_EGL_image_external_essl3 support, we must sample from the SurfaceTexture using an ESSL1 shader. This means we do not have access to the correct texture size, meaning we cannot correctly normalize the UV coordinates. This results in the video being rendered too far zoomed out. And in the non-compositor-surface software webrender path, we were accidentally downscaling the texture when reading back into a CPU buffer, resulting in the video being rendered at the correct zoom, but being very blurry. This patch aims to handle the transform correctly, in all rendering paths, hopefully once and for all. For hardware webrender, we now supply the texture coordinates to webrender already normalized, using the functionality added in the previous patch. This avoids the shaders scaling the coordinates again, or using an incorrect texture size to do so. For RenderCompositorOGLSWGL, we continue to apply the transform using CompositorOGL's shaders. In the non-compositor-surface software webrender path, we make GLReadPixelsHelper apply the transform when reading from the SurfaceTexture in to the CPU buffer. Again using functionality added earlier in this patch series. This avoids downscaling the image. We can then provide the default untransformed and unnormalized UVs to webrender. As a result we can now remove the virtual function RenderTextureHost::GetUvCoords(), added in bug 1731980, as it no longer serves any purpose: we no longer want to share the implementation between RenderAndroidSurfaceTextureHost::Lock and RenderTextureHostSWGL::LockSWGL. Finally, we remove all transform overrides on the devices we mistakenly assumed were buggy. Differential Revision: https://phabricator.services.mozilla.com/D220582
85 lines
3.3 KiB
C++
85 lines
3.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H
|
|
#define MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H
|
|
|
|
#include "RenderTextureHostSWGL.h"
|
|
|
|
namespace mozilla {
|
|
|
|
namespace wr {
|
|
|
|
/**
|
|
* RenderTextureHost of GPUVideoTextureHost.
|
|
*
|
|
* GPUVideoTextureHost wraps TextureHost. This class wraps RenderTextureHost of
|
|
* the wrapped TextureHost. Lifetime of the wrapped TextureHost is usually
|
|
* longer than GPUVideoTextureHost and the wrapped TextureHost is used by
|
|
* multiple GPUVideoTextureHosts. This class is used to reduce recreations of
|
|
* the wrappded RenderTextureHost. Initializations of some
|
|
* RenderTextureHosts(RenderDXGITextureHost and
|
|
* RenderDXGIYCbCrTextureHost) have overhead.
|
|
*/
|
|
class RenderTextureHostWrapper final : public RenderTextureHostSWGL {
|
|
public:
|
|
explicit RenderTextureHostWrapper(ExternalImageId aExternalImageId);
|
|
|
|
// RenderTextureHost
|
|
wr::WrExternalImage Lock(uint8_t aChannelIndex, gl::GLContext* aGL) override;
|
|
void Unlock() override;
|
|
void ClearCachedResources() override;
|
|
void PrepareForUse() override;
|
|
void NotifyForUse() override;
|
|
void NotifyNotUsed() override;
|
|
bool SyncObjectNeeded() override;
|
|
RefPtr<layers::TextureSource> CreateTextureSource(
|
|
layers::TextureSourceProvider* aProvider) override;
|
|
RenderMacIOSurfaceTextureHost* AsRenderMacIOSurfaceTextureHost() override;
|
|
RenderDXGITextureHost* AsRenderDXGITextureHost() override;
|
|
RenderDXGIYCbCrTextureHost* AsRenderDXGIYCbCrTextureHost() override;
|
|
RenderDcompSurfaceTextureHost* AsRenderDcompSurfaceTextureHost() override;
|
|
RenderAndroidHardwareBufferTextureHost*
|
|
AsRenderAndroidHardwareBufferTextureHost() override;
|
|
RenderAndroidSurfaceTextureHost* AsRenderAndroidSurfaceTextureHost() override;
|
|
RenderEGLImageTextureHost* AsRenderEGLImageTextureHost() override;
|
|
RenderTextureHostSWGL* AsRenderTextureHostSWGL() override;
|
|
void SetIsSoftwareDecodedVideo() override;
|
|
bool IsSoftwareDecodedVideo() override;
|
|
RefPtr<RenderTextureHostUsageInfo> GetOrMergeUsageInfo(
|
|
const MutexAutoLock& aProofOfMapLock,
|
|
RefPtr<RenderTextureHostUsageInfo> aUsageInfo) override;
|
|
RefPtr<RenderTextureHostUsageInfo> GetTextureHostUsageInfo(
|
|
const MutexAutoLock& aProofOfMapLock) override;
|
|
|
|
// RenderTextureHostSWGL
|
|
size_t GetPlaneCount() const override;
|
|
gfx::SurfaceFormat GetFormat() const override;
|
|
gfx::ColorDepth GetColorDepth() const override;
|
|
gfx::YUVRangedColorSpace GetYUVColorSpace() const override;
|
|
bool MapPlane(RenderCompositor* aCompositor, uint8_t aChannelIndex,
|
|
PlaneInfo& aPlaneInfo) override;
|
|
void UnmapPlanes() override;
|
|
|
|
// This is just a wrapper, so doesn't need to report the
|
|
// size of the wrapped object (which reports itself).
|
|
size_t Bytes() override { return 0; }
|
|
|
|
private:
|
|
~RenderTextureHostWrapper() override;
|
|
|
|
void EnsureTextureHost() const;
|
|
RenderTextureHostSWGL* EnsureRenderTextureHostSWGL() const;
|
|
|
|
ExternalImageId mExternalImageId;
|
|
mutable RefPtr<RenderTextureHost> mTextureHost;
|
|
};
|
|
|
|
} // namespace wr
|
|
} // namespace mozilla
|
|
|
|
#endif // MOZILLA_GFX_RENDERTEXTUREHOSTWRAPPER_H
|