<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[186766] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/186766">186766</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2015-07-13 10:59:16 -0700 (Mon, 13 Jul 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>Adding MediaStream Engine building blocks to the code repo
https://bugs.webkit.org/show_bug.cgi?id=146789
<rdar://problem/21747025>
Patch by Matthew Daiter <mdaiter@apple.com> on 2015-07-13
Reviewed by Brent Fulgham.
* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h: Added.
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setLoadingProgresssed):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setHasAvailableVideoFrame):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::createWeakPtr):
* platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm: Added.
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::MediaPlayerPrivateMediaStreamAVFObjC):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::~MediaPlayerPrivateMediaStreamAVFObjC):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::registerMediaEngine):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::isAvailable):
(WebCore::mimeTypeCache):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::getSupportedTypes):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::supportsType):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::load):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::cancelLoad):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::prepareToPlay):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::platformMedia):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::platformLayer):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::play):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::playInternal):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::pause):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::pauseInternal):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::paused):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setVolume):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::supportsScanning):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setMuted):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::naturalSize):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::hasVideo):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::hasAudio):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setVisible):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::durationMediaTime):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::seeking):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setRateDouble):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setPreservesPitch):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::networkState):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::readyState):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::seekable):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::maxMediaTimeSeekable):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::minMediaTimeSeekable):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::buffered):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::didLoadingProgress):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setSize):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::hasAvailableVideoFrame):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::supportsAcceleratedRendering):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::movieLoadType):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::prepareForRendering):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::engineDescription):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::languageOfPrimaryAudioTrack):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::shouldBePlaying):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::addDisplayLayer):
(WebCore::MediaPlayerPrivateMediaStreamAVFObjC::removeDisplayLayer):
* platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h: Added.
* platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm: Added.
(WebCore::MediaStreamPrivateAVFObjC::create):
(WebCore::MediaStreamPrivateAVFObjC::MediaStreamPrivateAVFObjC):
(WebCore::MediaStreamPrivateAVFObjC::~MediaStreamPrivateAVFObjC):
(WebCore::MediaStreamPrivateAVFObjC::duration):
(WebCore::MediaStreamPrivateAVFObjC::buffered):
(WebCore::MediaStreamPrivateAVFObjC::readyState):
(WebCore::MediaStreamPrivateAVFObjC::hasAudio):
(WebCore::MediaStreamPrivateAVFObjC::hasVideo):
(WebCore::MediaStreamPrivateAVFObjC::naturalSize):
* platform/mediastream/MediaStreamPrivate.h:
(WebCore::MediaStreamPrivate::MediaStreamPrivate): Added constructor.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreplatformmediastreamMediaStreamPrivateh">trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaPlayerPrivateMediaStreamAVFObjCh">trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h</a></li>
<li><a href="#trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaPlayerPrivateMediaStreamAVFObjCmm">trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm</a></li>
<li><a href="#trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaStreamPrivateAVFObjCh">trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h</a></li>
<li><a href="#trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaStreamPrivateAVFObjCmm">trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (186765 => 186766)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2015-07-13 17:17:02 UTC (rev 186765)
+++ trunk/Source/WebCore/ChangeLog 2015-07-13 17:59:16 UTC (rev 186766)
</span><span class="lines">@@ -1,3 +1,75 @@
</span><ins>+2015-07-13 Matthew Daiter <mdaiter@apple.com>
+
+ Adding MediaStream Engine building blocks to the code repo
+ https://bugs.webkit.org/show_bug.cgi?id=146789
+ <rdar://problem/21747025>
+
+ Reviewed by Brent Fulgham.
+
+ * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h: Added.
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setLoadingProgresssed):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setHasAvailableVideoFrame):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::createWeakPtr):
+ * platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm: Added.
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::MediaPlayerPrivateMediaStreamAVFObjC):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::~MediaPlayerPrivateMediaStreamAVFObjC):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::registerMediaEngine):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::isAvailable):
+ (WebCore::mimeTypeCache):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::getSupportedTypes):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::supportsType):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::load):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::cancelLoad):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::prepareToPlay):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::platformMedia):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::platformLayer):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::play):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::playInternal):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::pause):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::pauseInternal):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::paused):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setVolume):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::supportsScanning):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setMuted):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::naturalSize):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::hasVideo):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::hasAudio):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setVisible):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::durationMediaTime):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::seeking):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setRateDouble):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setPreservesPitch):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::networkState):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::readyState):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::seekable):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::maxMediaTimeSeekable):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::minMediaTimeSeekable):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::buffered):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::didLoadingProgress):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::setSize):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::hasAvailableVideoFrame):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::supportsAcceleratedRendering):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::movieLoadType):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::prepareForRendering):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::engineDescription):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::languageOfPrimaryAudioTrack):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::shouldBePlaying):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::addDisplayLayer):
+ (WebCore::MediaPlayerPrivateMediaStreamAVFObjC::removeDisplayLayer):
+ * platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h: Added.
+ * platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm: Added.
+ (WebCore::MediaStreamPrivateAVFObjC::create):
+ (WebCore::MediaStreamPrivateAVFObjC::MediaStreamPrivateAVFObjC):
+ (WebCore::MediaStreamPrivateAVFObjC::~MediaStreamPrivateAVFObjC):
+ (WebCore::MediaStreamPrivateAVFObjC::duration):
+ (WebCore::MediaStreamPrivateAVFObjC::buffered):
+ (WebCore::MediaStreamPrivateAVFObjC::readyState):
+ (WebCore::MediaStreamPrivateAVFObjC::hasAudio):
+ (WebCore::MediaStreamPrivateAVFObjC::hasVideo):
+ (WebCore::MediaStreamPrivateAVFObjC::naturalSize):
+ * platform/mediastream/MediaStreamPrivate.h:
+ (WebCore::MediaStreamPrivate::MediaStreamPrivate): Added constructor.
+
</ins><span class="cx"> 2015-07-13 Eric Carlson <eric.carlson@apple.com>
</span><span class="cx">
</span><span class="cx"> [iOS] Cancel AirPlay explicitly when exiting from full screen
</span></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaPlayerPrivateMediaStreamAVFObjCh"></a>
<div class="addfile"><h4>Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h (0 => 186766)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h (rev 0)
+++ trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h 2015-07-13 17:59:16 UTC (rev 186766)
</span><span class="lines">@@ -0,0 +1,174 @@
</span><ins>+/*
+ * Copyright (C) 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MediaPlayerPrivateMediaStreamAVFObjC_h
+#define MediaPlayerPrivateMediaStreamAVFObjC_h
+
+#if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
+
+#include "MediaPlayerPrivate.h"
+#include "MediaStreamPrivateAVFObjC.h"
+#include "SourceBufferPrivateClient.h"
+#include <wtf/MediaTime.h>
+#include <wtf/Vector.h>
+#include <wtf/WeakPtr.h>
+
+OBJC_CLASS AVAsset;
+OBJC_CLASS AVCaptureVideoPreviewLayer;
+OBJC_CLASS AVSampleBufferAudioRenderer;
+OBJC_CLASS AVSampleBufferDisplayLayer;
+OBJC_CLASS AVSampleBufferRenderSynchronizer;
+OBJC_CLASS AVStreamSession;
+
+typedef struct OpaqueCMTimebase* CMTimebaseRef;
+
+namespace WebCore {
+
+class MediaPlayerPrivateMediaStreamAVFObjC : public MediaPlayerPrivateInterface {
+public:
+ explicit MediaPlayerPrivateMediaStreamAVFObjC(MediaPlayer*);
+ virtual ~MediaPlayerPrivateMediaStreamAVFObjC();
+
+ static void registerMediaEngine(MediaEngineRegistrar);
+
+ // MediaPlayer Factory Methods
+ static bool isAvailable();
+ static void getSupportedTypes(HashSet<String>& types);
+ static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&);
+
+ void addDisplayLayer(AVSampleBufferDisplayLayer*);
+ void removeDisplayLayer(AVSampleBufferDisplayLayer*);
+
+ void addAudioRenderer(AVSampleBufferAudioRenderer*);
+ void removeAudioRenderer(AVSampleBufferAudioRenderer*);
+
+ MediaPlayer::NetworkState networkState() const override;
+ MediaPlayer::ReadyState readyState() const override;
+ void setReadyState(MediaPlayer::ReadyState);
+
+ void sizeChanged();
+ void characteristicsChanged();
+
+ WeakPtr<MediaPlayerPrivateMediaStreamAVFObjC> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
+
+private:
+ // MediaPlayerPrivateInterface
+ // FIXME(146853): Implement necessary conformations to standard in HTMLMediaElement for MediaStream
+ void load(const String&) override { };
+#if ENABLE(MEDIA_SOURCE)
+ void load(const String&, MediaSourcePrivateClient*) override { };
+#endif
+#if ENABLE(MEDIA_STREAM)
+ void load(MediaStreamPrivate*) override;
+#endif
+ void cancelLoad() override;
+
+ void prepareToPlay() override;
+ PlatformMedia platformMedia() const override;
+ PlatformLayer* platformLayer() const override;
+
+ bool supportsFullscreen() const override { return true; }
+
+ void play() override;
+ void playInternal();
+
+ void pause() override;
+ void pauseInternal();
+
+ bool paused() const override;
+
+ void setVolume(float) override;
+ bool supportsMuting() const override { return true; }
+ void setMuted(bool) override;
+
+ bool supportsScanning() const override;
+
+ FloatSize naturalSize() const override;
+
+ bool hasVideo() const override;
+ bool hasAudio() const override;
+
+ void setVisible(bool) override;
+
+ MediaTime durationMediaTime() const override;
+ MediaTime currentMediaTime() const override;
+
+ void seekWithTolerance(const MediaTime&, const MediaTime&, const MediaTime&) override { };
+ bool seeking() const override;
+ void setRateDouble(double) override;
+
+ std::unique_ptr<PlatformTimeRanges> seekable() const override;
+ MediaTime maxMediaTimeSeekable() const override;
+ MediaTime minMediaTimeSeekable() const override;
+ std::unique_ptr<PlatformTimeRanges> buffered() const override;
+
+ bool didLoadingProgress() const override;
+
+ void setSize(const IntSize&) override;
+
+ void paint(GraphicsContext*, const FloatRect&) override;
+ void paintCurrentFrameInContext(GraphicsContext*, const FloatRect&) override;
+
+ bool supportsAcceleratedRendering() const override;
+
+ MediaPlayer::MovieLoadType movieLoadType() const override;
+
+ void prepareForRendering() override;
+
+ String engineDescription() const override;
+
+ String languageOfPrimaryAudioTrack() const override;
+
+ size_t extraMemoryCost() const override;
+
+ bool shouldBePlaying() const;
+
+ friend class MediaStreamPrivateAVFObjC;
+
+ MediaPlayer* m_player;
+ WeakPtrFactory<MediaPlayerPrivateMediaStreamAVFObjC> m_weakPtrFactory;
+ RefPtr<MediaStreamPrivateAVFObjC> m_MediaStreamPrivate;
+ RetainPtr<AVAsset> m_asset;
+ RetainPtr<AVSampleBufferDisplayLayer> m_sampleBufferDisplayLayer;
+ Vector<RetainPtr<AVSampleBufferAudioRenderer>> m_sampleBufferAudioRenderers;
+ RetainPtr<AVSampleBufferRenderSynchronizer> m_synchronizer;
+ RetainPtr<id> m_timeJumpedObserver;
+ RetainPtr<id> m_durationObserver;
+ RetainPtr<AVStreamSession> m_streamSession;
+ MediaPlayer::NetworkState m_networkState;
+ MediaPlayer::ReadyState m_readyState;
+ MediaTime m_lastSeekTime;
+ double m_rate;
+ bool m_playing;
+ bool m_seeking;
+ bool m_seekCompleted;
+ mutable bool m_loadingProgressed;
+};
+
+}
+
+#endif // ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
+
+#endif // MediaPlayerPrivateMediaStreamAVFObjC_h
</ins></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaPlayerPrivateMediaStreamAVFObjCmm"></a>
<div class="addfile"><h4>Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm (0 => 186766)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm (rev 0)
+++ trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm 2015-07-13 17:59:16 UTC (rev 186766)
</span><span class="lines">@@ -0,0 +1,408 @@
</span><ins>+/*
+ * Copyright (C) 2013, 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#import "config.h"
+#import "MediaPlayerPrivateMediaStreamAVFObjC.h"
+
+#if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
+
+#import "AVVideoCaptureSource.h"
+#import "FileSystem.h"
+#import "Logging.h"
+#import "MediaStreamPrivate.h"
+#import "MediaStreamPrivateAVFObjC.h"
+#import "MediaTimeAVFoundation.h"
+#import "PlatformClockCM.h"
+#import "WebCoreSystemInterface.h"
+#import <AVFoundation/AVAsset.h>
+#import <AVFoundation/AVCaptureVideoPreviewLayer.h>
+#import <AVFoundation/AVTime.h>
+#import <QuartzCore/CALayer.h>
+#import <objc_runtime.h>
+#import <wtf/MainThread.h>
+#import <wtf/NeverDestroyed.h>
+
+#pragma mark - Soft Linking
+
+#import "CoreMediaSoftLink.h"
+
+SOFT_LINK_FRAMEWORK_OPTIONAL(AVFoundation)
+
+SOFT_LINK_CLASS_OPTIONAL(AVFoundation, AVAsset)
+SOFT_LINK_CLASS_OPTIONAL(AVFoundation, AVCaptureVideoPreviewLayer)
+SOFT_LINK_CLASS_OPTIONAL(AVFoundation, AVURLAsset)
+SOFT_LINK_CLASS_OPTIONAL(AVFoundation, AVStreamSession);
+
+#pragma mark -
+#pragma mark AVStreamSession
+
+@interface AVStreamSession : NSObject
+- (instancetype)initWithStorageDirectoryAtURL:(NSURL *)storageDirectory;
+@end
+
+namespace WebCore {
+
+#pragma mark -
+#pragma mark MediaPlayerPrivateMediaStreamAVFObjC
+
+MediaPlayerPrivateMediaStreamAVFObjC::MediaPlayerPrivateMediaStreamAVFObjC(MediaPlayer* player)
+ : m_player(player)
+ , m_weakPtrFactory(this)
+ , m_networkState(MediaPlayer::Idle)
+ , m_readyState(MediaPlayer::HaveNothing)
+ , m_rate(1)
+ , m_playing(0)
+ , m_seeking(false)
+ , m_seekCompleted(true)
+ , m_loadingProgressed(false)
+{
+}
+
+MediaPlayerPrivateMediaStreamAVFObjC::~MediaPlayerPrivateMediaStreamAVFObjC()
+{
+}
+
+#pragma mark -
+#pragma mark MediaPlayer Factory Methods
+
+void MediaPlayerPrivateMediaStreamAVFObjC::registerMediaEngine(MediaEngineRegistrar registrar)
+{
+ if (isAvailable())
+ registrar([](MediaPlayer* player) { return std::make_unique<MediaPlayerPrivateMediaStreamAVFObjC>(player); }, getSupportedTypes,
+ supportsType, 0, 0, 0, 0);
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::isAvailable()
+{
+ return AVFoundationLibrary()
+ && isCoreMediaFrameworkAvailable();
+}
+
+static const HashSet<String>& mimeTypeCache()
+{
+ static NeverDestroyed<HashSet<String>> cache;
+ static bool typeListInitialized = false;
+
+ if (typeListInitialized)
+ return cache;
+ typeListInitialized = true;
+
+ NSArray *types = [getAVURLAssetClass() audiovisualMIMETypes];
+ for (NSString *mimeType in types)
+ cache.get().add(mimeType);
+
+ return cache;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::getSupportedTypes(HashSet<String>& types)
+{
+ types = mimeTypeCache();
+}
+
+MediaPlayer::SupportsType MediaPlayerPrivateMediaStreamAVFObjC::supportsType(const MediaEngineSupportParameters& parameters)
+{
+ // This engine does not support non-media-stream sources.
+ if (parameters.isMediaStream)
+ return MediaPlayer::IsSupported;
+ return MediaPlayer::IsNotSupported;
+}
+
+#pragma mark -
+#pragma mark MediaPlayerPrivateInterface Overrides
+
+void MediaPlayerPrivateMediaStreamAVFObjC::load(MediaStreamPrivate* client)
+{
+ m_MediaStreamPrivate = MediaStreamPrivateAVFObjC::create(this, client->client());
+ for (auto track : m_MediaStreamPrivate->client()->getVideoTracks()) {
+ client->addTrack(&track->privateTrack(), MediaStreamPrivate::NotifyClientOption::DontNotify);
+ client->client()->didAddTrackToPrivate(track->privateTrack());
+ if (track->readyState() == "live") {
+ track->source()->startProducingData();
+ track->setEnabled(true);
+ }
+ }
+ for (auto track : m_MediaStreamPrivate->client()->getAudioTracks()) {
+ client->addTrack(&track->privateTrack(), MediaStreamPrivate::NotifyClientOption::DontNotify);
+ client->client()->didAddTrackToPrivate(track->privateTrack());
+ if (track->readyState() == "live") {
+ track->source()->startProducingData();
+ track->setEnabled(true);
+ }
+ }
+ m_player->client().mediaPlayerRenderingModeChanged(m_player);
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::cancelLoad()
+{
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::prepareToPlay()
+{
+}
+
+PlatformMedia MediaPlayerPrivateMediaStreamAVFObjC::platformMedia() const
+{
+ PlatformMedia pm;
+ pm.type = PlatformMedia::AVFoundationAssetType;
+ pm.media.avfAsset = m_asset.get();
+ return pm;
+}
+
+PlatformLayer* MediaPlayerPrivateMediaStreamAVFObjC::platformLayer() const
+{
+ if (!m_MediaStreamPrivate)
+ return MediaPlayerPrivateInterface::platformLayer();
+ for (auto track : m_MediaStreamPrivate->client()->getVideoTracks()) {
+ // FIXME(146858): Just grab the first webcam for now, we can manage more later
+ AVVideoCaptureSource* capture = (AVVideoCaptureSource*)track->source();
+ return (PlatformLayer*)[getAVCaptureVideoPreviewLayerClass() layerWithSession:capture->session()];
+ }
+ return MediaPlayerPrivateInterface::platformLayer();
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::play()
+{
+ auto weakThis = createWeakPtr();
+ callOnMainThread([weakThis] {
+ if (!weakThis)
+ return;
+ weakThis.get()->playInternal();
+ });
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::playInternal()
+{
+ m_playing = true;
+ if (shouldBePlaying())
+ [m_synchronizer setRate:m_rate];
+
+ for (auto track : m_MediaStreamPrivate->client()->getVideoTracks())
+ track->source()->startProducingData();
+ for (auto track : m_MediaStreamPrivate->client()->getAudioTracks())
+ track->source()->startProducingData();
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::pause()
+{
+ auto weakThis = createWeakPtr();
+ callOnMainThread([weakThis] {
+ if (!weakThis)
+ return;
+ weakThis.get()->pauseInternal();
+ });
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::pauseInternal()
+{
+ m_playing = false;
+
+ for (auto track : m_MediaStreamPrivate->client()->getVideoTracks())
+ track->source()->stopProducingData();
+ for (auto track : m_MediaStreamPrivate->client()->getAudioTracks())
+ track->source()->stopProducingData();
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::paused() const
+{
+ // Shouldn't be able to pause streams
+ return false;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::setVolume(float)
+{
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::supportsScanning() const
+{
+ return true;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::setMuted(bool muted)
+{
+ for (auto track : m_MediaStreamPrivate->client()->getAudioTracks())
+ track->source()->setMuted(muted);
+}
+
+FloatSize MediaPlayerPrivateMediaStreamAVFObjC::naturalSize() const
+{
+ FloatSize floatSize;
+ for (auto track : m_MediaStreamPrivate->client()->getVideoTracks()) {
+ AVVideoCaptureSource* source = (AVVideoCaptureSource*)track->source();
+ if (!source->stopped() && track->enabled()) {
+ if (source->width() > floatSize.width())
+ floatSize.setWidth(source->width());
+ if (source->height() > floatSize.height())
+ floatSize.setHeight(source->height());
+ }
+ }
+ return floatSize;
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::hasVideo() const
+{
+ return !m_MediaStreamPrivate->client()->getVideoTracks().isEmpty();
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::hasAudio() const
+{
+ return !m_MediaStreamPrivate->client()->getAudioTracks().isEmpty();
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::setVisible(bool)
+{
+ // No-op.
+}
+
+MediaTime MediaPlayerPrivateMediaStreamAVFObjC::durationMediaTime() const
+{
+ return MediaTime::positiveInfiniteTime();
+}
+
+MediaTime MediaPlayerPrivateMediaStreamAVFObjC::currentMediaTime() const
+{
+ MediaTime synchronizerTime = toMediaTime(CMTimebaseGetTime([m_synchronizer timebase]));
+ if (synchronizerTime < MediaTime::zeroTime())
+ return MediaTime::zeroTime();
+ return synchronizerTime;
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::seeking() const
+{
+ // MediaStream is unseekable
+ return false;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::setRateDouble(double)
+{
+ // MediaStream is unseekable; therefore, cannot set rate
+}
+
+MediaPlayer::NetworkState MediaPlayerPrivateMediaStreamAVFObjC::networkState() const
+{
+ return m_networkState;
+}
+
+MediaPlayer::ReadyState MediaPlayerPrivateMediaStreamAVFObjC::readyState() const
+{
+ return m_readyState;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::sizeChanged()
+{
+ m_player->sizeChanged();
+}
+
+std::unique_ptr<PlatformTimeRanges> MediaPlayerPrivateMediaStreamAVFObjC::seekable() const
+{
+ return std::make_unique<PlatformTimeRanges>(minMediaTimeSeekable(), maxMediaTimeSeekable());
+}
+
+MediaTime MediaPlayerPrivateMediaStreamAVFObjC::maxMediaTimeSeekable() const
+{
+ return durationMediaTime();
+}
+
+MediaTime MediaPlayerPrivateMediaStreamAVFObjC::minMediaTimeSeekable() const
+{
+ return startTime();
+}
+
+std::unique_ptr<PlatformTimeRanges> MediaPlayerPrivateMediaStreamAVFObjC::buffered() const
+{
+ return std::make_unique<PlatformTimeRanges>();
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::didLoadingProgress() const
+{
+ bool loadingProgressed = m_loadingProgressed;
+ m_loadingProgressed = false;
+ return loadingProgressed;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::setSize(const IntSize&)
+{
+ // No-op.
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::paint(GraphicsContext*, const FloatRect&)
+{
+ // FIXME(125157): Implement painting.
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::paintCurrentFrameInContext(GraphicsContext*, const FloatRect&)
+{
+ // FIXME(125157): Implement painting.
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::supportsAcceleratedRendering() const
+{
+ return true;
+}
+
+MediaPlayer::MovieLoadType MediaPlayerPrivateMediaStreamAVFObjC::movieLoadType() const
+{
+ return MediaPlayer::LiveStream;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::prepareForRendering()
+{
+ // No-op.
+}
+
+String MediaPlayerPrivateMediaStreamAVFObjC::engineDescription() const
+{
+ static NeverDestroyed<String> description(ASCIILiteral("AVFoundation MediaStream Engine"));
+ return description;
+}
+
+String MediaPlayerPrivateMediaStreamAVFObjC::languageOfPrimaryAudioTrack() const
+{
+ // FIXME(125158): implement languageOfPrimaryAudioTrack()
+ return emptyString();
+}
+
+size_t MediaPlayerPrivateMediaStreamAVFObjC::extraMemoryCost() const
+{
+ return 0;
+}
+
+bool MediaPlayerPrivateMediaStreamAVFObjC::shouldBePlaying() const
+{
+ return m_playing && m_readyState >= MediaPlayer::HaveFutureData;
+}
+
+void MediaPlayerPrivateMediaStreamAVFObjC::setReadyState(MediaPlayer::ReadyState readyState)
+{
+ if (m_readyState == readyState)
+ return;
+
+ m_readyState = readyState;
+
+ m_player->readyStateChanged();
+}
+
+}
+
+#endif
</ins></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaStreamPrivateAVFObjCh"></a>
<div class="addfile"><h4>Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h (0 => 186766)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h (rev 0)
+++ trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h 2015-07-13 17:59:16 UTC (rev 186766)
</span><span class="lines">@@ -0,0 +1,87 @@
</span><ins>+/*
+ * Copyright (C) 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MediaStreamPrivateAVFObjC_h
+#define MediaStreamPrivateAVFObjC_h
+
+#if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
+
+#include "MediaPlayer.h"
+#include "MediaStreamPrivate.h"
+#include <wtf/Deque.h>
+#include <wtf/HashMap.h>
+#include <wtf/MediaTime.h>
+#include <wtf/RefPtr.h>
+#include <wtf/RetainPtr.h>
+#include <wtf/Vector.h>
+
+OBJC_CLASS AVAsset;
+OBJC_CLASS AVStreamDataParser;
+OBJC_CLASS NSError;
+OBJC_CLASS NSObject;
+typedef struct opaqueCMSampleBuffer *CMSampleBufferRef;
+
+namespace WebCore {
+
+class CDMSession;
+class MediaPlayerPrivateMediaStreamAVFObjC;
+class MediaStreamPrivate;
+class MediaStreamPrivateClient;
+class PlatformTimeRanges;
+class TimeRanges;
+
+class MediaStreamPrivateAVFObjC final : public MediaStreamPrivate {
+public:
+ static RefPtr<MediaStreamPrivateAVFObjC> create(MediaPlayerPrivateMediaStreamAVFObjC&, MediaStreamPrivateClient&);
+ virtual ~MediaStreamPrivateAVFObjC();
+
+ MediaPlayerPrivateMediaStreamAVFObjC* player() const { return m_player; }
+
+ virtual MediaStreamPrivateClient* client() const { return m_client.get(); }
+ virtual void setClient(MediaStreamPrivateClient* client) { m_client = client; }
+
+ MediaTime duration();
+ std::unique_ptr<PlatformTimeRanges> buffered();
+
+ bool hasAudio() const;
+ bool hasVideo() const;
+
+ void setReadyState(MediaPlayer::ReadyState);
+ FloatSize naturalSize() const;
+
+ MediaPlayer::ReadyState readyState() const;
+
+private:
+ MediaStreamPrivateAVFObjC(MediaPlayerPrivateMediaStreamAVFObjC&, MediaStreamPrivateClient&);
+
+ MediaPlayerPrivateMediaStreamAVFObjC* m_player;
+ RefPtr<MediaStreamPrivateClient> m_client;
+};
+
+}
+
+#endif // ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
+
+#endif
</ins></span></pre></div>
<a id="trunkSourceWebCoreplatformgraphicsavfoundationobjcMediaStreamPrivateAVFObjCmm"></a>
<div class="addfile"><h4>Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm (0 => 186766)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm (rev 0)
+++ trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm 2015-07-13 17:59:16 UTC (rev 186766)
</span><span class="lines">@@ -0,0 +1,98 @@
</span><ins>+/*
+ * Copyright (C) 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "MediaStreamPrivateAVFObjC.h"
+
+#if ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
+
+#import "ContentType.h"
+#import "ExceptionCodePlaceholder.h"
+#import "MediaPlayerPrivateMediaStreamAVFObjC.h"
+#import "MediaStreamPrivate.h"
+#import "SoftLinking.h"
+#import "SourceBufferPrivateAVFObjC.h"
+#import <objc/runtime.h>
+#import <wtf/text/AtomicString.h>
+#import <wtf/text/StringBuilder.h>
+
+namespace WebCore {
+
+#pragma mark -
+#pragma mark MediaStreamPrivateAVFObjC
+
+RefPtr<MediaStreamPrivateAVFObjC> MediaStreamPrivateAVFObjC::create(MediaPlayerPrivateMediaStreamAVFObjC& parent, MediaStreamPrivateClient& client)
+{
+ return adoptRef(new MediaStreamPrivateAVFObjC(parent, client));
+}
+
+MediaStreamPrivateAVFObjC::MediaStreamPrivateAVFObjC(MediaPlayerPrivateMediaStreamAVFObjC& parent, MediaStreamPrivateClient& client)
+ : m_player(&parent)
+ , m_client(&client)
+{
+}
+
+MediaStreamPrivateAVFObjC::~MediaStreamPrivateAVFObjC()
+{
+}
+
+MediaTime MediaStreamPrivateAVFObjC::duration()
+{
+ return MediaTime::positiveInfiniteTime();
+}
+
+std::unique_ptr<PlatformTimeRanges> MediaStreamPrivateAVFObjC::buffered()
+{
+ return std::unique_ptr<PlatformTimeRanges>();
+}
+
+MediaPlayer::ReadyState MediaStreamPrivateAVFObjC::readyState() const
+{
+ return m_player->readyState();
+}
+
+void MediaStreamPrivateAVFObjC::setReadyState(MediaPlayer::ReadyState readyState)
+{
+ m_player->setReadyState(readyState);
+}
+
+bool MediaStreamPrivateAVFObjC::hasAudio() const
+{
+ return m_player->hasAudio();
+}
+
+bool MediaStreamPrivateAVFObjC::hasVideo() const
+{
+ return m_player->hasVideo();
+}
+
+FloatSize MediaStreamPrivateAVFObjC::naturalSize() const
+{
+ return m_player->naturalSize();
+}
+
+}
+
+#endif // ENABLE(MEDIA_STREAM) && USE(AVFOUNDATION)
</ins></span></pre></div>
<a id="trunkSourceWebCoreplatformmediastreamMediaStreamPrivateh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h (186765 => 186766)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h 2015-07-13 17:17:02 UTC (rev 186765)
+++ trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h 2015-07-13 17:59:16 UTC (rev 186766)
</span><span class="lines">@@ -81,6 +81,7 @@
</span><span class="cx"> void removeTrack(MediaStreamTrackPrivate&, NotifyClientOption);
</span><span class="cx">
</span><span class="cx"> private:
</span><ins>+ MediaStreamPrivate() { }
</ins><span class="cx"> MediaStreamPrivate(const String& id, const Vector<RefPtr<MediaStreamTrackPrivate>>&);
</span><span class="cx">
</span><span class="cx"> MediaStreamPrivateClient* m_client;
</span></span></pre>
</div>
</div>
</body>
</html>