Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #ifndef MOZILLA_GFX_WEBRENDERCOMPOSITABLE_HOLDER_H
       7             : #define MOZILLA_GFX_WEBRENDERCOMPOSITABLE_HOLDER_H
       8             : 
       9             : #include <queue>
      10             : 
      11             : #include "mozilla/gfx/Point.h"
      12             : #include "mozilla/layers/TextureHost.h"
      13             : #include "mozilla/Maybe.h"
      14             : #include "mozilla/webrender/WebRenderTypes.h"
      15             : #include "nsClassHashtable.h"
      16             : 
      17             : namespace mozilla {
      18             : 
      19             : namespace wr {
      20             : class DisplayListBuilder;
      21             : class WebRenderAPI;
      22             : }
      23             : 
      24             : namespace layers {
      25             : 
      26             : class CompositableHost;
      27             : class CompositorVsyncScheduler;
      28             : class WebRenderImageHost;
      29             : class WebRenderTextureHost;
      30             : 
      31             : class WebRenderCompositableHolder final
      32             : {
      33             : public:
      34           0 :   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderCompositableHolder)
      35             : 
      36             :   explicit WebRenderCompositableHolder(uint32_t aIdNamespace);
      37             : 
      38             : protected:
      39             :   ~WebRenderCompositableHolder();
      40             : 
      41             : public:
      42             :   void Destroy(wr::WebRenderAPI* aApi);
      43             :   bool HasKeysToDelete();
      44             : 
      45             :   void AddPipeline(const wr::PipelineId& aPipelineId);
      46             :   void RemovePipeline(const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch);
      47             : 
      48             :   void HoldExternalImage(const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch, WebRenderTextureHost* aTexture);
      49             :   void Update(const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch);
      50             : 
      51           0 :   TimeStamp GetCompositionTime() const {
      52           0 :     return mCompositionTime;
      53             :   }
      54           0 :   void SetCompositionTime(TimeStamp aTimeStamp) {
      55           0 :     mCompositionTime = aTimeStamp;
      56           0 :     if (!mCompositionTime.IsNull() && !mCompositeUntilTime.IsNull() &&
      57           0 :         mCompositionTime >= mCompositeUntilTime) {
      58           0 :       mCompositeUntilTime = TimeStamp();
      59             :     }
      60           0 :   }
      61           0 :   void CompositeUntil(TimeStamp aTimeStamp) {
      62           0 :     if (mCompositeUntilTime.IsNull() ||
      63           0 :         mCompositeUntilTime < aTimeStamp) {
      64           0 :       mCompositeUntilTime = aTimeStamp;
      65             :     }
      66           0 :   }
      67           0 :   TimeStamp GetCompositeUntilTime() const {
      68           0 :     return mCompositeUntilTime;
      69             :   }
      70             : 
      71             :   void AddAsyncImagePipeline(const wr::PipelineId& aPipelineId, WebRenderImageHost* aImageHost);
      72             :   void RemoveAsyncImagePipeline(wr::WebRenderAPI* aApi, const wr::PipelineId& aPipelineId);
      73             : 
      74             :   void UpdateAsyncImagePipeline(const wr::PipelineId& aPipelineId,
      75             :                                 const LayerRect& aScBounds,
      76             :                                 const gfx::Matrix4x4& aScTransform,
      77             :                                 const gfx::MaybeIntSize& aScaleToSize,
      78             :                                 const WrImageRendering& aFilter,
      79             :                                 const WrMixBlendMode& aMixBlendMode);
      80             :   void ApplyAsyncImages(wr::WebRenderAPI* aApi);
      81             : 
      82             : private:
      83             :   void DeleteOldAsyncImages(wr::WebRenderAPI* aApi);
      84             : 
      85           0 :   uint32_t GetNextResourceId() { return ++mResourceId; }
      86           0 :   uint32_t GetNamespace() { return mIdNamespace; }
      87           0 :   wr::ImageKey GetImageKey()
      88             :   {
      89             :     wr::ImageKey key;
      90           0 :     key.mNamespace = GetNamespace();
      91           0 :     key.mHandle = GetNextResourceId();
      92           0 :     return key;
      93             :   }
      94             :   bool GetImageKeyForTextureHost(wr::WebRenderAPI* aApi, TextureHost* aTexture, nsTArray<wr::ImageKey>& aKeys);
      95             : 
      96           0 :   struct ForwardingTextureHost {
      97           0 :     ForwardingTextureHost(const wr::Epoch& aEpoch, TextureHost* aTexture)
      98           0 :       : mEpoch(aEpoch)
      99           0 :       , mTexture(aTexture)
     100           0 :     {}
     101             :     wr::Epoch mEpoch;
     102             :     CompositableTextureHostRef mTexture;
     103             :   };
     104             : 
     105           0 :   struct PipelineTexturesHolder {
     106             :     // Holds forwarding WebRenderTextureHosts.
     107             :     std::queue<ForwardingTextureHost> mTextureHosts;
     108             :     Maybe<wr::Epoch> mDestroyedEpoch;
     109             :   };
     110             : 
     111           0 :   struct AsyncImagePipelineHolder {
     112             :     AsyncImagePipelineHolder();
     113             : 
     114             :     bool mInitialised;
     115             :     bool mIsChanged;
     116             :     bool mUseExternalImage;
     117             :     LayerRect mScBounds;
     118             :     gfx::Matrix4x4 mScTransform;
     119             :     gfx::MaybeIntSize mScaleToSize;
     120             :     WrImageRendering mFilter;
     121             :     WrMixBlendMode mMixBlendMode;
     122             :     RefPtr<WebRenderImageHost> mImageHost;
     123             :     CompositableTextureHostRef mCurrentTexture;
     124             :     nsTArray<wr::ImageKey> mKeys;
     125             :   };
     126             : 
     127             :   bool UpdateImageKeys(wr::WebRenderAPI* aApi,
     128             :                        bool& aUseExternalImage,
     129             :                        AsyncImagePipelineHolder* aHolder,
     130             :                        nsTArray<wr::ImageKey>& aKeys,
     131             :                        nsTArray<wr::ImageKey>& aKeysToDelete);
     132             : 
     133             :   uint32_t mIdNamespace;
     134             :   uint32_t mResourceId;
     135             : 
     136             :   nsClassHashtable<nsUint64HashKey, PipelineTexturesHolder> mPipelineTexturesHolders;
     137             :   nsClassHashtable<nsUint64HashKey, AsyncImagePipelineHolder> mAsyncImagePipelineHolders;
     138             :   uint32_t mAsyncImageEpoch;
     139             :   nsTArray<wr::ImageKey> mKeysToDelete;
     140             :   bool mDestroyed;
     141             : 
     142             :   // Render time for the current composition.
     143             :   TimeStamp mCompositionTime;
     144             : 
     145             :   // When nonnull, during rendering, some compositable indicated that it will
     146             :   // change its rendering at this time. In order not to miss it, we composite
     147             :   // on every vsync until this time occurs (this is the latest such time).
     148             :   TimeStamp mCompositeUntilTime;
     149             : };
     150             : 
     151             : } // namespace layers
     152             : } // namespace mozilla
     153             : 
     154             : #endif /* MOZILLA_GFX_WEBRENDERCOMPOSITABLE_HOLDER_H */