Source/WebCore/rendering/RenderVideo.cpp

   1 /*
   2  * Copyright (C) 2007, 2008, 2009, 2010 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27
  28 #if ENABLE(VIDEO)
  29 #include "RenderVideo.h"
  30
  31 #include "Document.h"
  32 #include "Frame.h"
  33 #include "FrameView.h"
  34 #include "GraphicsContext.h"
  35 #include "HTMLNames.h"
  36 #include "HTMLVideoElement.h"
  37 #include "MediaPlayer.h"
  38 #include "Page.h"
  39 #include "PaintInfo.h"
  40 #include "RenderView.h"
  41 #include <wtf/StackStats.h>
  42
  43 #if ENABLE(FULLSCREEN_API)
  44 #include "RenderFullScreen.h"
  45 #endif
  46
  47 namespace WebCore {
  48
  49 using namespace HTMLNames;
  50
  51 RenderVideo::RenderVideo(HTMLVideoElement& element, Ref<RenderStyle>&& style)
  52     : RenderMedia(element, WTFMove(style))
  53 {
  54     setIntrinsicSize(calculateIntrinsicSize());
  55 }
  56
  57 RenderVideo::~RenderVideo()
  58 {
  59     if (MediaPlayer* player = videoElement().player())
  60         player->setVisible(false);
  61 }
  62
  63 IntSize RenderVideo::defaultSize()
  64 {
  65     // These values are specified in the spec.
  66     static const int cDefaultWidth = 300;
  67     static const int cDefaultHeight = 150;
  68
  69     return IntSize(cDefaultWidth, cDefaultHeight);
  70 }
  71
  72 void RenderVideo::intrinsicSizeChanged()
  73 {
  74     if (videoElement().shouldDisplayPosterImage())
  75         RenderMedia::intrinsicSizeChanged();
  76     updateIntrinsicSize();
  77 }
  78
  79 void RenderVideo::updateIntrinsicSize()
  80 {
  81     LayoutSize size = calculateIntrinsicSize();
  82     size.scale(style().effectiveZoom());
  83
  84     // Never set the element size to zero when in a media document.
  85     if (size.isEmpty() && document().isMediaDocument())
  86         return;
  87
  88     if (size == intrinsicSize())
  89         return;
  90
  91     setIntrinsicSize(size);
  92     setPreferredLogicalWidthsDirty(true);
  93     setNeedsLayout();
  94 }
  95
  96 LayoutSize RenderVideo::calculateIntrinsicSize()
  97 {
  98     // Spec text from 4.8.6
  99     //
 100     // The intrinsic width of a video element's playback area is the intrinsic width
 101     // of the video resource, if that is available; otherwise it is the intrinsic
 102     // width of the poster frame, if that is available; otherwise it is 300 CSS pixels.
 103     //
 104     // The intrinsic height of a video element's playback area is the intrinsic height
 105     // of the video resource, if that is available; otherwise it is the intrinsic
 106     // height of the poster frame, if that is available; otherwise it is 150 CSS pixels.
 107     MediaPlayer* player = videoElement().player();
 108     if (player && videoElement().readyState() >= HTMLVideoElement::HAVE_METADATA) {
 109         LayoutSize size(player->naturalSize());
 110         if (!size.isEmpty())
 111             return size;
 112     }
 113
 114     if (videoElement().shouldDisplayPosterImage() && !m_cachedImageSize.isEmpty() && !imageResource().errorOccurred())
 115         return m_cachedImageSize;
 116
 117     // <video> in standalone media documents should not use the default 300x150
 118     // size since they also have audio-only files. By setting the intrinsic
 119     // size to 300x1 the video will resize itself in these cases, and audio will
 120     // have the correct height (it needs to be > 0 for controls to render properly).
 121     if (videoElement().document().isMediaDocument())
 122         return LayoutSize(defaultSize().width(), 1);
 123
 124     return defaultSize();
 125 }
 126
 127 void RenderVideo::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
 128 {
 129     RenderMedia::imageChanged(newImage, rect);
 130
 131     // Cache the image intrinsic size so we can continue to use it to draw the image correctly
 132     // even if we know the video intrinsic size but aren't able to draw video frames yet
 133     // (we don't want to scale the poster to the video size without keeping aspect ratio).
 134     if (videoElement().shouldDisplayPosterImage())
 135         m_cachedImageSize = intrinsicSize();
 136
 137     // The intrinsic size is now that of the image, but in case we already had the
 138     // intrinsic size of the video we call this here to restore the video size.
 139     updateIntrinsicSize();
 140 }
 141
 142 IntRect RenderVideo::videoBox() const
 143 {
 144     LayoutSize intrinsicSize = this->intrinsicSize();
 145
 146     if (videoElement().shouldDisplayPosterImage())
 147         intrinsicSize = m_cachedImageSize;
 148
 149     return snappedIntRect(replacedContentRect(intrinsicSize));
 150 }
 151
 152 bool RenderVideo::shouldDisplayVideo() const
 153 {
 154     return !videoElement().shouldDisplayPosterImage();
 155 }
 156
 157 void RenderVideo::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 158 {
 159     MediaPlayer* mediaPlayer = videoElement().player();
 160     bool displayingPoster = videoElement().shouldDisplayPosterImage();
 161
 162     Page* page = frame().page();
 163
 164     if (!displayingPoster && !mediaPlayer) {
 165         if (page && paintInfo.phase == PaintPhaseForeground)
 166             page->addRelevantUnpaintedObject(this, visualOverflowRect());
 167         return;
 168     }
 169
 170     LayoutRect rect = videoBox();
 171     if (rect.isEmpty()) {
 172         if (page && paintInfo.phase == PaintPhaseForeground)
 173             page->addRelevantUnpaintedObject(this, visualOverflowRect());
 174         return;
 175     }
 176     rect.moveBy(paintOffset);
 177
 178     if (page && paintInfo.phase == PaintPhaseForeground)
 179         page->addRelevantRepaintedObject(this, rect);
 180
 181     LayoutRect contentRect = contentBoxRect();
 182     contentRect.moveBy(paintOffset);
 183     GraphicsContext& context = paintInfo.context();
 184     bool clip = !contentRect.contains(rect);
 185     GraphicsContextStateSaver stateSaver(context, clip);
 186     if (clip)
 187         context.clip(contentRect);
 188
 189     if (displayingPoster)
 190         paintIntoRect(context, rect);
 191     else if (!videoElement().isFullscreen() || !mediaPlayer->supportsAcceleratedRendering()) {
 192         if (view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers)
 193             mediaPlayer->paintCurrentFrameInContext(context, rect);
 194         else
 195             mediaPlayer->paint(context, rect);
 196     }
 197 }
 198
 199 void RenderVideo::layout()
 200 {
 201     StackStats::LayoutCheckPoint layoutCheckPoint;
 202     RenderMedia::layout();
 203     updatePlayer();
 204 }
 205
 206 HTMLVideoElement& RenderVideo::videoElement() const
 207 {
 208     return downcast<HTMLVideoElement>(RenderMedia::mediaElement());
 209 }
 210
 211 void RenderVideo::updateFromElement()
 212 {
 213     RenderMedia::updateFromElement();
 214     updatePlayer();
 215 }
 216
 217 void RenderVideo::updatePlayer()
 218 {
 219     if (documentBeingDestroyed())
 220         return;
 221
 222     updateIntrinsicSize();
 223
 224     MediaPlayer* mediaPlayer = videoElement().player();
 225     if (!mediaPlayer)
 226         return;
 227
 228     if (!videoElement().inActiveDocument()) {
 229         mediaPlayer->setVisible(false);
 230         return;
 231     }
 232
 233     contentChanged(VideoChanged);
 234
 235     IntRect videoBounds = videoBox();
 236     mediaPlayer->setSize(IntSize(videoBounds.width(), videoBounds.height()));
 237     mediaPlayer->setVisible(true);
 238     mediaPlayer->setShouldMaintainAspectRatio(style().objectFit() != ObjectFitFill);
 239 }
 240
 241 LayoutUnit RenderVideo::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
 242 {
 243     return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
 244 }
 245
 246 LayoutUnit RenderVideo::computeReplacedLogicalHeight() const
 247 {
 248     return RenderReplaced::computeReplacedLogicalHeight();
 249 }
 250
 251 LayoutUnit RenderVideo::minimumReplacedHeight() const
 252 {
 253     return RenderReplaced::minimumReplacedHeight();
 254 }
 255
 256 bool RenderVideo::supportsAcceleratedRendering() const
 257 {
 258     if (MediaPlayer* player = videoElement().player())
 259         return player->supportsAcceleratedRendering();
 260     return false;
 261 }
 262
 263 void RenderVideo::acceleratedRenderingStateChanged()
 264 {
 265     if (MediaPlayer* player = videoElement().player())
 266         player->acceleratedRenderingStateChanged();
 267 }
 268
 269 bool RenderVideo::requiresImmediateCompositing() const
 270 {
 271     MediaPlayer* player = videoElement().player();
 272     return player && player->requiresImmediateCompositing();
 273 }
 274
 275 #if ENABLE(FULLSCREEN_API)
 276 static const RenderBlock* rendererPlaceholder(const RenderObject* renderer)
 277 {
 278     RenderObject* parent = renderer->parent();
 279     return is<RenderFullScreen>(parent) ? downcast<RenderFullScreen>(*parent).placeholder() : nullptr;
 280 }
 281
 282 LayoutUnit RenderVideo::offsetLeft() const
 283 {
 284     if (const RenderBlock* block = rendererPlaceholder(this))
 285         return block->offsetLeft();
 286     return RenderMedia::offsetLeft();
 287 }
 288
 289 LayoutUnit RenderVideo::offsetTop() const
 290 {
 291     if (const RenderBlock* block = rendererPlaceholder(this))
 292         return block->offsetTop();
 293     return RenderMedia::offsetTop();
 294 }
 295
 296 LayoutUnit RenderVideo::offsetWidth() const
 297 {
 298     if (const RenderBlock* block = rendererPlaceholder(this))
 299         return block->offsetWidth();
 300     return RenderMedia::offsetWidth();
 301 }
 302
 303 LayoutUnit RenderVideo::offsetHeight() const
 304 {
 305     if (const RenderBlock* block = rendererPlaceholder(this))
 306         return block->offsetHeight();
 307     return RenderMedia::offsetHeight();
 308 }
 309 #endif
 310
 311 bool RenderVideo::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const
 312 {
 313     if (videoElement().shouldDisplayPosterImage())
 314         return RenderImage::foregroundIsKnownToBeOpaqueInRect(localRect, maxDepthToTest);
 315
 316     if (!videoBox().contains(enclosingIntRect(localRect)))
 317         return false;
 318
 319     if (MediaPlayer* player = videoElement().player())
 320         return player->hasAvailableVideoFrame();
 321
 322     return false;
 323 }
 324
 325 } // namespace WebCore
 326
 327 #endif