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
|
/*
* Copyright (C) 2019 Igalia S.L
* Copyright (C) 2019 Metrological Group B.V.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* aint with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "MediaPlayerPrivateHolePunch.h"
#if USE(EXTERNAL_HOLEPUNCH)
#include "MediaPlayer.h"
#include "TextureMapperPlatformLayerBuffer.h"
#include "TextureMapperPlatformLayerProxyGL.h"
namespace WebCore {
static const FloatSize s_holePunchDefaultFrameSize(1280, 720);
MediaPlayerPrivateHolePunch::MediaPlayerPrivateHolePunch(MediaPlayer* player)
: m_player(player)
, m_readyTimer(RunLoop::main(), this, &MediaPlayerPrivateHolePunch::notifyReadyState)
, m_networkState(MediaPlayer::NetworkState::Empty)
#if USE(NICOSIA)
, m_nicosiaLayer(Nicosia::ContentLayer::create(Nicosia::ContentLayerTextureMapperImpl::createFactory(*this)))
#else
, m_platformLayerProxy(adoptRef(new TextureMapperPlatformLayerProxyGL))
#endif
{
pushNextHolePunchBuffer();
// Delay the configuration of the HTMLMediaElement, as during this stage this is not
// the MediaPlayer private yet and calls from HTMLMediaElement won't reach this.
m_readyTimer.startOneShot(0_s);
}
MediaPlayerPrivateHolePunch::~MediaPlayerPrivateHolePunch()
{
#if USE(NICOSIA)
downcast<Nicosia::ContentLayerTextureMapperImpl>(m_nicosiaLayer->impl()).invalidateClient();
#endif
}
PlatformLayer* MediaPlayerPrivateHolePunch::platformLayer() const
{
#if USE(NICOSIA)
return m_nicosiaLayer.ptr();
#else
return const_cast<MediaPlayerPrivateHolePunch*>(this);
#endif
}
FloatSize MediaPlayerPrivateHolePunch::naturalSize() const
{
// When using the holepuch we may not be able to get the video frames size, so we can't use
// it. But we need to report some non empty naturalSize for the player's GraphicsLayer
// to be properly created.
return s_holePunchDefaultFrameSize;
}
void MediaPlayerPrivateHolePunch::pushNextHolePunchBuffer()
{
auto proxyOperation =
[this](TextureMapperPlatformLayerProxyGL& proxy)
{
Locker locker { proxy.lock() };
std::unique_ptr<TextureMapperPlatformLayerBuffer> layerBuffer = makeUnique<TextureMapperPlatformLayerBuffer>(0, m_size, TextureMapperGL::ShouldNotBlend, GL_DONT_CARE);
proxy.pushNextBuffer(WTFMove(layerBuffer));
};
#if USE(NICOSIA)
auto& proxy = downcast<Nicosia::ContentLayerTextureMapperImpl>(m_nicosiaLayer->impl()).proxy();
ASSERT(is<TextureMapperPlatformLayerProxyGL>(proxy));
proxyOperation(downcast<TextureMapperPlatformLayerProxyGL>(proxy));
#else
proxyOperation(*m_platformLayerProxy);
#endif
}
void MediaPlayerPrivateHolePunch::swapBuffersIfNeeded()
{
pushNextHolePunchBuffer();
}
#if !USE(NICOSIA)
RefPtr<TextureMapperPlatformLayerProxy> MediaPlayerPrivateHolePunch::proxy() const
{
return m_platformLayerProxy.copyRef();
}
#endif
static HashSet<String, ASCIICaseInsensitiveHash>& mimeTypeCache()
{
static NeverDestroyed<HashSet<String, ASCIICaseInsensitiveHash>> cache;
static bool typeListInitialized = false;
if (typeListInitialized)
return cache;
const ASCIILiteral mimeTypes[] = {
"video/holepunch"_s
};
for (unsigned i = 0; i < (sizeof(mimeTypes) / sizeof(*mimeTypes)); ++i)
cache.get().add(mimeTypes[i]);
typeListInitialized = true;
return cache;
}
void MediaPlayerPrivateHolePunch::getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types)
{
types = mimeTypeCache();
}
MediaPlayer::SupportsType MediaPlayerPrivateHolePunch::supportsType(const MediaEngineSupportParameters& parameters)
{
auto containerType = parameters.type.containerType();
// Spec says we should not return "probably" if the codecs string is empty.
if (!containerType.isEmpty() && mimeTypeCache().contains(containerType)) {
if (parameters.type.codecs().isEmpty())
return MediaPlayer::SupportsType::MayBeSupported;
return MediaPlayer::SupportsType::IsSupported;
}
return MediaPlayer::SupportsType::IsNotSupported;
}
class MediaPlayerFactoryHolePunch final : public MediaPlayerFactory {
private:
MediaPlayerEnums::MediaEngineIdentifier identifier() const final { return MediaPlayerEnums::MediaEngineIdentifier::HolePunch; };
std::unique_ptr<MediaPlayerPrivateInterface> createMediaEnginePlayer(MediaPlayer* player) const final
{
return makeUnique<MediaPlayerPrivateHolePunch>(player);
}
void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>& types) const final
{
return MediaPlayerPrivateHolePunch::getSupportedTypes(types);
}
MediaPlayer::SupportsType supportsTypeAndCodecs(const MediaEngineSupportParameters& parameters) const final
{
return MediaPlayerPrivateHolePunch::supportsType(parameters);
}
};
void MediaPlayerPrivateHolePunch::registerMediaEngine(MediaEngineRegistrar registrar)
{
registrar(makeUnique<MediaPlayerFactoryHolePunch>());
}
void MediaPlayerPrivateHolePunch::notifyReadyState()
{
// Notify the ready state so the GraphicsLayer gets created.
if (auto player = m_player.get())
player->readyStateChanged();
}
void MediaPlayerPrivateHolePunch::setNetworkState(MediaPlayer::NetworkState networkState)
{
m_networkState = networkState;
if (auto player = m_player.get())
player->networkStateChanged();
}
void MediaPlayerPrivateHolePunch::load(const String&)
{
auto player = m_player.get();
if (!player)
return;
auto mimeType = player->contentMIMEType();
if (mimeType.isEmpty() || !mimeTypeCache().contains(mimeType))
setNetworkState(MediaPlayer::NetworkState::FormatError);
}
} // namespace WebCore
#endif // USE(EXTERNAL_HOLEPUNCH)
|
