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

#define GFX_TILEDCONTENTHOST_H

#include <stdint.h>                     // for uint16_t

#include <stdio.h>                      // for FILE

#include <algorithm>                    // for swap

#include "ContentHost.h"                // for ContentHost

#include "TiledLayerBuffer.h"           // for TiledLayerBuffer, etc

#include "CompositableHost.h"

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

#include "mozilla/Attributes.h"         // for override

#include "mozilla/RefPtr.h"             // for RefPtr

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

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

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

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

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

#include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor

#include "mozilla/layers/LayersTypes.h"  // for LayerRenderState, etc

#include "mozilla/layers/TextureHost.h"  // for TextureHost

#include "mozilla/layers/TextureClient.h"

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

#include "nsRegion.h"                   // for nsIntRegion

#include "nscore.h"                     // for nsACString

namespace mozilla {

namespace layers {

class Compositor;

class ISurfaceAllocator;

class Layer;

class ThebesBufferData;

class TextureReadLock;

struct EffectChain;

class TileHost {

public:

  // Constructs a placeholder TileHost. See the comments above

  // TiledLayerBuffer for more information on what this is used for;

  // essentially, this is a sentinel used to represent an invalid or blank

  // tile.

  TileHost()

  {}

  // Constructs a TileHost from a TextureReadLock and TextureHost.

  TileHost(TextureReadLock* aSharedLock,

               TextureHost* aTextureHost,

               TextureHost* aTextureHostOnWhite,

               TextureSource* aSource,

               TextureSource* aSourceOnWhite)

    : mTextureHost(aTextureHost)

    , mTextureHostOnWhite(aTextureHostOnWhite)

    , mTextureSource(aSource)

    , mTextureSourceOnWhite(aSourceOnWhite)

  {}

  TileHost(const TileHost& o) {

    mTextureHost = o.mTextureHost;

    mTextureHostOnWhite = o.mTextureHostOnWhite;

    mTextureSource = o.mTextureSource;

    mTextureSourceOnWhite = o.mTextureSourceOnWhite;

    mTileCoord = o.mTileCoord;

  }

  TileHost& operator=(const TileHost& o) {

    if (this == &o) {

      return *this;

    }

    mTextureHost = o.mTextureHost;

    mTextureHostOnWhite = o.mTextureHostOnWhite;

    mTextureSource = o.mTextureSource;

    mTextureSourceOnWhite = o.mTextureSourceOnWhite;

    mTileCoord = o.mTileCoord;

    return *this;

  }

  bool operator== (const TileHost& o) const {

    return mTextureHost == o.mTextureHost;

  }

  bool operator!= (const TileHost& o) const {

    return mTextureHost != o.mTextureHost;

  }

  bool IsPlaceholderTile() const { return mTextureHost == nullptr; }

  void Dump(std::stringstream& aStream) {

    aStream << "TileHost(...)"; // fill in as needed

  }

  void DumpTexture(std::stringstream& aStream, TextureDumpMode /* aCompress, ignored for host tiles */) {

    // TODO We should combine the OnWhite/OnBlack here an just output a single image.

    CompositableHost::DumpTextureHost(aStream, mTextureHost);

  }

  RefPtr<TextureSource> AcquireTextureSource() const;

  RefPtr<TextureSource> AcquireTextureSourceOnWhite() const;

  /**

   * This does a linear tween of the passed opacity (which is assumed

   * to be between 0.0 and 1.0). The duration of the fade is controlled

   * by the 'layers.tiles.fade-in.duration-ms' preference. It is enabled

   * via 'layers.tiles.fade-in.enabled'

   */

  float GetFadeInOpacity(float aOpacity);

  CompositableTextureHostRef mTextureHost;

  CompositableTextureHostRef mTextureHostOnWhite;

  mutable CompositableTextureSourceRef mTextureSource;

  mutable CompositableTextureSourceRef mTextureSourceOnWhite;

  // This is not strictly necessary but makes debugging whole lot easier.

  TileCoordIntPoint mTileCoord;

  TimeStamp mFadeStart;

};

class TiledLayerBufferComposite

