gecko-dev/gfx/gl/GLBlitHelper.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim: set ts=8 sts=4 et sw=4 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 GLBLITHELPER_H_
#define GLBLITHELPER_H_

#include "GLContextTypes.h"
#include "GLConsts.h"
#include "nsSize.h"
#include "ipc/IPCMessageUtils.h"
#include "mozilla/Attributes.h"
#include "mozilla/gfx/Point.h"
#include "../layers/ImageTypes.h"

#ifdef XP_WIN
#include <windows.h>
#endif

namespace mozilla {

namespace layers {
class D3D11YCbCrImage;
class Image;
class GPUVideoImage;
class PlanarYCbCrImage;
class SurfaceTextureImage;
class MacIOSurfaceImage;
class SurfaceDescriptorD3D10;
class SurfaceDescriptorDXGIYCbCr;
} // namespace layers

namespace gl {

class BindAnglePlanes;
class GLContext;
class GLBlitHelper;

bool
GuessDivisors(const gfx::IntSize& ySize, const gfx::IntSize& uvSize,
              gfx::IntSize* const out_divisors);

template<uint8_t N>
struct Mat
{
    float m[N*N]; // column-major, for GL

    float& at(const uint8_t x, const uint8_t y) {
        return m[N*x+y];
    }

    static Mat<N> Zero();
    static Mat<N> I();

    Mat<N> operator*(const Mat<N>& r) const;
};
typedef Mat<3> Mat3;

Mat3 SubRectMat3(float x, float y, float w, float h);
Mat3 SubRectMat3(const gfx::IntRect& subrect, const gfx::IntSize& size);
Mat3 SubRectMat3(const gfx::IntRect& bigSubrect, const gfx::IntSize& smallSize,
                 const gfx::IntSize& divisors);

class DrawBlitProg final
{
    const GLBlitHelper& mParent;
    const GLuint mProg;
    const GLint mLoc_uDestMatrix;
    const GLint mLoc_uTexMatrix0;
    const GLint mLoc_uTexMatrix1;
    const GLint mLoc_uColorMatrix;
    GLenum mType_uColorMatrix = 0;

public:
    struct Key final {
        const char* const fragHeader;
        const char* const fragBody;

        bool operator <(const Key& x) const {
            if (fragHeader != x.fragHeader)
                return fragHeader < x.fragHeader;
            return fragBody < x.fragBody;
        }
    };

    DrawBlitProg(const GLBlitHelper* parent, GLuint prog);
    ~DrawBlitProg();

    struct BaseArgs final {
        Mat3 texMatrix0;
        bool yFlip;
        gfx::IntSize destSize; // Always needed for (at least) setting the viewport.
        Maybe<gfx::IntRect> destRect;
    };
    struct YUVArgs final {
        Mat3 texMatrix1;
        YUVColorSpace colorSpace;
    };

    void Draw(const BaseArgs& args, const YUVArgs* argsYUV = nullptr) const;
};

class ScopedSaveMultiTex final
{
    GLContext& mGL;
    const uint8_t mTexCount;
    const GLenum mTexTarget;
    const GLuint mOldTexUnit;
    GLuint mOldTexSampler[3];
    GLuint mOldTex[3];

public:
    ScopedSaveMultiTex(GLContext* gl, uint8_t texCount, GLenum texTarget);
    ~ScopedSaveMultiTex();
};

/** Buffer blitting helper */
class GLBlitHelper final
{
    friend class BindAnglePlanes;
    friend class DrawBlitProg;
    friend class GLContext;

    GLContext* const mGL;
    mutable std::map<DrawBlitProg::Key, const DrawBlitProg*> mDrawBlitProgs;

    GLuint mQuadVAO = 0;
    GLuint mQuadVBO = 0;
    nsCString mDrawBlitProg_VersionLine;
    const GLuint mDrawBlitProg_VertShader;

    GLuint mYuvUploads[3] = {};
    gfx::IntSize mYuvUploads_YSize = {0,0};
    gfx::IntSize mYuvUploads_UVSize = {0,0};

#ifdef XP_WIN
    mutable RefPtr<ID3D11Device> mD3D11;

    ID3D11Device* GetD3D11() const;
#endif

