1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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_GFX_IMAGEHOST_H
#define MOZILLA_GFX_IMAGEHOST_H
#include <stdio.h> // for FILE
#include "CompositableHost.h" // for CompositableHost
#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, etc
#include "mozilla/mozalloc.h" // for operator delete
#include "nsCOMPtr.h" // for already_AddRefed
#include "nsRect.h" // for mozilla::gfx::IntRect
#include "nsRegionFwd.h" // for nsIntRegion
#include "nscore.h" // for nsACString
namespace mozilla {
namespace layers {
class Compositor;
struct EffectChain;
class ImageContainerParent;
class ImageHostOverlay;
/**
* ImageHost. Works with ImageClientSingle and ImageClientBuffered
*/
class ImageHost : public CompositableHost
{
public:
explicit ImageHost(const TextureInfo& aTextureInfo);
~ImageHost();
virtual CompositableType GetType() override { return mTextureInfo.mCompositableType; }
virtual void Composite(LayerComposite* aLayer,
EffectChain& aEffectChain,
float aOpacity,
const gfx::Matrix4x4& aTransform,
const gfx::SamplingFilter aSamplingFilter,
const gfx::IntRect& aClipRect,
const nsIntRegion* aVisibleRegion = nullptr) override;
virtual void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override;
virtual void RemoveTextureHost(TextureHost* aTexture) override;
virtual void UseOverlaySource(OverlaySource aOverlay,
const gfx::IntRect& aPictureRect) override;
virtual TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) override;
virtual void Attach(Layer* aLayer,
Compositor* aCompositor,
AttachFlags aFlags = NO_FLAGS) override;
virtual void SetCompositor(Compositor* aCompositor) override;
virtual void SetImageContainer(ImageContainerParent* aImageContainer) override;
gfx::IntSize GetImageSize() const override;
virtual LayerRenderState GetRenderState() override;
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
virtual void Dump(std::stringstream& aStream,
const char* aPrefix = "",
bool aDumpHtml = false) override;
virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
virtual bool Lock() override;
virtual void Unlock() override;
virtual already_AddRefed<TexturedEffect> GenEffect(const gfx::SamplingFilter aSamplingFilter) override;
void SetCurrentTextureHost(TextureHost* aTexture);
virtual void CleanupResources() override;
int32_t GetFrameID()
{
const TimedImage* img = ChooseImage();
return img ? img->mFrameID : -1;
}
int32_t GetProducerID()
{
const TimedImage* img = ChooseImage();
return img ? img->mProducerID : -1;
}
int32_t GetLastFrameID() const { return mLastFrameID; }
int32_t GetLastProducerID() const { return mLastProducerID; }
enum Bias {
// Don't apply bias to frame times
BIAS_NONE,
// Apply a negative bias to frame times to keep them before the vsync time
BIAS_NEGATIVE,
// Apply a positive bias to frame times to keep them after the vsync time
BIAS_POSITIVE,
};
bool IsOpaque();
protected:
struct TimedImage {
CompositableTextureHostRef mTextureHost;
TimeStamp mTimeStamp;
gfx::IntRect mPictureRect;
int32_t mFrameID;
int32_t mProducerID;
};
// Use a simple RefPtr because the same texture is already held by a
// a CompositableTextureHostRef in the array of TimedImage.
// See the comment in CompositableTextureRef for more details.
RefPtr<TextureHost> mCurrentTextureHost;
CompositableTextureSourceRef mCurrentTextureSource;
// When doing texture uploads it's best to alternate between two (or three)
// texture sources so that the texture we upload to isn't being used by
// the GPU to composite the previous frame.
RefPtr<TextureSource> mExtraTextureSource;
/**
* ChooseImage is guaranteed to return the same TimedImage every time it's
* called during the same composition, up to the end of Composite() ---
* it depends only on mImages, mCompositor->GetCompositionTime(), and mBias.
* mBias is updated at the end of Composite().
*/
const TimedImage* ChooseImage() const;
TimedImage* ChooseImage();
int ChooseImageIndex() const;
nsTArray<TimedImage> mImages;
// Weak reference, will be null if mImageContainer has been destroyed.
ImageContainerParent* mImageContainer;
int32_t mLastFrameID;
int32_t mLastProducerID;
/**
* Bias to apply to the next frame.
*/
Bias mBias;
bool mLocked;
RefPtr<ImageHostOverlay> mImageHostOverlay;
};
/**
* ImageHostOverlay handles OverlaySource compositing
*/
class ImageHostOverlay {
protected:
virtual ~ImageHostOverlay();
public:
NS_INLINE_DECL_REFCOUNTING(ImageHostOverlay)
ImageHostOverlay();
static bool IsValid(OverlaySource aOverlay);
void SetCompositor(Compositor* aCompositor);
virtual void Composite(Compositor* aCompositor,
uint32_t aFlashCounter,
LayerComposite* aLayer,
EffectChain& aEffectChain,
float aOpacity,
const gfx::Matrix4x4& aTransform,
const gfx::SamplingFilter aSamplingFilter,
const gfx::IntRect& aClipRect,
const nsIntRegion* aVisibleRegion);
virtual LayerRenderState GetRenderState();
virtual void UseOverlaySource(OverlaySource aOverlay,
const gfx::IntRect& aPictureRect);
virtual gfx::IntSize GetImageSize() const;
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
protected:
RefPtr<Compositor> mCompositor;
gfx::IntRect mPictureRect;
OverlaySource mOverlay;
};
} // namespace layers
} // namespace mozilla
#endif
|
