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