/* -*- 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_LAYERS_EFFECTS_H

#define MOZILLA_LAYERS_EFFECTS_H

#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc

#include "mozilla/RefPtr.h"             // for RefPtr, already_AddRefed, etc

#include "mozilla/gfx/Matrix.h"         // for Matrix4x4

#include "mozilla/gfx/Point.h"          // for IntSize

#include "mozilla/gfx/Rect.h"           // for Rect

#include "mozilla/gfx/Types.h"          // for SamplingFilter, etc

#include "mozilla/layers/CompositorTypes.h"  // for EffectTypes, etc

#include "mozilla/layers/LayersTypes.h"

#include "mozilla/layers/TextureHost.h"  // for CompositingRenderTarget, etc

#include "mozilla/mozalloc.h"           // for operator delete, etc

#include "nscore.h"                     // for nsACString

#include "mozilla/EnumeratedArray.h"

namespace mozilla {

namespace layers {

/**

 * Effects and effect chains are used by the compositor API (see Compositor.h).

 * An effect chain represents a rendering method, for example some shader and

 * the data required for that shader to run. An effect is some component of the

 * chain and its data.

 *

 * An effect chain consists of a primary effect - how the 'texture' memory should

 * be interpreted (RGBA, BGRX, YCBCR, etc.) - and any number of secondary effects

 * - any way in which rendering can be changed, e.g., applying a mask layer.

 *

 * During the rendering process, an effect chain is created by the layer being

 * rendered and the primary effect is added by the compositable host. Secondary

 * effects may be added by the layer or compositable. The effect chain is passed

 * to the compositor by the compositable host as a parameter to DrawQuad.

 */

struct TexturedEffect;

struct Effect

{

  NS_INLINE_DECL_REFCOUNTING(Effect)

  explicit Effect(EffectTypes aType) : mType(aType) {}

  EffectTypes mType;

  virtual TexturedEffect* AsTexturedEffect() { return nullptr; }

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) = 0;

protected:

  virtual ~Effect() {}

};

// Render from a texture

struct TexturedEffect : public Effect

{

  TexturedEffect(EffectTypes aType,

                 TextureSource *aTexture,

                 bool aPremultiplied,

                 gfx::SamplingFilter aSamplingFilter)

     : Effect(aType)

     , mTextureCoords(0, 0, 1.0f, 1.0f)

     , mTexture(aTexture)

     , mPremultiplied(aPremultiplied)

     , mSamplingFilter(aSamplingFilter)

  {}

  virtual TexturedEffect* AsTexturedEffect() override { return this; }

  virtual const char* Name() = 0;

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;

  gfx::Rect mTextureCoords;

  TextureSource* mTexture;

  bool mPremultiplied;

  gfx::SamplingFilter mSamplingFilter;

};

// Support an alpha mask.

struct EffectMask : public Effect

{

  EffectMask(TextureSource *aMaskTexture,

             gfx::IntSize aSize,

             const gfx::Matrix4x4 &aMaskTransform)

    : Effect(EffectTypes::MASK)

    , mMaskTexture(aMaskTexture)

    , mSize(aSize)

    , mMaskTransform(aMaskTransform)

  {}

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;

  TextureSource* mMaskTexture;

  gfx::IntSize mSize;

  gfx::Matrix4x4 mMaskTransform;

};

struct EffectBlendMode : public Effect

{

  explicit EffectBlendMode(gfx::CompositionOp aBlendMode)

    : Effect(EffectTypes::BLEND_MODE)

    , mBlendMode(aBlendMode)

  { }

  virtual const char* Name() { return "EffectBlendMode"; }

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;

  gfx::CompositionOp mBlendMode;

};

// Render to a render target rather than the screen.

struct EffectRenderTarget : public TexturedEffect

{

  explicit EffectRenderTarget(CompositingRenderTarget *aRenderTarget)

    : TexturedEffect(EffectTypes::RENDER_TARGET, aRenderTarget, true,

                     gfx::SamplingFilter::LINEAR)

    , mRenderTarget(aRenderTarget)

  {}

  virtual const char* Name() override { return "EffectRenderTarget"; }

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;

  RefPtr<CompositingRenderTarget> mRenderTarget;

protected:

  EffectRenderTarget(EffectTypes aType, CompositingRenderTarget *aRenderTarget)

    : TexturedEffect(aType, aRenderTarget, true, gfx::SamplingFilter::LINEAR)

    , mRenderTarget(aRenderTarget)

  {}

};

// Render to a render target rather than the screen.

struct EffectColorMatrix : public Effect

{

  explicit EffectColorMatrix(gfx::Matrix5x4 aMatrix)

    : Effect(EffectTypes::COLOR_MATRIX)

    , mColorMatrix(aMatrix)

  {}

  virtual const char* Name() { return "EffectColorMatrix"; }

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;

  const gfx::Matrix5x4 mColorMatrix;

};

struct EffectRGB : public TexturedEffect

{

  EffectRGB(TextureSource *aTexture,

            bool aPremultiplied,

            gfx::SamplingFilter aSamplingFilter,

            bool aFlipped = false)

    : TexturedEffect(EffectTypes::RGB, aTexture, aPremultiplied, aSamplingFilter)

  {}

  virtual const char* Name() override { return "EffectRGB"; }

};

struct EffectYCbCr : public TexturedEffect

{

  EffectYCbCr(TextureSource *aSource, YUVColorSpace aYUVColorSpace, uint32_t aBitDepth, gfx::SamplingFilter aSamplingFilter)

    : TexturedEffect(EffectTypes::YCBCR, aSource, false, aSamplingFilter)

    , mYUVColorSpace(aYUVColorSpace)

    , mBitDepth(aBitDepth)

  {}

