gecko-dev/gfx/gl/SharedSurfaceEGL.h

/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 4; -*- */
/* 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 SHARED_SURFACE_EGL_H_
#define SHARED_SURFACE_EGL_H_

#include "mozilla/Attributes.h"
#include "mozilla/Mutex.h"
#include "SharedSurface.h"

#ifdef MOZ_WIDGET_ANDROID
#  include "GeneratedJNIWrappers.h"
#  include "AndroidNativeWindow.h"
#endif

namespace mozilla {
namespace gl {

class GLContext;
class GLLibraryEGL;

class SharedSurface_EGLImage : public SharedSurface {
 public:
  static UniquePtr<SharedSurface_EGLImage> Create(GLContext* prodGL,
                                                  const GLFormats& formats,
                                                  const gfx::IntSize& size,
                                                  bool hasAlpha,
                                                  EGLContext context);

  static SharedSurface_EGLImage* Cast(SharedSurface* surf) {
    MOZ_ASSERT(surf->mType == SharedSurfaceType::EGLImageShare);

    return (SharedSurface_EGLImage*)surf;
  }

  static bool HasExtensions(GLLibraryEGL* egl, GLContext* gl);

 protected:
  mutable Mutex mMutex;
  const GLFormats mFormats;
  GLuint mProdTex;

 public:
  const EGLImage mImage;

 protected:
  EGLSync mSync;

  SharedSurface_EGLImage(GLContext* gl, const gfx::IntSize& size, bool hasAlpha,
                         const GLFormats& formats, GLuint prodTex,
                         EGLImage image);

  void UpdateProdTexture(const MutexAutoLock& curAutoLock);

 public:
  virtual ~SharedSurface_EGLImage();

  virtual layers::TextureFlags GetTextureFlags() const override {
    return layers::TextureFlags::DEALLOCATE_CLIENT;
  }

  virtual void LockProdImpl() override {}
  virtual void UnlockProdImpl() override {}

  virtual void ProducerAcquireImpl() override {}
  virtual void ProducerReleaseImpl() override;

  virtual void ProducerReadAcquireImpl() override;
  virtual void ProducerReadReleaseImpl() override{};

  virtual GLuint ProdTexture() override { return mProdTex; }

  // Implementation-specific functions below:
  // Returns texture and target
  virtual bool ToSurfaceDescriptor(
      layers::SurfaceDescriptor* const out_descriptor) override;

  virtual bool ReadbackBySharedHandle(
      gfx::DataSourceSurface* out_surface) override;
};

class SurfaceFactory_EGLImage : public SurfaceFactory {
 public:
  // Fallible:
  static UniquePtr<SurfaceFactory_EGLImage> Create(
      GLContext* prodGL, const SurfaceCaps& caps,
      const RefPtr<layers::LayersIPCChannel>& allocator,
      const layers::TextureFlags& flags);

 protected:
  const EGLContext mContext;

  SurfaceFactory_EGLImage(GLContext* prodGL, const SurfaceCaps& caps,
                          const RefPtr<layers::LayersIPCChannel>& allocator,
                          const layers::TextureFlags& flags, EGLContext context)
      : SurfaceFactory(SharedSurfaceType::EGLImageShare, prodGL, caps,
                       allocator, flags),
        mContext(context) {}

 public:
  virtual UniquePtr<SharedSurface> CreateShared(
      const gfx::IntSize& size) override {
    bool hasAlpha = mReadCaps.alpha;
    return SharedSurface_EGLImage::Create(mGL, mFormats, size, hasAlpha,
                                          mContext);
  }
};

#ifdef MOZ_WIDGET_ANDROID

class SharedSurface_SurfaceTexture : public SharedSurface {
 public:
  static UniquePtr<SharedSurface_SurfaceTexture> Create(
      GLContext* prodGL, const GLFormats& formats, const gfx::IntSize& size,
      bool hasAlpha, java::GeckoSurface::Param surface);

  static SharedSurface_SurfaceTexture* Cast(SharedSurface* surf) {
    MOZ_ASSERT(surf->mType == SharedSurfaceType::AndroidSurfaceTexture);

    return (SharedSurface_SurfaceTexture*)surf;
  }

  java::GeckoSurface::Param JavaSurface() { return mSurface; }

 protected:
  java::GeckoSurface::GlobalRef mSurface;
  EGLSurface mEglSurface;
  EGLSurface mOrigEglSurface;

  SharedSurface_SurfaceTexture(GLContext* gl, const gfx::IntSize& size,
                               bool hasAlpha, const GLFormats& formats,
                               java::GeckoSurface::Param surface,
                               EGLSurface eglSurface);

 public:
  virtual ~SharedSurface_SurfaceTexture();

  virtual layers::TextureFlags GetTextureFlags() const override {
    return layers::TextureFlags::DEALLOCATE_CLIENT;
  }

  virtual void LockProdImpl() override;
  virtual void UnlockProdImpl() override;

  virtual void ProducerAcquireImpl() override {}
  virtual void ProducerReleaseImpl() override {}

  virtual void ProducerReadAcquireImpl() override {}
  virtual void ProducerReadReleaseImpl() override {}

  // Implementation-specific functions below:
  // Returns texture and target
  virtual bool ToSurfaceDescriptor(
      layers::SurfaceDescriptor* const out_descriptor) override;

  virtual bool ReadbackBySharedHandle(
      gfx::DataSourceSurface* out_surface) override {
    return false;
  }

  virtual void Commit() override;

  virtual void WaitForBufferOwnership() override;

  virtual bool IsBufferAvailable() const override;
};

class SurfaceFactory_SurfaceTexture : public SurfaceFactory {
 public:
  // Fallible:
  static UniquePtr<SurfaceFactory_SurfaceTexture> Create(
      GLContext* prodGL, const SurfaceCaps& caps,
      const RefPtr<layers::LayersIPCChannel>& allocator,
      const layers::TextureFlags& flags);

 protected:
  SurfaceFactory_SurfaceTexture(
      GLContext* prodGL, const SurfaceCaps& caps,
      const RefPtr<layers::LayersIPCChannel>& allocator,
      const layers::TextureFlags& flags)
      : SurfaceFactory(SharedSurfaceType::AndroidSurfaceTexture, prodGL, caps,
                       allocator, flags) {}

 public:
  virtual UniquePtr<SharedSurface> CreateShared(
      const gfx::IntSize& size) override;
};

#endif  // MOZ_WIDGET_ANDROID

}  // namespace gl

} /* namespace mozilla */

#endif /* SHARED_SURFACE_EGL_H_ */