  : public TiledLayerBuffer<TiledLayerBufferComposite, TileHost>

{

  friend class TiledLayerBuffer<TiledLayerBufferComposite, TileHost>;

public:

  TiledLayerBufferComposite();

  ~TiledLayerBufferComposite();

  bool UseTiles(const SurfaceDescriptorTiles& aTileDescriptors,

                HostLayerManager* aLayerManager,

                ISurfaceAllocator* aAllocator);

  void Clear();

  TileHost GetPlaceholderTile() const { return TileHost(); }

  // Stores the absolute resolution of the containing frame, calculated

  // by the sum of the resolutions of all parent layers' FrameMetrics.

  const CSSToParentLayerScale2D& GetFrameResolution() { return mFrameResolution; }

  void SetTextureSourceProvider(TextureSourceProvider* aProvider);

  void AddAnimationInvalidation(nsIntRegion& aRegion);

protected:

  CSSToParentLayerScale2D mFrameResolution;

};

/**

 * ContentHost for tiled PaintedLayers. Since tiled layers are special snow

 * flakes, we have a unique update process. All the textures that back the

 * tiles are added in the usual way, but Updated is called on the host side

 * in response to a message that describes the transaction for every tile.

 * Composition happens in the normal way.

 *

 * TiledContentHost has a TiledLayerBufferComposite which keeps hold of the tiles.

 * Each tile has a reference to a texture host. During the layers transaction, we

 * receive a list of descriptors for the client-side tile buffer tiles

 * (UseTiledLayerBuffer). If we receive two transactions before a composition,

 * we immediately unlock and discard the unused buffer.

 *

 * When the content host is composited, we first validate the TiledLayerBuffer

 * (Upload), which calls Updated on each tile's texture host to make sure the

 * texture data has been uploaded. For single-buffered tiles, we unlock at this

 * point, for double-buffered tiles we unlock and discard the last composited

 * buffer after compositing a new one. Rendering takes us to RenderTile which

 * is similar to Composite for non-tiled ContentHosts.

 */

class TiledContentHost : public ContentHost

{

public:

  explicit TiledContentHost(const TextureInfo& aTextureInfo);

protected:

  ~TiledContentHost();

public:

  // Generate effect for layerscope when using hwc.

  virtual already_AddRefed<TexturedEffect> GenEffect(const gfx::SamplingFilter aSamplingFilter) override;

  virtual bool UpdateThebes(const ThebesBufferData& aData,

                            const nsIntRegion& aUpdated,

                            const nsIntRegion& aOldValidRegionBack) override

  {

    NS_ERROR("N/A for tiled layers");

    return false;

  }

  const nsIntRegion& GetValidLowPrecisionRegion() const

  {

    return mLowPrecisionTiledBuffer.GetValidRegion();

  }

  const nsIntRegion& GetValidRegion() const

  {

    return mTiledBuffer.GetValidRegion();

  }

  virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) override

  {

    CompositableHost::SetTextureSourceProvider(aProvider);

    mTiledBuffer.SetTextureSourceProvider(aProvider);

    mLowPrecisionTiledBuffer.SetTextureSourceProvider(aProvider);

  }

  bool UseTiledLayerBuffer(ISurfaceAllocator* aAllocator,

                           const SurfaceDescriptorTiles& aTiledDescriptor);

  virtual void Composite(Compositor* aCompositor,

                         LayerComposite* aLayer,

                         EffectChain& aEffectChain,

                         float aOpacity,

                         const gfx::Matrix4x4& aTransform,

                         const gfx::SamplingFilter aSamplingFilter,

                         const gfx::IntRect& aClipRect,

                         const nsIntRegion* aVisibleRegion = nullptr,

                         const Maybe<gfx::Polygon>& aGeometry = Nothing()) override;

  virtual CompositableType GetType() override { return CompositableType::CONTENT_TILED; }

  virtual TiledContentHost* AsTiledContentHost() override { return this; }

  virtual void Attach(Layer* aLayer,

                      TextureSourceProvider* aProvider,

                      AttachFlags aFlags = NO_FLAGS) override;

  virtual void Detach(Layer* aLayer = nullptr,

                      AttachFlags aFlags = NO_FLAGS) override;

  virtual void Dump(std::stringstream& aStream,

                    const char* aPrefix="",

                    bool aDumpHtml=false) override;

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

  virtual void AddAnimationInvalidation(nsIntRegion& aRegion) override;

  TiledLayerBufferComposite& GetLowResBuffer() {

    return mLowPrecisionTiledBuffer;

  }

  TiledLayerBufferComposite& GetHighResBuffer() {

    return mTiledBuffer;

  }

private:

  void RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,

                         Compositor* aCompositor,

                         const gfx::Color* aBackgroundColor,

                         EffectChain& aEffectChain,

                         float aOpacity,

                         const gfx::SamplingFilter aSamplingFilter,

                         const gfx::IntRect& aClipRect,

                         nsIntRegion aMaskRegion,

                         gfx::Matrix4x4 aTransform,

                         const Maybe<gfx::Polygon>& aGeometry);

  // Renders a single given tile.

  void RenderTile(TileHost& aTile,

                  Compositor* aCompositor,

                  EffectChain& aEffectChain,

                  float aOpacity,

                  const gfx::Matrix4x4& aTransform,

                  const gfx::SamplingFilter aSamplingFilter,

                  const gfx::IntRect& aClipRect,

                  const nsIntRegion& aScreenRegion,

                  const gfx::IntPoint& aTextureOffset,

                  const gfx::IntSize& aTextureBounds,

                  const gfx::Rect& aVisibleRect,

                  const Maybe<gfx::Polygon>& aGeometry);

  void EnsureTileStore() {}

  TiledLayerBufferComposite    mTiledBuffer;

  TiledLayerBufferComposite    mLowPrecisionTiledBuffer;

};

} // namespace layers

} // namespace mozilla

#endif