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 "WebMediaPlayerClientImpl.h" 7 8 #if ENABLE(VIDEO) 9 10 #include "Frame.h" 11 #include "GraphicsContext.h" 12 #include "HTMLMediaElement.h" 13 #include "IntSize.h" 14 #include "KURL.h" 15 #include "MediaPlayer.h" 16 #include "NotImplemented.h" 17 #include "RenderView.h" 18 #include "TimeRanges.h" 19 #include "VideoLayerChromium.h" 20 21 #if USE(ACCELERATED_COMPOSITING) 22 #include "RenderLayerCompositor.h" 23 #endif 24 25 #include "VideoFrameChromium.h" 26 #include "VideoFrameChromiumImpl.h" 27 #include "WebCanvas.h" 28 #include "WebCString.h" 29 #include "WebFrameClient.h" 30 #include "WebFrameImpl.h" 31 #include "WebKit.h" 32 #include "WebKitClient.h" 33 #include "WebMediaElement.h" 34 #include "WebMediaPlayer.h" 35 #include "WebMimeRegistry.h" 36 #include "WebRect.h" 37 #include "WebSize.h" 38 #include "WebString.h" 39 #include "WebURL.h" 40 #include "WebViewImpl.h" 41 42 // WebCommon.h defines WEBKIT_USING_SKIA so this has to be included last. 43 #if WEBKIT_USING_SKIA 44 #include "PlatformContextSkia.h" 45 #endif 46 47 #include <wtf/Assertions.h> 48 #include <wtf/text/CString.h> 49 50 using namespace WebCore; 51 52 namespace WebKit { 53 54 static WebMediaPlayer* createWebMediaPlayer( 55 WebMediaPlayerClient* client, Frame* frame) 56 { 57 WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame); 58 59 if (!webFrame->client()) 60 return 0; 61 return webFrame->client()->createMediaPlayer(webFrame, client); 62 } 63 64 bool WebMediaPlayerClientImpl::m_isEnabled = false; 65 66 bool WebMediaPlayerClientImpl::isEnabled() 67 { 68 return m_isEnabled; 69 } 70 71 void WebMediaPlayerClientImpl::setIsEnabled(bool isEnabled) 72 { 73 m_isEnabled = isEnabled; 74 } 75 76 void WebMediaPlayerClientImpl::registerSelf(MediaEngineRegistrar registrar) 77 { 78 if (m_isEnabled) { 79 registrar(WebMediaPlayerClientImpl::create, 80 WebMediaPlayerClientImpl::getSupportedTypes, 81 WebMediaPlayerClientImpl::supportsType, 82 0, 83 0, 84 0); 85 } 86 } 87 88 WebMediaPlayerClientImpl* WebMediaPlayerClientImpl::fromMediaElement(const WebMediaElement* element) 89 { 90 PlatformMedia pm = element->constUnwrap<HTMLMediaElement>()->platformMedia(); 91 return static_cast<WebMediaPlayerClientImpl*>(pm.media.chromiumMediaPlayer); 92 } 93 94 WebMediaPlayer* WebMediaPlayerClientImpl::mediaPlayer() const 95 { 96 return m_webMediaPlayer.get(); 97 } 98 99 // WebMediaPlayerClient -------------------------------------------------------- 100 101 WebMediaPlayerClientImpl::~WebMediaPlayerClientImpl() 102 { 103 // VideoLayerChromium may outlive this object so make sure all frames are 104 // released. 105 #if USE(ACCELERATED_COMPOSITING) 106 if (m_videoLayer.get()) 107 m_videoLayer->releaseCurrentFrame(); 108 #endif 109 } 110 111 void WebMediaPlayerClientImpl::networkStateChanged() 112 { 113 ASSERT(m_mediaPlayer); 114 m_mediaPlayer->networkStateChanged(); 115 } 116 117 void WebMediaPlayerClientImpl::readyStateChanged() 118 { 119 ASSERT(m_mediaPlayer); 120 m_mediaPlayer->readyStateChanged(); 121 #if USE(ACCELERATED_COMPOSITING) 122 if (hasVideo() && supportsAcceleratedRendering() && !m_videoLayer.get()) 123 m_videoLayer = VideoLayerChromium::create(0, this); 124 #endif 125 } 126 127 void WebMediaPlayerClientImpl::volumeChanged(float newVolume) 128 { 129 ASSERT(m_mediaPlayer); 130 m_mediaPlayer->volumeChanged(newVolume); 131 } 132 133 void WebMediaPlayerClientImpl::muteChanged(bool newMute) 134 { 135 ASSERT(m_mediaPlayer); 136 m_mediaPlayer->muteChanged(newMute); 137 } 138 139 void WebMediaPlayerClientImpl::timeChanged() 140 { 141 ASSERT(m_mediaPlayer); 142 m_mediaPlayer->timeChanged(); 143 } 144 145 void WebMediaPlayerClientImpl::repaint() 146 { 147 ASSERT(m_mediaPlayer); 148 #if USE(ACCELERATED_COMPOSITING) 149 if (m_videoLayer.get() && supportsAcceleratedRendering()) 150 m_videoLayer->setNeedsDisplay(IntRect(0, 0, m_videoLayer->bounds().width(), m_videoLayer->bounds().height())); 151 #endif 152 m_mediaPlayer->repaint(); 153 } 154 155 void WebMediaPlayerClientImpl::durationChanged() 156 { 157 ASSERT(m_mediaPlayer); 158 m_mediaPlayer->durationChanged(); 159 } 160 161 void WebMediaPlayerClientImpl::rateChanged() 162 { 163 ASSERT(m_mediaPlayer); 164 m_mediaPlayer->rateChanged(); 165 } 166 167 void WebMediaPlayerClientImpl::sizeChanged() 168 { 169 ASSERT(m_mediaPlayer); 170 m_mediaPlayer->sizeChanged(); 171 } 172 173 void WebMediaPlayerClientImpl::sawUnsupportedTracks() 174 { 175 ASSERT(m_mediaPlayer); 176 m_mediaPlayer->mediaPlayerClient()->mediaPlayerSawUnsupportedTracks(m_mediaPlayer); 177 } 178 179 float WebMediaPlayerClientImpl::volume() const 180 { 181 if (m_mediaPlayer) 182 return m_mediaPlayer->volume(); 183 return 0.0f; 184 } 185 186 void WebMediaPlayerClientImpl::playbackStateChanged() 187 { 188 ASSERT(m_mediaPlayer); 189 m_mediaPlayer->playbackStateChanged(); 190 } 191 192 WebMediaPlayer::Preload WebMediaPlayerClientImpl::preload() const 193 { 194 if (m_mediaPlayer) 195 return static_cast<WebMediaPlayer::Preload>(m_mediaPlayer->preload()); 196 return static_cast<WebMediaPlayer::Preload>(m_preload); 197 } 198 199 // MediaPlayerPrivateInterface ------------------------------------------------- 200 201 void WebMediaPlayerClientImpl::load(const String& url) 202 { 203 m_url = url; 204 205 // Video frame object is owned by WebMediaPlayer. Before destroying 206 // WebMediaPlayer all frames need to be released. 207 #if USE(ACCELERATED_COMPOSITING) 208 if (m_videoLayer.get()) 209 m_videoLayer->releaseCurrentFrame(); 210 #endif 211 212 if (m_preload == MediaPlayer::None) { 213 m_webMediaPlayer.clear(); 214 m_delayingLoad = true; 215 } else 216 loadInternal(); 217 } 218 219 void WebMediaPlayerClientImpl::loadInternal() 220 { 221 Frame* frame = static_cast<HTMLMediaElement*>(m_mediaPlayer->mediaPlayerClient())->document()->frame(); 222 m_webMediaPlayer.set(createWebMediaPlayer(this, frame)); 223 if (m_webMediaPlayer.get()) 224 m_webMediaPlayer->load(KURL(ParsedURLString, m_url)); 225 } 226 227 void WebMediaPlayerClientImpl::cancelLoad() 228 { 229 if (m_webMediaPlayer.get()) 230 m_webMediaPlayer->cancelLoad(); 231 } 232 233 #if USE(ACCELERATED_COMPOSITING) 234 PlatformLayer* WebMediaPlayerClientImpl::platformLayer() const 235 { 236 ASSERT(m_supportsAcceleratedCompositing); 237 return m_videoLayer.get(); 238 } 239 #endif 240 241 PlatformMedia WebMediaPlayerClientImpl::platformMedia() const 242 { 243 PlatformMedia pm; 244 pm.type = PlatformMedia::ChromiumMediaPlayerType; 245 pm.media.chromiumMediaPlayer = const_cast<WebMediaPlayerClientImpl*>(this); 246 return pm; 247 } 248 249 void WebMediaPlayerClientImpl::play() 250 { 251 if (m_webMediaPlayer.get()) 252 m_webMediaPlayer->play(); 253 } 254 255 void WebMediaPlayerClientImpl::pause() 256 { 257 if (m_webMediaPlayer.get()) 258 m_webMediaPlayer->pause(); 259 } 260 261 void WebMediaPlayerClientImpl::prepareToPlay() 262 { 263 if (m_delayingLoad) 264 startDelayedLoad(); 265 } 266 267 IntSize WebMediaPlayerClientImpl::naturalSize() const 268 { 269 if (m_webMediaPlayer.get()) 270 return m_webMediaPlayer->naturalSize(); 271 return IntSize(); 272 } 273 274 bool WebMediaPlayerClientImpl::hasVideo() const 275 { 276 if (m_webMediaPlayer.get()) 277 return m_webMediaPlayer->hasVideo(); 278 return false; 279 } 280 281 bool WebMediaPlayerClientImpl::hasAudio() const 282 { 283 if (m_webMediaPlayer.get()) 284 return m_webMediaPlayer->hasAudio(); 285 return false; 286 } 287 288 void WebMediaPlayerClientImpl::setVisible(bool visible) 289 { 290 if (m_webMediaPlayer.get()) 291 m_webMediaPlayer->setVisible(visible); 292 } 293 294 float WebMediaPlayerClientImpl::duration() const 295 { 296 if (m_webMediaPlayer.get()) 297 return m_webMediaPlayer->duration(); 298 return 0.0f; 299 } 300 301 float WebMediaPlayerClientImpl::currentTime() const 302 { 303 if (m_webMediaPlayer.get()) 304 return m_webMediaPlayer->currentTime(); 305 return 0.0f; 306 } 307 308 void WebMediaPlayerClientImpl::seek(float time) 309 { 310 if (m_webMediaPlayer.get()) 311 m_webMediaPlayer->seek(time); 312 } 313 314 bool WebMediaPlayerClientImpl::seeking() const 315 { 316 if (m_webMediaPlayer.get()) 317 return m_webMediaPlayer->seeking(); 318 return false; 319 } 320 321 void WebMediaPlayerClientImpl::setEndTime(float time) 322 { 323 if (m_webMediaPlayer.get()) 324 m_webMediaPlayer->setEndTime(time); 325 } 326 327 void WebMediaPlayerClientImpl::setRate(float rate) 328 { 329 if (m_webMediaPlayer.get()) 330 m_webMediaPlayer->setRate(rate); 331 } 332 333 bool WebMediaPlayerClientImpl::paused() const 334 { 335 if (m_webMediaPlayer.get()) 336 return m_webMediaPlayer->paused(); 337 return false; 338 } 339 340 bool WebMediaPlayerClientImpl::supportsFullscreen() const 341 { 342 if (m_webMediaPlayer.get()) 343 return m_webMediaPlayer->supportsFullscreen(); 344 return false; 345 } 346 347 bool WebMediaPlayerClientImpl::supportsSave() const 348 { 349 if (m_webMediaPlayer.get()) 350 return m_webMediaPlayer->supportsSave(); 351 return false; 352 } 353 354 void WebMediaPlayerClientImpl::setVolume(float volume) 355 { 356 if (m_webMediaPlayer.get()) 357 m_webMediaPlayer->setVolume(volume); 358 } 359 360 MediaPlayer::NetworkState WebMediaPlayerClientImpl::networkState() const 361 { 362 if (m_webMediaPlayer.get()) 363 return static_cast<MediaPlayer::NetworkState>(m_webMediaPlayer->networkState()); 364 return MediaPlayer::Empty; 365 } 366 367 MediaPlayer::ReadyState WebMediaPlayerClientImpl::readyState() const 368 { 369 if (m_webMediaPlayer.get()) 370 return static_cast<MediaPlayer::ReadyState>(m_webMediaPlayer->readyState()); 371 return MediaPlayer::HaveNothing; 372 } 373 374 float WebMediaPlayerClientImpl::maxTimeSeekable() const 375 { 376 if (m_webMediaPlayer.get()) 377 return m_webMediaPlayer->maxTimeSeekable(); 378 return 0.0f; 379 } 380 381 PassRefPtr<TimeRanges> WebMediaPlayerClientImpl::buffered() const 382 { 383 if (m_webMediaPlayer.get()) { 384 const WebTimeRanges& webRanges = m_webMediaPlayer->buffered(); 385 386 // FIXME: Save the time ranges in a member variable and update it when needed. 387 RefPtr<TimeRanges> ranges = TimeRanges::create(); 388 for (size_t i = 0; i < webRanges.size(); ++i) 389 ranges->add(webRanges[i].start, webRanges[i].end); 390 return ranges.release(); 391 } 392 return TimeRanges::create(); 393 } 394 395 int WebMediaPlayerClientImpl::dataRate() const 396 { 397 if (m_webMediaPlayer.get()) 398 return m_webMediaPlayer->dataRate(); 399 return 0; 400 } 401 402 bool WebMediaPlayerClientImpl::totalBytesKnown() const 403 { 404 if (m_webMediaPlayer.get()) 405 return m_webMediaPlayer->totalBytesKnown(); 406 return false; 407 } 408 409 unsigned WebMediaPlayerClientImpl::totalBytes() const 410 { 411 if (m_webMediaPlayer.get()) 412 return static_cast<unsigned>(m_webMediaPlayer->totalBytes()); 413 return 0; 414 } 415 416 unsigned WebMediaPlayerClientImpl::bytesLoaded() const 417 { 418 if (m_webMediaPlayer.get()) 419 return static_cast<unsigned>(m_webMediaPlayer->bytesLoaded()); 420 return 0; 421 } 422 423 void WebMediaPlayerClientImpl::setSize(const IntSize& size) 424 { 425 if (m_webMediaPlayer.get()) 426 m_webMediaPlayer->setSize(WebSize(size.width(), size.height())); 427 } 428 429 void WebMediaPlayerClientImpl::paint(GraphicsContext* context, const IntRect& rect) 430 { 431 #if USE(ACCELERATED_COMPOSITING) 432 // If we are using GPU to render video, ignore requests to paint frames into 433 // canvas because it will be taken care of by VideoLayerChromium. 434 if (acceleratedRenderingInUse()) 435 return; 436 #endif 437 paintCurrentFrameInContext(context, rect); 438 } 439 440 void WebMediaPlayerClientImpl::paintCurrentFrameInContext(GraphicsContext* context, const IntRect& rect) 441 { 442 // Normally GraphicsContext operations do nothing when painting is disabled. 443 // Since we're accessing platformContext() directly we have to manually 444 // check. 445 if (m_webMediaPlayer.get() && !context->paintingDisabled()) { 446 #if WEBKIT_USING_SKIA 447 PlatformGraphicsContext* platformContext = context->platformContext(); 448 WebCanvas* canvas = platformContext->canvas(); 449 450 canvas->saveLayerAlpha(0, platformContext->getNormalizedAlpha()); 451 452 m_webMediaPlayer->paint(canvas, rect); 453 454 canvas->restore(); 455 #elif WEBKIT_USING_CG 456 m_webMediaPlayer->paint(context->platformContext(), rect); 457 #else 458 notImplemented(); 459 #endif 460 } 461 } 462 463 void WebMediaPlayerClientImpl::setPreload(MediaPlayer::Preload preload) 464 { 465 m_preload = preload; 466 467 if (m_webMediaPlayer.get()) 468 m_webMediaPlayer->setPreload(static_cast<WebMediaPlayer::Preload>(preload)); 469 470 if (m_delayingLoad && m_preload != MediaPlayer::None) 471 startDelayedLoad(); 472 } 473 474 bool WebMediaPlayerClientImpl::hasSingleSecurityOrigin() const 475 { 476 if (m_webMediaPlayer.get()) 477 return m_webMediaPlayer->hasSingleSecurityOrigin(); 478 return false; 479 } 480 481 MediaPlayer::MovieLoadType WebMediaPlayerClientImpl::movieLoadType() const 482 { 483 if (m_webMediaPlayer.get()) 484 return static_cast<MediaPlayer::MovieLoadType>( 485 m_webMediaPlayer->movieLoadType()); 486 return MediaPlayer::Unknown; 487 } 488 489 unsigned WebMediaPlayerClientImpl::decodedFrameCount() const 490 { 491 if (m_webMediaPlayer.get()) 492 return m_webMediaPlayer->decodedFrameCount(); 493 return 0; 494 } 495 496 unsigned WebMediaPlayerClientImpl::droppedFrameCount() const 497 { 498 if (m_webMediaPlayer.get()) 499 return m_webMediaPlayer->droppedFrameCount(); 500 return 0; 501 } 502 503 unsigned WebMediaPlayerClientImpl::audioDecodedByteCount() const 504 { 505 if (m_webMediaPlayer.get()) 506 return m_webMediaPlayer->audioDecodedByteCount(); 507 return 0; 508 } 509 510 unsigned WebMediaPlayerClientImpl::videoDecodedByteCount() const 511 { 512 if (m_webMediaPlayer.get()) 513 return m_webMediaPlayer->videoDecodedByteCount(); 514 return 0; 515 } 516 517 #if USE(ACCELERATED_COMPOSITING) 518 bool WebMediaPlayerClientImpl::supportsAcceleratedRendering() const 519 { 520 return m_supportsAcceleratedCompositing; 521 } 522 523 bool WebMediaPlayerClientImpl::acceleratedRenderingInUse() 524 { 525 return m_videoLayer.get() && m_videoLayer->layerRenderer(); 526 } 527 528 VideoFrameChromium* WebMediaPlayerClientImpl::getCurrentFrame() 529 { 530 VideoFrameChromium* videoFrame = 0; 531 if (m_webMediaPlayer.get()) { 532 WebVideoFrame* webkitVideoFrame = m_webMediaPlayer->getCurrentFrame(); 533 if (webkitVideoFrame) 534 videoFrame = new VideoFrameChromiumImpl(webkitVideoFrame); 535 } 536 return videoFrame; 537 } 538 539 void WebMediaPlayerClientImpl::putCurrentFrame(VideoFrameChromium* videoFrame) 540 { 541 if (videoFrame) { 542 if (m_webMediaPlayer.get()) { 543 m_webMediaPlayer->putCurrentFrame( 544 VideoFrameChromiumImpl::toWebVideoFrame(videoFrame)); 545 } 546 delete videoFrame; 547 } 548 } 549 #endif 550 551 MediaPlayerPrivateInterface* WebMediaPlayerClientImpl::create(MediaPlayer* player) 552 { 553 WebMediaPlayerClientImpl* client = new WebMediaPlayerClientImpl(); 554 client->m_mediaPlayer = player; 555 556 #if USE(ACCELERATED_COMPOSITING) 557 Frame* frame = static_cast<HTMLMediaElement*>( 558 client->m_mediaPlayer->mediaPlayerClient())->document()->frame(); 559 560 // This does not actually check whether the hardware can support accelerated 561 // compositing, but only if the flag is set. However, this is checked lazily 562 // in WebViewImpl::setIsAcceleratedCompositingActive() and will fail there 563 // if necessary. 564 client->m_supportsAcceleratedCompositing = 565 frame->contentRenderer()->compositor()->hasAcceleratedCompositing(); 566 #endif 567 568 return client; 569 } 570 571 void WebMediaPlayerClientImpl::getSupportedTypes(HashSet<String>& supportedTypes) 572 { 573 // FIXME: integrate this list with WebMediaPlayerClientImpl::supportsType. 574 notImplemented(); 575 } 576 577 MediaPlayer::SupportsType WebMediaPlayerClientImpl::supportsType(const String& type, 578 const String& codecs) 579 { 580 WebMimeRegistry::SupportsType supportsType = 581 webKitClient()->mimeRegistry()->supportsMediaMIMEType(type, codecs); 582 583 switch (supportsType) { 584 default: 585 ASSERT_NOT_REACHED(); 586 case WebMimeRegistry::IsNotSupported: 587 return MediaPlayer::IsNotSupported; 588 case WebMimeRegistry::IsSupported: 589 return MediaPlayer::IsSupported; 590 case WebMimeRegistry::MayBeSupported: 591 return MediaPlayer::MayBeSupported; 592 } 593 return MediaPlayer::IsNotSupported; 594 } 595 596 void WebMediaPlayerClientImpl::startDelayedLoad() 597 { 598 ASSERT(m_delayingLoad); 599 ASSERT(!m_webMediaPlayer.get()); 600 601 m_delayingLoad = false; 602 603 loadInternal(); 604 } 605 606 WebMediaPlayerClientImpl::WebMediaPlayerClientImpl() 607 : m_mediaPlayer(0) 608 , m_delayingLoad(false) 609 , m_preload(MediaPlayer::MetaData) 610 #if USE(ACCELERATED_COMPOSITING) 611 , m_videoLayer(0) 612 , m_supportsAcceleratedCompositing(false) 613 #endif 614 { 615 } 616 617 } // namespace WebKit 618 619 #endif // ENABLE(VIDEO) 620
