Diff
Modified: trunk/Source/WebCore/ChangeLog (186765 => 186766)
--- 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)
@@ -1,3 +1,75 @@
+2015-07-13 Matthew Daiter <mdai...@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.
+
2015-07-13 Eric Carlson <eric.carl...@apple.com>
[iOS] Cancel AirPlay explicitly when exiting from full screen
Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.h (0 => 186766)
--- 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)
@@ -0,0 +1,174 @@
+/*
+ * 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
Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaPlayerPrivateMediaStreamAVFObjC.mm (0 => 186766)
--- 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)
@@ -0,0 +1,408 @@
+/*
+ * 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
Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.h (0 => 186766)
--- 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)
@@ -0,0 +1,87 @@
+/*
+ * 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
Added: trunk/Source/WebCore/platform/graphics/avfoundation/objc/MediaStreamPrivateAVFObjC.mm (0 => 186766)
--- 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)
@@ -0,0 +1,98 @@
+/*
+ * 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)
Modified: trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h (186765 => 186766)
--- 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)
@@ -81,6 +81,7 @@
void removeTrack(MediaStreamTrackPrivate&, NotifyClientOption);
private:
+ MediaStreamPrivate() { }
MediaStreamPrivate(const String& id, const Vector<RefPtr<MediaStreamTrackPrivate>>&);
MediaStreamPrivateClient* m_client;