  virtual const char* Name() override { return "EffectYCbCr"; }

  YUVColorSpace mYUVColorSpace;

  uint32_t mBitDepth;

};

struct EffectNV12 : public TexturedEffect

{

  EffectNV12(TextureSource *aSource, gfx::SamplingFilter aSamplingFilter)

    : TexturedEffect(EffectTypes::NV12, aSource, false, aSamplingFilter)

  {}

  virtual const char* Name() override { return "EffectNV12"; }

};

struct EffectComponentAlpha : public TexturedEffect

{

  EffectComponentAlpha(TextureSource *aOnBlack,

                       TextureSource *aOnWhite,

                       gfx::SamplingFilter aSamplingFilter)

    : TexturedEffect(EffectTypes::COMPONENT_ALPHA, nullptr, false, aSamplingFilter)

    , mOnBlack(aOnBlack)

    , mOnWhite(aOnWhite)

  {}

  virtual const char* Name() override { return "EffectComponentAlpha"; }

  TextureSource* mOnBlack;

  TextureSource* mOnWhite;

};

struct EffectSolidColor : public Effect

{

  explicit EffectSolidColor(const gfx::Color &aColor)

    : Effect(EffectTypes::SOLID_COLOR)

    , mColor(aColor)

  {}

  virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;

  gfx::Color mColor;

};

struct EffectChain

{

  EffectChain() : mLayerRef(nullptr) {}

  explicit EffectChain(void* aLayerRef) : mLayerRef(aLayerRef) {}

  RefPtr<Effect> mPrimaryEffect;

  EnumeratedArray<EffectTypes, EffectTypes::MAX_SECONDARY, RefPtr<Effect>>

    mSecondaryEffects;

  void* mLayerRef; //!< For LayerScope logging

};

/**

 * Create a Textured effect corresponding to aFormat and using

 * aSource as the (first) texture source.

 *

 * Note that aFormat can be different form aSource->GetFormat if, we are

 * creating an effect that takes several texture sources (like with YCBCR

 * where aFormat would be FOMRAT_YCBCR and each texture source would be

 * a one-channel A8 texture)

 */

inline already_AddRefed<TexturedEffect>

CreateTexturedEffect(gfx::SurfaceFormat aFormat,

                     TextureSource* aSource,

                     const gfx::SamplingFilter aSamplingFilter,

                     bool isAlphaPremultiplied)

{

  MOZ_ASSERT(aSource);

  RefPtr<TexturedEffect> result;

  switch (aFormat) {

  case gfx::SurfaceFormat::B8G8R8A8:

  case gfx::SurfaceFormat::B8G8R8X8:

  case gfx::SurfaceFormat::R8G8B8X8:

  case gfx::SurfaceFormat::R5G6B5_UINT16:

  case gfx::SurfaceFormat::R8G8B8A8:

    result = new EffectRGB(aSource, isAlphaPremultiplied, aSamplingFilter);

    break;

  case gfx::SurfaceFormat::NV12:

    result = new EffectNV12(aSource, aSamplingFilter);

    break;

  case gfx::SurfaceFormat::YUV:

    MOZ_ASSERT_UNREACHABLE("gfx::SurfaceFormat::YUV is invalid");

    break;

  default:

    NS_WARNING("unhandled program type");

    break;

  }

  return result.forget();

}

inline already_AddRefed<TexturedEffect>

CreateTexturedEffect(TextureHost* aHost,

                     TextureSource* aSource,

                     const gfx::SamplingFilter aSamplingFilter,

                     bool isAlphaPremultiplied)

{

  MOZ_ASSERT(aHost);

  MOZ_ASSERT(aSource);

  RefPtr<TexturedEffect> result;

  if (aHost->GetReadFormat() == gfx::SurfaceFormat::YUV) {

    MOZ_ASSERT(aHost->GetYUVColorSpace() != YUVColorSpace::UNKNOWN);

    result = new EffectYCbCr(

      aSource, aHost->GetYUVColorSpace(), aHost->GetBitDepth(), aSamplingFilter);

  } else {

    result = CreateTexturedEffect(aHost->GetReadFormat(),

                                  aSource,

                                  aSamplingFilter,

                                  isAlphaPremultiplied);

  }

  return result.forget();

}

/**

 * Create a textured effect based on aSource format and the presence of

 * aSourceOnWhite.

 *

 * aSourceOnWhite can be null.

 */

inline already_AddRefed<TexturedEffect>

CreateTexturedEffect(TextureSource* aSource,

                     TextureSource* aSourceOnWhite,

                     const gfx::SamplingFilter aSamplingFilter,

                     bool isAlphaPremultiplied)

{

  MOZ_ASSERT(aSource);

  if (aSourceOnWhite) {

    MOZ_ASSERT(aSource->GetFormat() == gfx::SurfaceFormat::R8G8B8X8 ||

               aSource->GetFormat() == gfx::SurfaceFormat::B8G8R8X8);

    MOZ_ASSERT(aSource->GetFormat() == aSourceOnWhite->GetFormat());

    return MakeAndAddRef<EffectComponentAlpha>(aSource, aSourceOnWhite,

                                               aSamplingFilter);

  }

  return CreateTexturedEffect(aSource->GetFormat(),

                              aSource,

                              aSamplingFilter,

                              isAlphaPremultiplied);

}

/**

 * Create a textured effect based on aSource format.

 *

 * This version excudes the possibility of component alpha.

 */

inline already_AddRefed<TexturedEffect>

CreateTexturedEffect(TextureSource *aTexture,

                     const gfx::SamplingFilter aSamplingFilter)

{

  return CreateTexturedEffect(aTexture, nullptr, aSamplingFilter, true);

}

} // namespace layers

} // namespace mozilla

#endif