summaryrefslogtreecommitdiffstats
path: root/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp')
-rw-r--r--gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp325
1 files changed, 325 insertions, 0 deletions
diff --git a/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp
new file mode 100644
index 0000000000..c41e244e06
--- /dev/null
+++ b/gfx/webrender_bindings/RenderAndroidSurfaceTextureHost.cpp
@@ -0,0 +1,325 @@
+/* -*- 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/. */
+
+#include "RenderAndroidSurfaceTextureHost.h"
+
+#include "GLReadTexImageHelper.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/webrender/RenderThread.h"
+#include "GLContext.h"
+#include "AndroidSurfaceTexture.h"
+
+namespace mozilla {
+namespace wr {
+
+RenderAndroidSurfaceTextureHost::RenderAndroidSurfaceTextureHost(
+ const java::GeckoSurfaceTexture::GlobalRef& aSurfTex, gfx::IntSize aSize,
+ gfx::SurfaceFormat aFormat, bool aContinuousUpdate,
+ Maybe<gfx::Matrix4x4> aTransformOverride, bool aIsRemoteTexture)
+ : mSurfTex(aSurfTex),
+ mSize(aSize),
+ mFormat(aFormat),
+ mContinuousUpdate(aContinuousUpdate),
+ mTransformOverride(aTransformOverride),
+ mPrepareStatus(STATUS_NONE),
+ mAttachedToGLContext(false),
+ mIsRemoteTexture(aIsRemoteTexture) {
+ MOZ_COUNT_CTOR_INHERITED(RenderAndroidSurfaceTextureHost, RenderTextureHost);
+
+ if (mSurfTex) {
+ mSurfTex->IncrementUse();
+ }
+}
+
+RenderAndroidSurfaceTextureHost::~RenderAndroidSurfaceTextureHost() {
+ MOZ_ASSERT(RenderThread::IsInRenderThread());
+ MOZ_COUNT_DTOR_INHERITED(RenderAndroidSurfaceTextureHost, RenderTextureHost);
+ // The SurfaceTexture gets destroyed when its use count reaches zero.
+ if (mSurfTex) {
+ mSurfTex->DecrementUse();
+ }
+}
+
+wr::WrExternalImage RenderAndroidSurfaceTextureHost::Lock(uint8_t aChannelIndex,
+ gl::GLContext* aGL) {
+ MOZ_ASSERT(aChannelIndex == 0);
+ MOZ_ASSERT((mPrepareStatus == STATUS_PREPARED) ||
+ (!mSurfTex->IsSingleBuffer() &&
+ mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) ||
+ mIsRemoteTexture);
+
+ if (mIsRemoteTexture) {
+ EnsureAttachedToGLContext();
+ }
+
+ if (mGL.get() != aGL) {
+ // This should not happen. On android, SingletonGL is used.
+ MOZ_ASSERT_UNREACHABLE("Unexpected GL context");
+ return InvalidToWrExternalImage();
+ }
+
+ if (!mSurfTex || !mGL || !mGL->MakeCurrent()) {
+ return InvalidToWrExternalImage();
+ }
+
+ MOZ_ASSERT(mAttachedToGLContext);
+ if (!mAttachedToGLContext) {
+ return InvalidToWrExternalImage();
+ }
+
+ UpdateTexImageIfNecessary();
+
+ const auto uvs = GetUvCoords(mSize);
+ return NativeTextureToWrExternalImage(mSurfTex->GetTexName(), uvs.first.x,
+ uvs.first.y, uvs.second.x,
+ uvs.second.y);
+}
+
+void RenderAndroidSurfaceTextureHost::Unlock() {}
+
+bool RenderAndroidSurfaceTextureHost::EnsureAttachedToGLContext() {
+ // During handling WebRenderError, GeckoSurfaceTexture should not be attached
+ // to GLContext.
+ if (RenderThread::Get()->IsHandlingWebRenderError()) {
+ return false;
+ }
+
+ if (mAttachedToGLContext) {
+ return true;
+ }
+
+ if (!mGL) {
+ mGL = RenderThread::Get()->SingletonGL();
+ }
+
+ if (!mSurfTex || !mGL || !mGL->MakeCurrent()) {
+ return false;
+ }
+
+ if (!mSurfTex->IsAttachedToGLContext((int64_t)mGL.get())) {
+ GLuint texName;
+ mGL->fGenTextures(1, &texName);
+ ActivateBindAndTexParameteri(mGL, LOCAL_GL_TEXTURE0,
+ LOCAL_GL_TEXTURE_EXTERNAL_OES, texName);
+
+ if (NS_FAILED(mSurfTex->AttachToGLContext((int64_t)mGL.get(), texName))) {
+ MOZ_ASSERT(0);
+ mGL->fDeleteTextures(1, &texName);
+ return false;
+ }
+ }
+
+ mAttachedToGLContext = true;
+ return true;
+}
+
+void RenderAndroidSurfaceTextureHost::PrepareForUse() {
+ // When SurfaceTexture is single buffer mode, UpdateTexImage needs to be
+ // called only once for each publish. If UpdateTexImage is called more
+ // than once, it causes hang on puglish side. And UpdateTexImage needs to
+ // be called on render thread, since the SurfaceTexture is consumed on render
+ // thread.
+ MOZ_ASSERT(RenderThread::IsInRenderThread());
+ MOZ_ASSERT(mPrepareStatus == STATUS_NONE);
+
+ if (mContinuousUpdate || !mSurfTex) {
+ return;
+ }
+
+ mPrepareStatus = STATUS_MIGHT_BE_USED_BY_WR;
+
+ if (mSurfTex->IsSingleBuffer()) {
+ EnsureAttachedToGLContext();
+ // When SurfaceTexture is single buffer mode, it is OK to call
+ // UpdateTexImage() here.
+ mSurfTex->UpdateTexImage();
+ mPrepareStatus = STATUS_PREPARED;
+ }
+}
+
+void RenderAndroidSurfaceTextureHost::NotifyForUse() {
+ MOZ_ASSERT(RenderThread::IsInRenderThread());
+
+ if (mPrepareStatus == STATUS_MIGHT_BE_USED_BY_WR) {
+ // This happens when SurfaceTexture of video is rendered on WebRender.
+ // There is a case that SurfaceTexture is not rendered on WebRender, instead
+ // it is rendered to WebGL and the SurfaceTexture should not be attached to
+ // gl context of WebRender. It is ugly. But it is same as Compositor
+ // rendering.
+ MOZ_ASSERT(!mSurfTex->IsSingleBuffer());
+ if (!EnsureAttachedToGLContext()) {
+ return;
+ }
+ mPrepareStatus = STATUS_UPDATE_TEX_IMAGE_NEEDED;
+ }
+}
+
+void RenderAndroidSurfaceTextureHost::NotifyNotUsed() {
+ MOZ_ASSERT(RenderThread::IsInRenderThread());
+
+ if (!mSurfTex) {
+ MOZ_ASSERT(mPrepareStatus == STATUS_NONE);
+ return;
+ }
+
+ if (mIsRemoteTexture) {
+ UpdateTexImageIfNecessary();
+ }
+
+ if (mSurfTex->IsSingleBuffer()) {
+ MOZ_ASSERT(mPrepareStatus == STATUS_PREPARED);
+ MOZ_ASSERT(mAttachedToGLContext);
+ // Release SurfaceTexture's buffer to client side.
+ mGL->MakeCurrent();
+ mSurfTex->ReleaseTexImage();
+ } else if (mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) {
+ MOZ_ASSERT(mAttachedToGLContext);
+ // This could happen when video frame was skipped. UpdateTexImage() neeeds
+ // to be called for adjusting SurfaceTexture's buffer status.
+ mSurfTex->UpdateTexImage();
+ }
+
+ mPrepareStatus = STATUS_NONE;
+}
+
+void RenderAndroidSurfaceTextureHost::UpdateTexImageIfNecessary() {
+ if (mIsRemoteTexture) {
+ EnsureAttachedToGLContext();
+ if (mPrepareStatus == STATUS_NONE) {
+ PrepareForUse();
+ }
+ if (mPrepareStatus == STATUS_MIGHT_BE_USED_BY_WR) {
+ NotifyForUse();
+ }
+ }
+
+ if (mContinuousUpdate) {
+ MOZ_ASSERT(!mSurfTex->IsSingleBuffer());
+ mSurfTex->UpdateTexImage();
+ } else if (mPrepareStatus == STATUS_UPDATE_TEX_IMAGE_NEEDED) {
+ MOZ_ASSERT(!mSurfTex->IsSingleBuffer());
+ // When SurfaceTexture is not single buffer mode, call UpdateTexImage() once
+ // just before rendering. During playing video, one SurfaceTexture is used
+ // for all RenderAndroidSurfaceTextureHosts of video.
+ mSurfTex->UpdateTexImage();
+ mPrepareStatus = STATUS_PREPARED;
+ }
+}
+
+gfx::SurfaceFormat RenderAndroidSurfaceTextureHost::GetFormat() const {
+ MOZ_ASSERT(mFormat == gfx::SurfaceFormat::R8G8B8A8 ||
+ mFormat == gfx::SurfaceFormat::R8G8B8X8);
+
+ if (mFormat == gfx::SurfaceFormat::R8G8B8A8) {
+ return gfx::SurfaceFormat::B8G8R8A8;
+ }
+
+ if (mFormat == gfx::SurfaceFormat::R8G8B8X8) {
+ return gfx::SurfaceFormat::B8G8R8X8;
+ }
+
+ gfxCriticalNoteOnce
+ << "Unexpected color format of RenderAndroidSurfaceTextureHost";
+
+ return gfx::SurfaceFormat::UNKNOWN;
+}
+
+already_AddRefed<DataSourceSurface>
+RenderAndroidSurfaceTextureHost::ReadTexImage() {
+ if (!mGL) {
+ mGL = RenderThread::Get()->SingletonGL();
+ if (!mGL) {
+ return nullptr;
+ }
+ }
+
+ /* Allocate resulting image surface */
+ int32_t stride = mSize.width * BytesPerPixel(GetFormat());
+ RefPtr<DataSourceSurface> surf =
+ Factory::CreateDataSourceSurfaceWithStride(mSize, GetFormat(), stride);
+ if (!surf) {
+ return nullptr;
+ }
+
+ layers::ShaderConfigOGL config = layers::ShaderConfigFromTargetAndFormat(
+ LOCAL_GL_TEXTURE_EXTERNAL, mFormat);
+ int shaderConfig = config.mFeatures;
+
+ bool ret = mGL->ReadTexImageHelper()->ReadTexImage(
+ surf, mSurfTex->GetTexName(), LOCAL_GL_TEXTURE_EXTERNAL, mSize,
+ shaderConfig, /* aYInvert */ false);
+ if (!ret) {
+ return nullptr;
+ }
+
+ return surf.forget();
+}
+
+bool RenderAndroidSurfaceTextureHost::MapPlane(RenderCompositor* aCompositor,
+ uint8_t aChannelIndex,
+ PlaneInfo& aPlaneInfo) {
+ UpdateTexImageIfNecessary();
+
+ RefPtr<gfx::DataSourceSurface> readback = ReadTexImage();
+ if (!readback) {
+ return false;
+ }
+
+ DataSourceSurface::MappedSurface map;
+ if (!readback->Map(DataSourceSurface::MapType::READ, &map)) {
+ return false;
+ }
+
+ mReadback = readback;
+ aPlaneInfo.mSize = mSize;
+ aPlaneInfo.mStride = map.mStride;
+ aPlaneInfo.mData = map.mData;
+ return true;
+}
+
+void RenderAndroidSurfaceTextureHost::UnmapPlanes() {
+ if (mReadback) {
+ mReadback->Unmap();
+ mReadback = nullptr;
+ }
+}
+
+std::pair<gfx::Point, gfx::Point> RenderAndroidSurfaceTextureHost::GetUvCoords(
+ gfx::IntSize aTextureSize) const {
+ gfx::Matrix4x4 transform;
+
+ // GetTransformMatrix() returns the transform set by the producer side of the
+ // SurfaceTexture that must be applied to texture coordinates when
+ // sampling. In some cases we may have set an override value, such as in
+ // AndroidNativeWindowTextureData where we own the producer side, or for
+ // MediaCodec output on devices where where we know the value is incorrect.
+ if (mTransformOverride) {
+ transform = *mTransformOverride;
+ } else if (mSurfTex) {
+ const auto& surf = java::sdk::SurfaceTexture::LocalRef(
+ java::sdk::SurfaceTexture::Ref::From(mSurfTex));
+ gl::AndroidSurfaceTexture::GetTransformMatrix(surf, &transform);
+ }
+
+ // We expect this transform to always be rectilinear, usually just a
+ // y-flip and sometimes an x and y scale. This allows this function
+ // to simply transform and return 2 points here instead of 4.
+ MOZ_ASSERT(transform.IsRectilinear(),
+ "Unexpected non-rectilinear transform returned from "
+ "SurfaceTexture.GetTransformMatrix()");
+
+ transform.PostScale(aTextureSize.width, aTextureSize.height, 0.0);
+
+ gfx::Point uv0 = gfx::Point(0.0, 0.0);
+ gfx::Point uv1 = gfx::Point(1.0, 1.0);
+ uv0 = transform.TransformPoint(uv0);
+ uv1 = transform.TransformPoint(uv1);
+
+ return std::make_pair(uv0, uv1);
+}
+
+} // namespace wr
+} // namespace mozilla