src/third_party/WebKit/Source/web/WebMediaPlayerClientImpl.cpp

   1 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "config.h"
   6 #include "web/WebMediaPlayerClientImpl.h"
   7
   8 #include "core/frame/LocalFrame.h"
   9 #include "core/html/HTMLMediaElement.h"
  10 #include "core/html/TimeRanges.h"
  11 #include "core/rendering/RenderView.h"
  12 #include "core/rendering/compositing/RenderLayerCompositor.h"
  13 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h"
  14 #include "modules/encryptedmedia/MediaKeyNeededEvent.h"
  15 #include "modules/mediastream/MediaStreamRegistry.h"
  16 #include "platform/audio/AudioBus.h"
  17 #include "platform/audio/AudioSourceProviderClient.h"
  18 #include "platform/geometry/IntSize.h"
  19 #include "platform/graphics/GraphicsContext.h"
  20 #include "platform/graphics/GraphicsLayer.h"
  21 #include "platform/graphics/gpu/Extensions3DUtil.h"
  22 #include "platform/graphics/skia/GaneshUtils.h"
  23 #include "public/platform/Platform.h"
  24 #include "public/platform/WebAudioSourceProvider.h"
  25 #include "public/platform/WebCString.h"
  26 #include "public/platform/WebCanvas.h"
  27 #include "public/platform/WebCompositorSupport.h"
  28 #include "public/platform/WebContentDecryptionModule.h"
  29 #include "public/platform/WebGraphicsContext3DProvider.h"
  30 #include "public/platform/WebInbandTextTrack.h"
  31 #include "public/platform/WebMediaPlayer.h"
  32 #include "public/platform/WebRect.h"
  33 #include "public/platform/WebString.h"
  34 #include "public/platform/WebURL.h"
  35 #include "public/web/WebDocument.h"
  36 #include "public/web/WebFrameClient.h"
  37 #include "web/WebLocalFrameImpl.h"
  38 #include "web/WebViewImpl.h"
  39
  40 #if OS(ANDROID)
  41 #include "GrContext.h"
  42 #include "GrTypes.h"
  43 #include "SkCanvas.h"
  44 #include "SkGrPixelRef.h"
  45 #endif
  46
  47
  48 #include "wtf/Assertions.h"
  49 #include "wtf/text/CString.h"
  50
  51 namespace blink {
  52
  53 static PassOwnPtr<WebMediaPlayer> createWebMediaPlayer(WebMediaPlayerClient* client, const WebURL& url, LocalFrame* frame, WebContentDecryptionModule* initialCdm)
  54 {
  55     WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(frame);
  56
  57     if (!webFrame || !webFrame->client())
  58         return nullptr;
  59     return adoptPtr(webFrame->client()->createMediaPlayer(webFrame, url, client, initialCdm));
  60 }
  61
  62 WebMediaPlayer* WebMediaPlayerClientImpl::webMediaPlayer() const
  63 {
  64     return m_webMediaPlayer.get();
  65 }
  66
  67 // WebMediaPlayerClient --------------------------------------------------------
  68
  69 WebMediaPlayerClientImpl::~WebMediaPlayerClientImpl()
  70 {
  71     // Explicitly destroy the WebMediaPlayer to allow verification of tear down.
  72     m_webMediaPlayer.clear();
  73
  74     HTMLMediaElementEncryptedMedia::playerDestroyed(mediaElement());
  75 }
  76
  77 void WebMediaPlayerClientImpl::networkStateChanged()
  78 {
  79     m_client->mediaPlayerNetworkStateChanged();
  80 }
  81
  82 void WebMediaPlayerClientImpl::readyStateChanged()
  83 {
  84     m_client->mediaPlayerReadyStateChanged();
  85 }
  86
  87 void WebMediaPlayerClientImpl::timeChanged()
  88 {
  89     m_client->mediaPlayerTimeChanged();
  90 }
  91
  92 void WebMediaPlayerClientImpl::repaint()
  93 {
  94     m_client->mediaPlayerRepaint();
  95 }
  96
  97 void WebMediaPlayerClientImpl::durationChanged()
  98 {
  99     m_client->mediaPlayerDurationChanged();
 100 }
 101
 102 void WebMediaPlayerClientImpl::sizeChanged()
 103 {
 104     m_client->mediaPlayerSizeChanged();
 105 }
 106
 107 void WebMediaPlayerClientImpl::playbackStateChanged()
 108 {
 109     m_client->mediaPlayerPlaybackStateChanged();
 110 }
 111
 112 void WebMediaPlayerClientImpl::keyAdded(const WebString& keySystem, const WebString& sessionId)
 113 {
 114     HTMLMediaElementEncryptedMedia::keyAdded(mediaElement(), keySystem, sessionId);
 115 }
 116
 117 void WebMediaPlayerClientImpl::keyError(const WebString& keySystem, const WebString& sessionId, MediaKeyErrorCode errorCode, unsigned short systemCode)
 118 {
 119     HTMLMediaElementEncryptedMedia::keyError(mediaElement(), keySystem, sessionId, errorCode, systemCode);
 120 }
 121
 122 void WebMediaPlayerClientImpl::keyMessage(const WebString& keySystem, const WebString& sessionId, const unsigned char* message, unsigned messageLength, const WebURL& defaultURL)
 123 {
 124     HTMLMediaElementEncryptedMedia::keyMessage(mediaElement(), keySystem, sessionId, message, messageLength, defaultURL);
 125 }
 126
 127 void WebMediaPlayerClientImpl::keyNeeded(const WebString& contentType, const unsigned char* initData, unsigned initDataLength)
 128 {
 129     HTMLMediaElementEncryptedMedia::keyNeeded(mediaElement(), contentType, initData, initDataLength);
 130 }
 131
 132 void WebMediaPlayerClientImpl::setWebLayer(WebLayer* layer)
 133 {
 134     m_client->mediaPlayerSetWebLayer(layer);
 135 }
 136
 137 WebMediaPlayer::TrackId WebMediaPlayerClientImpl::addAudioTrack(const WebString& id, AudioTrackKind kind, const WebString& label, const WebString& language, bool enabled)
 138 {
 139     return mediaElement().addAudioTrack(id, kind, label, language, enabled);
 140 }
 141
 142 void WebMediaPlayerClientImpl::removeAudioTrack(WebMediaPlayer::TrackId id)
 143 {
 144     mediaElement().removeAudioTrack(id);
 145 }
 146
 147 WebMediaPlayer::TrackId WebMediaPlayerClientImpl::addVideoTrack(const WebString& id, VideoTrackKind kind, const WebString& label, const WebString& language, bool selected)
 148 {
 149     return mediaElement().addVideoTrack(id, kind, label, language, selected);
 150 }
 151
 152 void WebMediaPlayerClientImpl::removeVideoTrack(WebMediaPlayer::TrackId id)
 153 {
 154     mediaElement().removeVideoTrack(id);
 155 }
 156
 157 void WebMediaPlayerClientImpl::addTextTrack(WebInbandTextTrack* textTrack)
 158 {
 159     m_client->mediaPlayerDidAddTextTrack(textTrack);
 160 }
 161
 162 void WebMediaPlayerClientImpl::removeTextTrack(WebInbandTextTrack* textTrack)
 163 {
 164     m_client->mediaPlayerDidRemoveTextTrack(textTrack);
 165 }
 166
 167 void WebMediaPlayerClientImpl::mediaSourceOpened(WebMediaSource* webMediaSource)
 168 {
 169     ASSERT(webMediaSource);
 170     m_client->mediaPlayerMediaSourceOpened(webMediaSource);
 171 }
 172
 173 void WebMediaPlayerClientImpl::requestFullscreen()
 174 {
 175     m_client->mediaPlayerRequestFullscreen();
 176 }
 177
 178 void WebMediaPlayerClientImpl::requestSeek(double time)
 179 {
 180     m_client->mediaPlayerRequestSeek(time);
 181 }
 182
 183 void WebMediaPlayerClientImpl::remoteRouteAvailabilityChanged(bool routesAvailable)
 184 {
 185     mediaElement().remoteRouteAvailabilityChanged(routesAvailable);
 186 }
 187
 188 void WebMediaPlayerClientImpl::connectedToRemoteDevice()
 189 {
 190     mediaElement().connectedToRemoteDevice();
 191 }
 192
 193 void WebMediaPlayerClientImpl::disconnectedFromRemoteDevice()
 194 {
 195     mediaElement().disconnectedFromRemoteDevice();
 196 }
 197
 198 // MediaPlayer -------------------------------------------------
 199 void WebMediaPlayerClientImpl::load(WebMediaPlayer::LoadType loadType, const WTF::String& url, WebMediaPlayer::CORSMode corsMode)
 200 {
 201     ASSERT(!m_webMediaPlayer);
 202
 203     // FIXME: Remove this cast
 204     LocalFrame* frame = mediaElement().document().frame();
 205
 206     WebURL poster = m_client->mediaPlayerPosterURL();
 207
 208     KURL kurl(ParsedURLString, url);
 209     m_webMediaPlayer = createWebMediaPlayer(this, kurl, frame, HTMLMediaElementEncryptedMedia::contentDecryptionModule(mediaElement()));
 210     if (!m_webMediaPlayer)
 211         return;
 212
 213 #if ENABLE(WEB_AUDIO)
 214     // Make sure if we create/re-create the WebMediaPlayer that we update our wrapper.
 215     m_audioSourceProvider.wrap(m_webMediaPlayer->audioSourceProvider());
 216 #endif
 217
 218     m_webMediaPlayer->setVolume(mediaElement().effectiveMediaVolume());
 219
 220     m_webMediaPlayer->setPoster(poster);
 221
 222     m_webMediaPlayer->load(loadType, kurl, corsMode);
 223 }
 224
 225 void WebMediaPlayerClientImpl::setPreload(MediaPlayer::Preload preload)
 226 {
 227     if (m_webMediaPlayer)
 228         m_webMediaPlayer->setPreload(static_cast<WebMediaPlayer::Preload>(preload));
 229 }
 230
 231 #if ENABLE(WEB_AUDIO)
 232 AudioSourceProvider* WebMediaPlayerClientImpl::audioSourceProvider()
 233 {
 234     return &m_audioSourceProvider;
 235 }
 236 #endif
 237
 238 PassOwnPtr<MediaPlayer> WebMediaPlayerClientImpl::create(MediaPlayerClient* client)
 239 {
 240     return adoptPtr(new WebMediaPlayerClientImpl(client));
 241 }
 242
 243 WebMediaPlayerClientImpl::WebMediaPlayerClientImpl(MediaPlayerClient* client)
 244     : m_client(client)
 245 {
 246     ASSERT(m_client);
 247 }
 248
 249 HTMLMediaElement& WebMediaPlayerClientImpl::mediaElement() const
 250 {
 251     return *static_cast<HTMLMediaElement*>(m_client);
 252 }
 253
 254 #if ENABLE(WEB_AUDIO)
 255 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::wrap(WebAudioSourceProvider* provider)
 256 {
 257     MutexLocker locker(provideInputLock);
 258
 259     if (m_webAudioSourceProvider && provider != m_webAudioSourceProvider)
 260         m_webAudioSourceProvider->setClient(0);
 261
 262     m_webAudioSourceProvider = provider;
 263     if (m_webAudioSourceProvider)
 264         m_webAudioSourceProvider->setClient(m_client.get());
 265 }
 266
 267 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::setClient(AudioSourceProviderClient* client)
 268 {
 269     MutexLocker locker(provideInputLock);
 270
 271     if (client)
 272         m_client = new WebMediaPlayerClientImpl::AudioClientImpl(client);
 273     else
 274         m_client.clear();
 275
 276     if (m_webAudioSourceProvider)
 277         m_webAudioSourceProvider->setClient(m_client.get());
 278 }
 279
 280 void WebMediaPlayerClientImpl::AudioSourceProviderImpl::provideInput(AudioBus* bus, size_t framesToProcess)
 281 {
 282     ASSERT(bus);
 283     if (!bus)
 284         return;
 285
 286     MutexTryLocker tryLocker(provideInputLock);
 287     if (!tryLocker.locked() || !m_webAudioSourceProvider || !m_client.get()) {
 288         bus->zero();
 289         return;
 290     }
 291
 292     // Wrap the AudioBus channel data using WebVector.
 293     size_t n = bus->numberOfChannels();
 294     WebVector<float*> webAudioData(n);
 295     for (size_t i = 0; i < n; ++i)
 296         webAudioData[i] = bus->channel(i)->mutableData();
 297
 298     m_webAudioSourceProvider->provideInput(webAudioData, framesToProcess);
 299 }
 300
 301 void WebMediaPlayerClientImpl::AudioClientImpl::setFormat(size_t numberOfChannels, float sampleRate)
 302 {
 303     if (m_client)
 304         m_client->setFormat(numberOfChannels, sampleRate);
 305 }
 306
 307 void WebMediaPlayerClientImpl::AudioClientImpl::trace(Visitor* visitor)
 308 {
 309     visitor->trace(m_client);
 310 }
 311
 312 #endif
 313
 314 } // namespace blink