    const DrawBlitProg* GetDrawBlitProg(const DrawBlitProg::Key& key) const;
private:
    const DrawBlitProg* CreateDrawBlitProg(const DrawBlitProg::Key& key) const;
public:

    bool BlitImage(layers::PlanarYCbCrImage* yuvImage, const gfx::IntSize& destSize,
                   OriginPos destOrigin);
#ifdef MOZ_WIDGET_ANDROID
    // Blit onto the current FB.
    bool BlitImage(layers::SurfaceTextureImage* stImage, const gfx::IntSize& destSize,
                   OriginPos destOrigin) const;
#endif
#ifdef XP_MACOSX
    bool BlitImage(layers::MacIOSurfaceImage* srcImage, const gfx::IntSize& destSize,
                   OriginPos destOrigin) const;
#endif

    explicit GLBlitHelper(GLContext* gl);
public:
    ~GLBlitHelper();

    void BlitFramebuffer(const gfx::IntSize& srcSize,
                         const gfx::IntSize& destSize,
                         GLuint filter = LOCAL_GL_NEAREST) const;
    void BlitFramebufferToFramebuffer(GLuint srcFB, GLuint destFB,
                                      const gfx::IntSize& srcSize,
                                      const gfx::IntSize& destSize,
                                      GLuint filter = LOCAL_GL_NEAREST) const;
    void BlitFramebufferToTexture(GLuint destTex, const gfx::IntSize& srcSize,
                                  const gfx::IntSize& destSize,
                                  GLenum destTarget = LOCAL_GL_TEXTURE_2D) const;
    void BlitTextureToFramebuffer(GLuint srcTex, const gfx::IntSize& srcSize,
                                  const gfx::IntSize& destSize,
                                  GLenum srcTarget = LOCAL_GL_TEXTURE_2D) const;
    void BlitTextureToTexture(GLuint srcTex, GLuint destTex,
                              const gfx::IntSize& srcSize,
                              const gfx::IntSize& destSize,
                              GLenum srcTarget = LOCAL_GL_TEXTURE_2D,
                              GLenum destTarget = LOCAL_GL_TEXTURE_2D) const;


    void DrawBlitTextureToFramebuffer(GLuint srcTex, const gfx::IntSize& srcSize,
                                      const gfx::IntSize& destSize,
                                      GLenum srcTarget = LOCAL_GL_TEXTURE_2D) const;

    bool BlitImageToFramebuffer(layers::Image* srcImage, const gfx::IntSize& destSize,
                                OriginPos destOrigin);

private:
#ifdef XP_WIN
    // GLBlitHelperD3D.cpp:
    bool BlitImage(layers::GPUVideoImage* srcImage, const gfx::IntSize& destSize,
                   OriginPos destOrigin) const;
    bool BlitImage(layers::D3D11YCbCrImage* srcImage, const gfx::IntSize& destSize,
                   OriginPos destOrigin) const;

    bool BlitDescriptor(const layers::SurfaceDescriptorD3D10& desc,
                        const gfx::IntSize& destSize, OriginPos destOrigin) const;

    bool BlitAngleYCbCr(const WindowsHandle (&handleList)[3],
                        const gfx::IntRect& clipRect,
                        const gfx::IntSize& ySize, const gfx::IntSize& uvSize,
                        const YUVColorSpace colorSpace, const gfx::IntSize& destSize,
                        OriginPos destOrigin) const;

    bool BlitAnglePlanes(uint8_t numPlanes, const RefPtr<ID3D11Texture2D>* texD3DList,
                         const DrawBlitProg* prog, const DrawBlitProg::BaseArgs& baseArgs,
                         const DrawBlitProg::YUVArgs* const yuvArgs) const;
#endif
};

extern const char* const kFragHeader_Tex2D;
extern const char* const kFragHeader_Tex2DRect;
extern const char* const kFragHeader_TexExt;
extern const char* const kFragBody_RGBA;
extern const char* const kFragBody_CrYCb;
extern const char* const kFragBody_NV12;
extern const char* const kFragBody_PlanarYUV;

} // namespace gl
} // namespace mozilla

#endif // GLBLITHELPER_H_