Get rid of AVFMediaPlayerSession

Move all the code into AVFMediaPlayer, as that class was only forwarding
to the session anyway.

Fix some compile problems on macOS at the same time. The change also
makes subtitles work on macOS for some reason now :)

Change-Id: If187d1568b0000ad8ba20922e3f6479ae27bbf2c
Reviewed-by: Doris Verria <doris.verria@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

9 files changed, 1071 insertions, 1449 deletions

diff --git a/examples/multimediawidgets/player/player.cpp b/examples/multimediawidgets/player/player.cpp
index c4f968c4e..3612c49c9 100644
--- a/examples/multimediawidgets/player/player.cpp
+++ b/examples/multimediawidgets/player/player.cpp
@@ -481,7 +481,7 @@ void Player::selectVideoStream()
 
 void Player::selectSubtitleStream()
 {
-    int stream = m_audioTracks->currentData().toInt();
+    int stream = m_subtitleTracks->currentData().toInt();
     m_player->setActiveSubtitleTrack(stream);
 }
 
diff --git a/src/imports/multimedia/qmldir b/src/imports/multimedia/qmldir
index e7dcc3dd6..d68049f63 100644
--- a/src/imports/multimedia/qmldir
+++ b/src/imports/multimedia/qmldir
@@ -4,4 +4,3 @@ classname QMultimediaDeclarativeModule
 typeinfo plugins.qmltypes
 typeinfo plugins.qmltypes
 Video 5.0 Video.qml
-
diff --git a/src/multimedia/CMakeLists.txt b/src/multimedia/CMakeLists.txt
index 41ff23fcf..ced6e0696 100644
--- a/src/multimedia/CMakeLists.txt
+++ b/src/multimedia/CMakeLists.txt
@@ -375,7 +375,6 @@ qt_internal_extend_target(Multimedia CONDITION APPLE AND NOT WATCHOS
         platform/darwin/audio/qcoreaudiooutput.mm platform/darwin/audio/qcoreaudiooutput_p.h
         platform/darwin/audio/qcoreaudioutils.mm platform/darwin/audio/qcoreaudioutils_p.h
         platform/darwin/mediaplayer/avfmediaplayer.mm platform/darwin/mediaplayer/avfmediaplayer_p.h
-        platform/darwin/mediaplayer/avfmediaplayersession.mm platform/darwin/mediaplayer/avfmediaplayersession_p.h
         platform/darwin/mediaplayer/avfmetadata.mm platform/darwin/mediaplayer/avfmetadata_p.h
         platform/darwin/mediaplayer/avfvideooutput.mm platform/darwin/mediaplayer/avfvideooutput_p.h
         platform/darwin/mediaplayer/avfvideowindowcontrol.mm platform/darwin/mediaplayer/avfvideowindowcontrol_p.h
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm
index 44c5d8006..6d9f8a118 100644
--- a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm
+++ b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm
@@ -38,14 +38,464 @@
 ****************************************************************************/
 
 #include "avfmediaplayer_p.h"
-#include "avfmediaplayersession_p.h"
+#include "avfmediaplayer_p.h"
+#include "avfvideorenderercontrol_p.h"
+#include "avfvideooutput_p.h"
+#include "avfmetadata_p.h"
+
+#include <qpointer.h>
+#include <QFileInfo>
+
+#import <AVFoundation/AVFoundation.h>
 
 QT_USE_NAMESPACE
 
-AVFMediaPlayer::AVFMediaPlayer(QMediaPlayer *)
-    : QPlatformMediaPlayer(parent)
+//AVAsset Keys
+static NSString* const AVF_TRACKS_KEY       = @"tracks";
+static NSString* const AVF_PLAYABLE_KEY     = @"playable";
+
+//AVPlayerItem keys
+static NSString* const AVF_STATUS_KEY                   = @"status";
+static NSString* const AVF_BUFFER_LIKELY_KEEP_UP_KEY    = @"playbackLikelyToKeepUp";
+
+//AVPlayer keys
+static NSString* const AVF_RATE_KEY                     = @"rate";
+static NSString* const AVF_CURRENT_ITEM_KEY             = @"currentItem";
+static NSString* const AVF_CURRENT_ITEM_DURATION_KEY    = @"currentItem.duration";
+
+static void *AVFMediaPlayerObserverRateObservationContext = &AVFMediaPlayerObserverRateObservationContext;
+static void *AVFMediaPlayerObserverStatusObservationContext = &AVFMediaPlayerObserverStatusObservationContext;
+static void *AVFMediaPlayerObserverBufferLikelyToKeepUpContext = &AVFMediaPlayerObserverBufferLikelyToKeepUpContext;
+static void *AVFMediaPlayerObserverTracksContext = &AVFMediaPlayerObserverTracksContext;
+static void *AVFMediaPlayerObserverCurrentItemObservationContext = &AVFMediaPlayerObserverCurrentItemObservationContext;
+static void *AVFMediaPlayerObserverCurrentItemDurationObservationContext = &AVFMediaPlayerObserverCurrentItemDurationObservationContext;
+
+@interface AVFMediaPlayerObserver : NSObject<AVAssetResourceLoaderDelegate>
+
+@property (readonly, getter=player) AVPlayer* m_player;
+@property (readonly, getter=playerItem) AVPlayerItem* m_playerItem;
+@property (readonly, getter=playerLayer) AVPlayerLayer* m_playerLayer;
+@property (readonly, getter=session) AVFMediaPlayer* m_session;
+@property (retain) AVPlayerItemTrack *videoTrack;
+
+- (AVFMediaPlayerObserver *) initWithMediaPlayerSession:(AVFMediaPlayer *)session;
+- (void) setURL:(NSURL *)url mimeType:(NSString *)mimeType;
+- (void) unloadMedia;
+- (void) prepareToPlayAsset:(AVURLAsset *)asset withKeys:(NSArray *)requestedKeys;
+- (void) assetFailedToPrepareForPlayback:(NSError *)error;
+- (void) playerItemDidReachEnd:(NSNotification *)notification;
+- (void) playerItemTimeJumped:(NSNotification *)notification;
+- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
+                         change:(NSDictionary *)change context:(void *)context;
+- (void) detatchSession;
+- (void) dealloc;
+- (BOOL) resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest;
+@end
+
+@implementation AVFMediaPlayerObserver
+{
+@private
+    AVFMediaPlayer *m_session;
+    AVPlayer *m_player;
+    AVPlayerItem *m_playerItem;
+    AVPlayerLayer *m_playerLayer;
+    NSURL *m_URL;
+    BOOL m_bufferIsLikelyToKeepUp;
+    NSData *m_data;
+    NSString *m_mimeType;
+}
+
+@synthesize m_player, m_playerItem, m_playerLayer, m_session;
+
+- (AVFMediaPlayerObserver *) initWithMediaPlayerSession:(AVFMediaPlayer *)session
+{
+    if (!(self = [super init]))
+        return nil;
+
+    self->m_session = session;
+    self->m_bufferIsLikelyToKeepUp = FALSE;
+    return self;
+}
+
+- (void) setURL:(NSURL *)url mimeType:(NSString *)mimeType
 {
-    setSession(new AVFMediaPlayerSession(this));
+    [m_mimeType release];
+    m_mimeType = [mimeType retain];
+
+    if (m_URL != url)
+    {
+        [m_URL release];
+        m_URL = [url copy];
+
+        //Create an asset for inspection of a resource referenced by a given URL.
+        //Load the values for the asset keys "tracks", "playable".
+
+        // use __block to avoid maintaining strong references on variables captured by the
+        // following block callback
+        __block AVURLAsset *asset = [[AVURLAsset URLAssetWithURL:m_URL options:nil] retain];
+        [asset.resourceLoader setDelegate:self queue:dispatch_get_main_queue()];
+
+        __block NSArray *requestedKeys = [[NSArray arrayWithObjects:AVF_TRACKS_KEY, AVF_PLAYABLE_KEY, nil] retain];
+
+        __block AVFMediaPlayerObserver *blockSelf = self;
+        QPointer<AVFMediaPlayer> session(m_session);
+
+        // Tells the asset to load the values of any of the specified keys that are not already loaded.
+        [asset loadValuesAsynchronouslyForKeys:requestedKeys completionHandler:
+         ^{
+             dispatch_async( dispatch_get_main_queue(),
+                           ^{
+                                if (session)
+                                    [blockSelf prepareToPlayAsset:asset withKeys:requestedKeys];
+                                 [asset release];
+                                 [requestedKeys release];
+                            });
+         }];
+    }
+}
+
+- (void) unloadMedia
+{
+    if (m_playerItem) {
+        [m_playerItem removeObserver:self forKeyPath:AVF_STATUS_KEY];
+        [m_playerItem removeObserver:self forKeyPath:AVF_BUFFER_LIKELY_KEEP_UP_KEY];
+        [m_playerItem removeObserver:self forKeyPath:AVF_TRACKS_KEY];
+
+        [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                    name:AVPlayerItemDidPlayToEndTimeNotification
+                                                    object:m_playerItem];
+        [[NSNotificationCenter defaultCenter] removeObserver:self
+                                                    name:AVPlayerItemTimeJumpedNotification
+                                                    object:m_playerItem];
+        m_playerItem = 0;
+    }
+    if (m_player) {
+        [m_player setRate:0.0];
+        [m_player removeObserver:self forKeyPath:AVF_CURRENT_ITEM_DURATION_KEY];
+        [m_player removeObserver:self forKeyPath:AVF_CURRENT_ITEM_KEY];
+        [m_player removeObserver:self forKeyPath:AVF_RATE_KEY];
+        [m_player release];
+        m_player = 0;
+    }
+    if (m_playerLayer) {
+        [m_playerLayer release];
+        m_playerLayer = 0;
+    }
+#if defined(Q_OS_IOS)
+    [[AVAudioSession sharedInstance] setActive:NO error:nil];
+#endif
+}
+
+- (void) prepareToPlayAsset:(AVURLAsset *)asset
+                   withKeys:(NSArray *)requestedKeys
+{
+    //Make sure that the value of each key has loaded successfully.
+    for (NSString *thisKey in requestedKeys)
+    {
+        NSError *error = nil;
+        AVKeyValueStatus keyStatus = [asset statusOfValueForKey:thisKey error:&error];
+#ifdef QT_DEBUG_AVF
+        qDebug() << Q_FUNC_INFO << [thisKey UTF8String] << " status: " << keyStatus;
+#endif
+        if (keyStatus == AVKeyValueStatusFailed)
+        {
+            [self assetFailedToPrepareForPlayback:error];
+            return;
+        }
+    }
+
+    //Use the AVAsset playable property to detect whether the asset can be played.
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << "isPlayable: " << [asset isPlayable];
+#endif
+    if (!asset.playable)
+    {
+        //Generate an error describing the failure.
+        NSString *localizedDescription = NSLocalizedString(@"Item cannot be played", @"Item cannot be played description");
+        NSString *localizedFailureReason = NSLocalizedString(@"The assets tracks were loaded, but could not be made playable.", @"Item cannot be played failure reason");
+        NSDictionary *errorDict = [NSDictionary dictionaryWithObjectsAndKeys:
+                localizedDescription, NSLocalizedDescriptionKey,
+                localizedFailureReason, NSLocalizedFailureReasonErrorKey,
+                nil];
+        NSError *assetCannotBePlayedError = [NSError errorWithDomain:@"StitchedStreamPlayer" code:0 userInfo:errorDict];
+
+        [self assetFailedToPrepareForPlayback:assetCannotBePlayedError];
+
+        return;
+    }
+
+    //At this point we're ready to set up for playback of the asset.
+    //Stop observing our prior AVPlayerItem, if we have one.
+    if (m_playerItem)
+    {
+        //Remove existing player item key value observers and notifications.
+        [self unloadMedia];
+    }
+
+    //Create a new instance of AVPlayerItem from the now successfully loaded AVAsset.
+    m_playerItem = [AVPlayerItem playerItemWithAsset:asset];
+
+    //Observe the player item "status" key to determine when it is ready to play.
+    [m_playerItem addObserver:self
+                   forKeyPath:AVF_STATUS_KEY
+                      options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
+                      context:AVFMediaPlayerObserverStatusObservationContext];
+
+    [m_playerItem addObserver:self
+                   forKeyPath:AVF_BUFFER_LIKELY_KEEP_UP_KEY
+                      options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
+                      context:AVFMediaPlayerObserverBufferLikelyToKeepUpContext];
+
+    [m_playerItem addObserver:self
+                   forKeyPath:AVF_TRACKS_KEY
+                      options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
+                      context:AVFMediaPlayerObserverTracksContext];
+
+    //When the player item has played to its end time we'll toggle
+    //the movie controller Pause button to be the Play button
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(playerItemDidReachEnd:)
+                                                 name:AVPlayerItemDidPlayToEndTimeNotification
+                                               object:m_playerItem];
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(playerItemTimeJumped:)
+                                                 name:AVPlayerItemTimeJumpedNotification
+                                               object:m_playerItem];
+
+    //Get a new AVPlayer initialized to play the specified player item.
+    m_player = [AVPlayer playerWithPlayerItem:m_playerItem];
+    [m_player retain];
+
+    //Set the initial volume on new player object
+    if (self.session) {
+        [m_player setVolume:m_session->volume() / 100.0f];
+        [m_player setMuted:m_session->isMuted()];
+    }
+
+    //Create a new player layer if we don't have one already
+    if (!m_playerLayer)
+    {
+        m_playerLayer = [AVPlayerLayer playerLayerWithPlayer:m_player];
+        [m_playerLayer retain];
+        m_playerLayer.videoGravity = AVLayerVideoGravityResizeAspectFill;
+        m_playerLayer.anchorPoint = CGPointMake(0.0f, 0.0f);
+    }
+
+    //Observe the AVPlayer "currentItem" property to find out when any
+    //AVPlayer replaceCurrentItemWithPlayerItem: replacement will/did
+    //occur.
+    [m_player addObserver:self
+                          forKeyPath:AVF_CURRENT_ITEM_KEY
+                          options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
+                          context:AVFMediaPlayerObserverCurrentItemObservationContext];
+
+    //Observe the AVPlayer "rate" property to update the scrubber control.
+    [m_player addObserver:self
+                          forKeyPath:AVF_RATE_KEY
+                          options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
+                          context:AVFMediaPlayerObserverRateObservationContext];
+
+    //Observe the duration for getting the buffer state
+    [m_player addObserver:self
+                          forKeyPath:AVF_CURRENT_ITEM_DURATION_KEY
+                          options:0
+                          context:AVFMediaPlayerObserverCurrentItemDurationObservationContext];
+#if defined(Q_OS_IOS)
+    [[AVAudioSession sharedInstance] setCategory:AVAudioSessionCategoryPlayback withOptions:AVAudioSessionCategoryOptionMixWithOthers error:nil];
+    [[AVAudioSession sharedInstance] setActive:YES error:nil];
+#endif
+}
+
+-(void) assetFailedToPrepareForPlayback:(NSError *)error
+{
+    Q_UNUSED(error);
+    QMetaObject::invokeMethod(m_session, "processMediaLoadError", Qt::AutoConnection);
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO;
+    qDebug() << [[error localizedDescription] UTF8String];
+    qDebug() << [[error localizedFailureReason] UTF8String];
+    qDebug() << [[error localizedRecoverySuggestion] UTF8String];
+#endif
+}
+
+- (void) playerItemDidReachEnd:(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+    if (self.session)
+        QMetaObject::invokeMethod(m_session, "processEOS", Qt::AutoConnection);
+}
+
+- (void) playerItemTimeJumped:(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+    if (self.session)
+        QMetaObject::invokeMethod(m_session, "processPositionChange", Qt::AutoConnection);
+}
+
+- (void) observeValueForKeyPath:(NSString*) path
+                       ofObject:(id)object
+                         change:(NSDictionary*)change
+                        context:(void*)context
+{
+    //AVPlayerItem "status" property value observer.
+    if (context == AVFMediaPlayerObserverStatusObservationContext)
+    {
+        AVPlayerStatus status = (AVPlayerStatus)[[change objectForKey:NSKeyValueChangeNewKey] integerValue];
+        switch (status)
+        {
+            //Indicates that the status of the player is not yet known because
+            //it has not tried to load new media resources for playback
+            case AVPlayerStatusUnknown:
+            {
+                //QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
+            }
+            break;
+
+            case AVPlayerStatusReadyToPlay:
+            {
+                //Once the AVPlayerItem becomes ready to play, i.e.
+                //[playerItem status] == AVPlayerItemStatusReadyToPlay,
+                //its duration can be fetched from the item.
+                if (self.session)
+                    QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
+            }
+            break;
+
+            case AVPlayerStatusFailed:
+            {
+                AVPlayerItem *playerItem = static_cast<AVPlayerItem*>(object);
+                [self assetFailedToPrepareForPlayback:playerItem.error];
+
+                if (self.session)
+                    QMetaObject::invokeMethod(m_session, "processLoadStateFailure", Qt::AutoConnection);
+            }
+            break;
+        }
+    }
+    else if (context == AVFMediaPlayerObserverBufferLikelyToKeepUpContext)
+    {
+        const bool isPlaybackLikelyToKeepUp = [m_playerItem isPlaybackLikelyToKeepUp];
+        if (isPlaybackLikelyToKeepUp != m_bufferIsLikelyToKeepUp) {
+            m_bufferIsLikelyToKeepUp = isPlaybackLikelyToKeepUp;
+            QMetaObject::invokeMethod(m_session, "processBufferStateChange", Qt::AutoConnection,
+                                      Q_ARG(int, isPlaybackLikelyToKeepUp ? 100 : 0));
+        }
+    }
+    else if (context == AVFMediaPlayerObserverTracksContext)
+    {
+        QMetaObject::invokeMethod(m_session, "updateTracks", Qt::AutoConnection);
+    }
+    //AVPlayer "rate" property value observer.
+    else if (context == AVFMediaPlayerObserverRateObservationContext)
+    {
+        //QMetaObject::invokeMethod(m_session, "setPlaybackRate",  Qt::AutoConnection, Q_ARG(qreal, [m_player rate]));
+    }
+    //AVPlayer "currentItem" property observer.
+    //Called when the AVPlayer replaceCurrentItemWithPlayerItem:
+    //replacement will/did occur.
+    else if (context == AVFMediaPlayerObserverCurrentItemObservationContext)
+    {
+        AVPlayerItem *newPlayerItem = [change objectForKey:NSKeyValueChangeNewKey];
+        if (m_playerItem != newPlayerItem)
+            m_playerItem = newPlayerItem;
+    }
+    else if (context == AVFMediaPlayerObserverCurrentItemDurationObservationContext)
+    {
+        const CMTime time = [m_playerItem duration];
+        const qint64 duration =  static_cast<qint64>(float(time.value) / float(time.timescale) * 1000.0f);
+        if (self.session)
+            QMetaObject::invokeMethod(m_session, "processDurationChange",  Qt::AutoConnection, Q_ARG(qint64, duration));
+    }
+    else
+    {
+        [super observeValueForKeyPath:path ofObject:object change:change context:context];
+    }
+}
+
+- (void) detatchSession
+{
+#ifdef QT_DEBUG_AVF
+        qDebug() << Q_FUNC_INFO;
+#endif
+        m_session = 0;
+}
+
+- (void) dealloc
+{
+#ifdef QT_DEBUG_AVF
+        qDebug() << Q_FUNC_INFO;
+#endif
+    [self unloadMedia];
+
+    if (m_URL) {
+        [m_URL release];
+    }
+
+    [m_mimeType release];
+    [super dealloc];
+}
+
+- (BOOL) resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest
+{
+    Q_UNUSED(resourceLoader);
+
+    if (![loadingRequest.request.URL.scheme isEqualToString:@"iodevice"])
+        return NO;
+
+    QIODevice *device = m_session->mediaStream();
+    if (!device)
+        return NO;
+
+    device->seek(loadingRequest.dataRequest.requestedOffset);
+    if (loadingRequest.contentInformationRequest) {
+        loadingRequest.contentInformationRequest.contentType = m_mimeType;
+        loadingRequest.contentInformationRequest.contentLength = device->size();
+        loadingRequest.contentInformationRequest.byteRangeAccessSupported = YES;
+    }
+
+    if (loadingRequest.dataRequest) {
+        NSInteger requestedLength = loadingRequest.dataRequest.requestedLength;
+        int maxBytes = qMin(32 * 1064, int(requestedLength));
+        char buffer[maxBytes];
+        NSInteger submitted = 0;
+        while (submitted < requestedLength) {
+            qint64 len = device->read(buffer, maxBytes);
+            if (len < 1)
+                break;
+
+            [loadingRequest.dataRequest respondWithData:[NSData dataWithBytes:buffer length:len]];
+            submitted += len;
+        }
+
+        // Finish loading even if not all bytes submitted.
+        [loadingRequest finishLoading];
+    }
+
+    return YES;
+}
+@end
+
+AVFMediaPlayer::AVFMediaPlayer(QMediaPlayer *player)
+    : QObject(player)
+    , QPlatformMediaPlayer(player)
+    , m_videoOutput(nullptr)
+    , m_state(QMediaPlayer::StoppedState)
+    , m_mediaStatus(QMediaPlayer::NoMedia)
+    , m_mediaStream(nullptr)
+    , m_muted(false)
+    , m_tryingAsync(false)
+    , m_volume(100)
+    , m_rate(1.0)
+    , m_requestedPosition(-1)
+    , m_duration(0)
+    , m_bufferStatus(0)
+    , m_videoAvailable(false)
+    , m_audioAvailable(false)
+    , m_seekable(false)
+{
+    m_observer = [[AVFMediaPlayerObserver alloc] initWithMediaPlayerSession:this];
+    setVideoOutput(new AVFVideoRendererControl(this));
 }
 
 AVFMediaPlayer::~AVFMediaPlayer()
@@ -53,197 +503,664 @@ AVFMediaPlayer::~AVFMediaPlayer()
 #ifdef QT_DEBUG_AVF
     qDebug() << Q_FUNC_INFO;
 #endif
+    //Detatch the session from the sessionObserver (which could still be alive trying to communicate with this session).
+    [m_observer detatchSession];
+    [static_cast<AVFMediaPlayerObserver*>(m_observer) release];
 }
 
-void AVFMediaPlayer::setSession(AVFMediaPlayerSession *session)
+void AVFMediaPlayer::setVideoSurface(QAbstractVideoSurface *surface)
 {
-    m_session = session;
+    m_videoOutput->setSurface(surface);
+}
+
+void AVFMediaPlayer::setVideoOutput(AVFVideoRendererControl *output)
+{
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << output;
+#endif
+
+    if (m_videoOutput == output)
+        return;
+
+    //Set the current output layer to null to stop rendering
+    if (m_videoOutput) {
+        m_videoOutput->setLayer(nullptr);
+    }
+
+    m_videoOutput = output;
+
+    if (m_videoOutput && m_state != QMediaPlayer::StoppedState)
+        m_videoOutput->setLayer([static_cast<AVFMediaPlayerObserver*>(m_observer) playerLayer]);
+}
 
-    connect(m_session, SIGNAL(positionChanged(qint64)), this, SIGNAL(positionChanged(qint64)));
-    connect(m_session, SIGNAL(durationChanged(qint64)), this, SIGNAL(durationChanged(qint64)));
-    connect(m_session, SIGNAL(bufferStatusChanged(int)), this, SIGNAL(bufferStatusChanged(int)));
-    connect(m_session, SIGNAL(stateChanged(QMediaPlayer::State)),
-            this, SIGNAL(stateChanged(QMediaPlayer::State)));
-    connect(m_session, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
-            this, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
-    connect(m_session, SIGNAL(volumeChanged(int)), this, SIGNAL(volumeChanged(int)));
-    connect(m_session, SIGNAL(mutedChanged(bool)), this, SIGNAL(mutedChanged(bool)));
-    connect(m_session, SIGNAL(audioAvailableChanged(bool)), this, SIGNAL(audioAvailableChanged(bool)));
-    connect(m_session, SIGNAL(videoAvailableChanged(bool)), this, SIGNAL(videoAvailableChanged(bool)));
-    connect(m_session, SIGNAL(error(int,QString)), this, SIGNAL(error(int,QString)));
-    connect(m_session, &AVFMediaPlayerSession::playbackRateChanged,
-            this, &AVFMediaPlayer::playbackRateChanged);
-    connect(m_session, &AVFMediaPlayerSession::seekableChanged,
-            this, &AVFMediaPlayer::seekableChanged);
+AVAsset *AVFMediaPlayer::currentAssetHandle()
+{
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO;
+#endif
+    AVAsset *currentAsset = [[static_cast<AVFMediaPlayerObserver*>(m_observer) playerItem] asset];
+    return currentAsset;
 }
 
 QMediaPlayer::State AVFMediaPlayer::state() const
 {
-    return m_session->state();
+    return m_state;
 }
 
 QMediaPlayer::MediaStatus AVFMediaPlayer::mediaStatus() const
 {
-    return m_session->mediaStatus();
+    return m_mediaStatus;
 }
 
 QUrl AVFMediaPlayer::media() const
 {
-    return m_session->media();
+    return m_resources;
+}
+
+QIODevice *AVFMediaPlayer::mediaStream() const
+{
+    return m_mediaStream;
+}
+
+static void setURL(AVFMediaPlayerObserver *observer, const QByteArray &url, const QString &mimeType = QString())
+{
+    NSString *urlString = [NSString stringWithUTF8String:url.constData()];
+    NSURL *nsurl = [NSURL URLWithString:urlString];
+    [observer setURL:nsurl mimeType:[NSString stringWithUTF8String:mimeType.toLatin1().constData()]];
 }
 
-const QIODevice *AVFMediaPlayer::mediaStream() const
+static void setStreamURL(AVFMediaPlayerObserver *observer, const QByteArray &url)
 {
-    return m_session->mediaStream();
+    setURL(observer, QByteArrayLiteral("iodevice://") + url, QFileInfo(QString::fromUtf8(url)).suffix());
 }
 
 void AVFMediaPlayer::setMedia(const QUrl &content, QIODevice *stream)
 {
-    const QUrl oldContent = m_session->media();
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << content.request().url();
+#endif
+
+    [static_cast<AVFMediaPlayerObserver*>(m_observer) unloadMedia];
+
+    m_resources = content;
+    resetStream(stream);
+
+    setAudioAvailable(false);
+    setVideoAvailable(false);
+    setSeekable(false);
+    m_requestedPosition = -1;
+    Q_EMIT positionChanged(position());
+
+    const QMediaPlayer::MediaStatus oldMediaStatus = m_mediaStatus;
+    const QMediaPlayer::State oldState = m_state;
+
+    if (!m_mediaStream && content.isEmpty()) {
+        m_mediaStatus = QMediaPlayer::NoMedia;
+        if (m_mediaStatus != oldMediaStatus)
+            Q_EMIT mediaStatusChanged(m_mediaStatus);
 
-    m_session->setMedia(content, stream);
+        m_state = QMediaPlayer::StoppedState;
+        if (m_state != oldState)
+            Q_EMIT stateChanged(m_state);
+
+        return;
+    }
+
+    m_mediaStatus = QMediaPlayer::LoadingMedia;
+    if (m_mediaStatus != oldMediaStatus)
+        Q_EMIT mediaStatusChanged(m_mediaStatus);
+
+    if (m_mediaStream) {
+        // If there is a data, try to load it,
+        // otherwise wait for readyRead.
+        if (m_mediaStream->size())
+            setStreamURL(m_observer, m_resources.toEncoded());
+    } else {
+        //Load AVURLAsset
+        //initialize asset using content's URL
+        setURL(m_observer, m_resources.toEncoded());
+    }
+
+    m_state = QMediaPlayer::StoppedState;
+    if (m_state != oldState)
+        Q_EMIT stateChanged(m_state);
 }
 
 qint64 AVFMediaPlayer::position() const
 {
-    return m_session->position();
+    AVPlayerItem *playerItem = [static_cast<AVFMediaPlayerObserver*>(m_observer) playerItem];
+
+    if (!playerItem)
+        return m_requestedPosition != -1 ? m_requestedPosition : 0;
+
+    CMTime time = [playerItem currentTime];
+    return static_cast<quint64>(float(time.value) / float(time.timescale) * 1000.0f);
 }
 
 qint64 AVFMediaPlayer::duration() const
 {
-    return m_session->duration();
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO;
+#endif
+    return m_duration;
 }
 
 int AVFMediaPlayer::bufferStatus() const
 {
-    return m_session->bufferStatus();
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO;
+#endif
+    return m_bufferStatus;
 }
 
 int AVFMediaPlayer::volume() const
 {
-    return m_session->volume();
+    return m_volume;
 }
 
 bool AVFMediaPlayer::isMuted() const
 {
-    return m_session->isMuted();
+    return m_muted;
+}
+
+void AVFMediaPlayer::setAudioAvailable(bool available)
+{
+    if (m_audioAvailable == available)
+        return;
+
+    m_audioAvailable = available;
+    Q_EMIT audioAvailableChanged(available);
 }
 
 bool AVFMediaPlayer::isAudioAvailable() const
 {
-    return m_session->isAudioAvailable();
+    return m_audioAvailable;
+}
+
+void AVFMediaPlayer::setVideoAvailable(bool available)
+{
+    if (m_videoAvailable == available)
+        return;
+
+    m_videoAvailable = available;
+    Q_EMIT videoAvailableChanged(available);
 }
 
 bool AVFMediaPlayer::isVideoAvailable() const
 {
-    return m_session->isVideoAvailable();
+    return m_videoAvailable;
 }
 
 bool AVFMediaPlayer::isSeekable() const
 {
-    return m_session->isSeekable();
+    return m_seekable;
 }
 
-QMediaTimeRange AVFMediaPlayer::availablePlaybackRanges() const
+void AVFMediaPlayer::setSeekable(bool seekable)
 {
-    return m_session->availablePlaybackRanges();
+    if (m_seekable == seekable)
+        return;
+
+    m_seekable = seekable;
+    Q_EMIT seekableChanged(seekable);
 }
 
-qreal AVFMediaPlayer::playbackRate() const
+QMediaTimeRange AVFMediaPlayer::availablePlaybackRanges() const
 {
-    return m_session->playbackRate();
+    AVPlayerItem *playerItem = [static_cast<AVFMediaPlayerObserver*>(m_observer) playerItem];
+
+    if (playerItem) {
+        QMediaTimeRange timeRanges;
+
+        NSArray *ranges = [playerItem loadedTimeRanges];
+        for (NSValue *timeRange in ranges) {
+            CMTimeRange currentTimeRange = [timeRange CMTimeRangeValue];
+            qint64 startTime = qint64(float(currentTimeRange.start.value) / currentTimeRange.start.timescale * 1000.0);
+            timeRanges.addInterval(startTime, startTime + qint64(float(currentTimeRange.duration.value) / currentTimeRange.duration.timescale * 1000.0));
+        }
+        if (!timeRanges.isEmpty())
+            return timeRanges;
+    }
+    return QMediaTimeRange(0, duration());
 }
 
-void AVFMediaPlayer::setPlaybackRate(qreal rate)
+qreal AVFMediaPlayer::playbackRate() const
 {
-    m_session->setPlaybackRate(rate);
+    return m_rate;
 }
 
 bool AVFMediaPlayer::setAudioOutput(const QAudioDeviceInfo &info)
 {
-#ifdef Q_OS_IOS
-    Q_UNUSED(info);
-    return false;
-#else
-    return m_session->setAudioOutput(info);
+    m_audioOutput = info;
+
+#ifdef Q_OS_MACOS
+    AVPlayer *player = [static_cast<AVFMediaPlayerObserver*>(m_observer) player];
+    if (info.isNull()) {
+        player.audioOutputDeviceUniqueID = nil;
+    } else {
+        NSString *str = QString::fromUtf8(info.id()).toNSString();
+        player.audioOutputDeviceUniqueID = str;
+    }
 #endif
+    return true;
 }
 
 QAudioDeviceInfo AVFMediaPlayer::audioOutput() const
 {
-#ifdef Q_OS_IOS
-    return QAudioDeviceInfo();
-#else
-    return m_session->audioOutput();
-#endif
+    return m_audioOutput;
 }
 
-QMediaMetaData AVFMediaPlayer::metaData() const
+void AVFMediaPlayer::setPlaybackRate(qreal rate)
 {
-    return m_metaData;
-}
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << rate;
+#endif
 
-void AVFMediaPlayer::setMetaData(const QMediaMetaData &metaData)
-{
-    m_metaData = metaData;
-    metaDataChanged();
+    if (qFuzzyCompare(m_rate, rate))
+        return;
+
+    m_rate = rate;
+
+    AVPlayer *player = [static_cast<AVFMediaPlayerObserver*>(m_observer) player];
+    if (player && m_state == QMediaPlayer::PlayingState)
+        [player setRate:m_rate];
+
+    Q_EMIT playbackRateChanged(m_rate);
 }
 
 void AVFMediaPlayer::setPosition(qint64 pos)
 {
-    m_session->setPosition(pos);
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << pos;
+#endif
+
+    if (pos == position())
+        return;
+
+    AVPlayerItem *playerItem = [static_cast<AVFMediaPlayerObserver*>(m_observer) playerItem];
+    if (!playerItem) {
+        m_requestedPosition = pos;
+        Q_EMIT positionChanged(m_requestedPosition);
+        return;
+    }
+
+    if (!isSeekable()) {
+        if (m_requestedPosition != -1) {
+            m_requestedPosition = -1;
+            Q_EMIT positionChanged(position());
+        }
+        return;
+    }
+
+    pos = qMax(qint64(0), pos);
+    if (duration() > 0)
+        pos = qMin(pos, duration());
+
+    CMTime newTime = [playerItem currentTime];
+    newTime.value = (pos / 1000.0f) * newTime.timescale;
+    [playerItem seekToTime:newTime toleranceBefore:kCMTimeZero toleranceAfter:kCMTimeZero completionHandler:nil];
+
+    Q_EMIT positionChanged(pos);
+
+    // Reset media status if the current status is EndOfMedia
+    if (m_mediaStatus == QMediaPlayer::EndOfMedia) {
+        QMediaPlayer::MediaStatus newMediaStatus = (m_state == QMediaPlayer::PausedState) ? QMediaPlayer::BufferedMedia
+                                                                                          : QMediaPlayer::LoadedMedia;
+        Q_EMIT mediaStatusChanged((m_mediaStatus = newMediaStatus));
+    }
 }
 
 void AVFMediaPlayer::play()
 {
-    m_session->play();
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << "currently: " << m_state;
+#endif
+
+    if (m_mediaStatus == QMediaPlayer::NoMedia || m_mediaStatus == QMediaPlayer::InvalidMedia)
+        return;
+
+    if (m_state == QMediaPlayer::PlayingState)
+        return;
+
+    if (m_videoOutput) {
+        m_videoOutput->setLayer([static_cast<AVFMediaPlayerObserver*>(m_observer) playerLayer]);
+    }
+
+    // Reset media status if the current status is EndOfMedia
+    if (m_mediaStatus == QMediaPlayer::EndOfMedia)
+        setPosition(0);
+
+    if (m_mediaStatus == QMediaPlayer::LoadedMedia || m_mediaStatus == QMediaPlayer::BufferedMedia) {
+        // Setting the rate starts playback
+        [[static_cast<AVFMediaPlayerObserver*>(m_observer) player] setRate:m_rate];
+    }
+
+    m_state = QMediaPlayer::PlayingState;
+    processLoadStateChange();
+
+    Q_EMIT stateChanged(m_state);
 }
 
 void AVFMediaPlayer::pause()
 {
-    m_session->pause();
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << "currently: " << m_state;
+#endif
+
+    if (m_mediaStatus == QMediaPlayer::NoMedia)
+        return;
+
+    if (m_state == QMediaPlayer::PausedState)
+        return;
+
+    m_state = QMediaPlayer::PausedState;
+
+    if (m_videoOutput) {
+        m_videoOutput->setLayer([static_cast<AVFMediaPlayerObserver*>(m_observer) playerLayer]);
+    }
+
+    [[static_cast<AVFMediaPlayerObserver*>(m_observer) player] pause];
+
+    // Reset media status if the current status is EndOfMedia
+    if (m_mediaStatus == QMediaPlayer::EndOfMedia)
+        setPosition(0);
+
+
+    Q_EMIT stateChanged(m_state);
 }
 
 void AVFMediaPlayer::stop()
 {
-    m_session->stop();
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << "currently: " << m_state;
+#endif
+
+    if (m_state == QMediaPlayer::StoppedState)
+        return;
+
+    // AVPlayer doesn't have stop(), only pause() and play().
+    [[static_cast<AVFMediaPlayerObserver*>(m_observer) player] pause];
+    setPosition(0);
+
+    if (m_videoOutput) {
+        m_videoOutput->setLayer(nullptr);
+    }
+
+    if (m_mediaStatus == QMediaPlayer::BufferedMedia)
+        Q_EMIT mediaStatusChanged((m_mediaStatus = QMediaPlayer::LoadedMedia));
+
+    Q_EMIT positionChanged(position());
+    Q_EMIT stateChanged((m_state = QMediaPlayer::StoppedState));
 }
 
 void AVFMediaPlayer::setVolume(int volume)
 {
-    m_session->setVolume(volume);
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << volume;
+#endif
+
+    if (m_volume == volume)
+        return;
+
+    m_volume = volume;
+
+    AVPlayer *player = [static_cast<AVFMediaPlayerObserver*>(m_observer) player];
+    if (player)
+        [player setVolume:volume / 100.0f];
+
+    Q_EMIT volumeChanged(m_volume);
 }
 
 void AVFMediaPlayer::setMuted(bool muted)
 {
-    m_session->setMuted(muted);
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << muted;
+#endif
+
+    if (m_muted == muted)
+        return;
+
+    m_muted = muted;
+
+    AVPlayer *player = [static_cast<AVFMediaPlayerObserver*>(m_observer) player];
+    if (player)
+        [player setMuted:muted];
+
+    Q_EMIT mutedChanged(muted);
 }
 
-void AVFMediaPlayer::setVideoSurface(QAbstractVideoSurface *surface)
+void AVFMediaPlayer::processEOS()
+{
+    //AVPlayerItem has reached end of track/stream
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO;
+#endif
+    Q_EMIT positionChanged(position());
+    m_mediaStatus = QMediaPlayer::EndOfMedia;
+    m_state = QMediaPlayer::StoppedState;
+
+    // At this point, frames should not be rendered anymore.
+    // Clear the output layer to make sure of that.
+    if (m_videoOutput)
+        m_videoOutput->setLayer(nullptr);
+
+    Q_EMIT mediaStatusChanged(m_mediaStatus);
+    Q_EMIT stateChanged(m_state);
+}
+
+void AVFMediaPlayer::processLoadStateChange(QMediaPlayer::State newState)
 {
-    m_session->setVideoSurface(surface);
+    AVPlayerStatus currentStatus = [[static_cast<AVFMediaPlayerObserver*>(m_observer) player] status];
+
+#ifdef QT_DEBUG_AVF
+    qDebug() << Q_FUNC_INFO << currentStatus << ", " << m_mediaStatus << ", " << newState;
+#endif
+
+    if (m_mediaStatus == QMediaPlayer::NoMedia)
+        return;
+
+    if (currentStatus == AVPlayerStatusReadyToPlay) {
+
+        QMediaPlayer::MediaStatus newStatus = m_mediaStatus;
+
+        AVPlayerItem *playerItem = [m_observer playerItem];
+
+        // get the meta data
+        m_metaData = AVFMetaData::fromAsset(playerItem.asset);
+        Q_EMIT metaDataChanged();
+        updateTracks();
+
+        if (playerItem) {
+            setSeekable([[playerItem seekableTimeRanges] count] > 0);
+
+            // Get the native size of the video, and reset the bounds of the player layer
+            AVPlayerLayer *playerLayer = [m_observer playerLayer];
+            if (m_observer.videoTrack && playerLayer) {
+                if (!playerLayer.bounds.size.width || !playerLayer.bounds.size.height) {
+                    playerLayer.bounds = CGRectMake(0.0f, 0.0f,
+                                                    m_observer.videoTrack.assetTrack.naturalSize.width,
+                                                    m_observer.videoTrack.assetTrack.naturalSize.height);
+                }
+
+                if (m_videoOutput && newState != QMediaPlayer::StoppedState) {
+                    m_videoOutput->setLayer(playerLayer);
+                }
+            }
+
+            if (m_requestedPosition != -1) {
+                setPosition(m_requestedPosition);
+                m_requestedPosition = -1;
+            }
+        }
+
+        newStatus = (newState != QMediaPlayer::StoppedState) ? QMediaPlayer::BufferedMedia
+                                                             : QMediaPlayer::LoadedMedia;
+
+        if (newStatus != m_mediaStatus)
+            Q_EMIT mediaStatusChanged((m_mediaStatus = newStatus));
+
+    }
+
+    if (newState == QMediaPlayer::PlayingState && [static_cast<AVFMediaPlayerObserver*>(m_observer) player]) {
+        // Setting the rate is enough to start playback, no need to call play()
+        [[static_cast<AVFMediaPlayerObserver*>(m_observer) player] setRate:m_rate];
+    }
 }
 
-int AVFMediaPlayer::trackCount(QPlatformMediaPlayer::TrackType type)
+
+void AVFMediaPlayer::processLoadStateChange()
 {
-    return m_session->tracks[type].count();
+    processLoadStateChange(m_state);
 }
 
-QMediaMetaData AVFMediaPlayer::trackMetaData(QPlatformMediaPlayer::TrackType type, int index)
+
+void AVFMediaPlayer::processLoadStateFailure()
 {
-    const auto &tracks = m_session->tracks[type];
-    if (index < 0 || index >= tracks.size())
-        return QMediaMetaData();
-    return tracks.at(index);
+    Q_EMIT stateChanged((m_state = QMediaPlayer::StoppedState));
 }
 
-int AVFMediaPlayer::activeTrack(QPlatformMediaPlayer::TrackType type)
+void AVFMediaPlayer::processBufferStateChange(int bufferStatus)
+{
+    if (bufferStatus == m_bufferStatus)
+        return;
+
+    auto status = m_mediaStatus;
+    // Buffered -> unbuffered.
+    if (!bufferStatus) {
+        status = QMediaPlayer::StalledMedia;
+    } else if (status == QMediaPlayer::StalledMedia) {
+        status = QMediaPlayer::BufferedMedia;
+        // Resume playback.
+        if (m_state == QMediaPlayer::PlayingState)
+            [[static_cast<AVFMediaPlayerObserver*>(m_observer) player] setRate:m_rate];
+    }
+
+    if (m_mediaStatus != status)
+        Q_EMIT mediaStatusChanged(m_mediaStatus = status);
+
+    m_bufferStatus = bufferStatus;
+    Q_EMIT bufferStatusChanged(bufferStatus);
+}
+
+void AVFMediaPlayer::processDurationChange(qint64 duration)
+{
+    if (duration == m_duration)
+        return;
+
+    m_duration = duration;
+    Q_EMIT durationChanged(duration);
+}
+
+void AVFMediaPlayer::processPositionChange()
+{
+    if (m_state == QMediaPlayer::StoppedState)
+        return;
+
+    Q_EMIT positionChanged(position());
+}
+
+void AVFMediaPlayer::processMediaLoadError()
+{
+    if (m_requestedPosition != -1) {
+        m_requestedPosition = -1;
+        Q_EMIT positionChanged(position());
+    }
+
+    Q_EMIT mediaStatusChanged((m_mediaStatus = QMediaPlayer::InvalidMedia));
+
+    Q_EMIT error(QMediaPlayer::FormatError, tr("Failed to load media"));
+}
+
+void AVFMediaPlayer::streamReady()
+{
+    setStreamURL(m_observer, m_resources.toEncoded());
+}
+
+void AVFMediaPlayer::streamDestroyed()
+{
+    resetStream(nullptr);
+}
+
+void AVFMediaPlayer::updateTracks()
 {
-    return m_session->activeTrack(type);
+    for (int i = 0; i < QPlatformMediaPlayer::NTrackTypes; ++i) {
+        tracks[i].clear();
+        nativeTracks[i].clear();
+    }
+    AVPlayerItem *playerItem = [m_observer playerItem];
+    if (playerItem) {
+        // Check each track for audio and video content
+        NSArray *tracks =  playerItem.tracks;
+        for (AVPlayerItemTrack *track in tracks) {
+            AVAssetTrack *assetTrack = track.assetTrack;
+            if (assetTrack) {
+                int qtTrack = -1;
+                if ([assetTrack.mediaType isEqualToString:AVMediaTypeAudio]) {
+                    qtTrack = QPlatformMediaPlayer::AudioStream;
+                    setAudioAvailable(true);
+                } else if ([assetTrack.mediaType isEqualToString:AVMediaTypeVideo]) {
+                    qtTrack = QPlatformMediaPlayer::VideoStream;
+                    setVideoAvailable(true);
+                    if (!m_observer.videoTrack)
+                        m_observer.videoTrack = track;
+                }
+                else if ([assetTrack.mediaType isEqualToString:AVMediaTypeSubtitle]) {
+                    qtTrack = QPlatformMediaPlayer::SubtitleStream;
+                    setVideoAvailable(true);
+                    if (!m_observer.videoTrack)
+                        m_observer.videoTrack = track;
+                }
+                if (qtTrack != -1) {
+                    QMediaMetaData metaData = AVFMetaData::fromAssetTrack(assetTrack);
+                    this->tracks[qtTrack].append(metaData);
+                    nativeTracks[qtTrack].append(track);
+                }
+            }
+        }
+    }
+    Q_EMIT tracksChanged();
 }
 
 void AVFMediaPlayer::setActiveTrack(QPlatformMediaPlayer::TrackType type, int index)
 {
-    m_session->setActiveTrack(type, index);
-// ####
+    const auto &t = nativeTracks[type];
+    for (int i = 0; i < t.count(); ++i)
+        t.at(i).enabled = (i == index);
+}
+
+int AVFMediaPlayer::activeTrack(QPlatformMediaPlayer::TrackType type)
+{
+    const auto &t = nativeTracks[type];
+    for (int i = 0; i < t.count(); ++i)
+        if (t.at(i).enabled)
+            return i;
+    return -1;
+}
+
+int AVFMediaPlayer::trackCount(QPlatformMediaPlayer::TrackType type)
+{
+    return nativeTracks[type].count();
+}
+
+QMediaMetaData AVFMediaPlayer::trackMetaData(QPlatformMediaPlayer::TrackType type, int trackNumber)
+{
+    const auto &t = tracks[type];
+    if (trackNumber < 0 || trackNumber >= t.count())
+        return QMediaMetaData();
+    return t.at(trackNumber);
+}
+
+void AVFMediaPlayer::resetStream(QIODevice *stream)
+{
+    if (m_mediaStream) {
+        disconnect(m_mediaStream, &QIODevice::readyRead, this, &AVFMediaPlayer::streamReady);
+        disconnect(m_mediaStream, &QIODevice::destroyed, this, &AVFMediaPlayer::streamDestroyed);
+    }
+
+    m_mediaStream = stream;
+
+    if (m_mediaStream) {
+        connect(m_mediaStream, &QIODevice::readyRead, this, &AVFMediaPlayer::streamReady);
+        connect(m_mediaStream, &QIODevice::destroyed, this, &AVFMediaPlayer::streamDestroyed);
+    }
 }
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h
index e7b66094f..4b0dfca71 100644
--- a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h
+++ b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h
@@ -51,27 +51,41 @@
 // We mean it.
 //
 
-#include <private/qplatformmediaplayer_p.h>
 #include <QtCore/QObject>
+#include <QtCore/QByteArray>
+#include <QtCore/QSet>
+#include <QtCore/QResource>
+#include <QtCore/QUrl>
+
+#include <private/qplatformmediaplayer_p.h>
+#include <QtMultimedia/QMediaPlayer>
+
+Q_FORWARD_DECLARE_OBJC_CLASS(AVAsset);
+Q_FORWARD_DECLARE_OBJC_CLASS(AVPlayerItemTrack);
+Q_FORWARD_DECLARE_OBJC_CLASS(AVFMediaPlayerObserver);
 
 QT_BEGIN_NAMESPACE
 
-class AVFMediaPlayerSession;
+class AVFMediaPlayer;
+class AVFVideoOutput;
+class AVFVideoRendererControl;
 
-class AVFMediaPlayer : public QPlatformMediaPlayer
+class AVFMediaPlayer : public QObject, public QPlatformMediaPlayer
 {
     Q_OBJECT
 public:
-    explicit AVFMediaPlayer(QMediaPlayer *parent = nullptr);
-    ~AVFMediaPlayer();
+    AVFMediaPlayer(QMediaPlayer *parent);
+    virtual ~AVFMediaPlayer();
 
-    void setSession(AVFMediaPlayerSession *session);
+    void setVideoSurface(QAbstractVideoSurface *surface) override;
+    void setVideoOutput(AVFVideoRendererControl *output);
+    AVAsset *currentAssetHandle();
 
     QMediaPlayer::State state() const override;
     QMediaPlayer::MediaStatus mediaStatus() const override;
 
     QUrl media() const override;
-    const QIODevice *mediaStream() const override;
+    QIODevice *mediaStream() const override;
     void setMedia(const QUrl &content, QIODevice *stream) override;
 
     qint64 position() const override;
@@ -89,22 +103,14 @@ public:
     QMediaTimeRange availablePlaybackRanges() const override;
 
     qreal playbackRate() const override;
-    void setPlaybackRate(qreal rate) override;
 
     bool setAudioOutput(const QAudioDeviceInfo &) override;
     QAudioDeviceInfo audioOutput() const override;
-
-    QMediaMetaData metaData() const override;
-    void setMetaData(const QMediaMetaData &metaData);
-
-    void setVideoSurface(QAbstractVideoSurface *surface) override;
-
-    int trackCount(TrackType) override;
-    QMediaMetaData trackMetaData(TrackType /*type*/, int /*streamNumber*/) override;
-    int activeTrack(TrackType) override;
-    void setActiveTrack(TrackType, int /*streamNumber*/) override;
+    QAudioDeviceInfo m_audioOutput;
 
 public Q_SLOTS:
+    void setPlaybackRate(qreal rate) override;
+
     void setPosition(qint64 pos) override;
 
     void play() override;
@@ -114,9 +120,57 @@ public Q_SLOTS:
     void setVolume(int volume) override;
     void setMuted(bool muted) override;
 
+    void processEOS();
+    void processLoadStateChange(QMediaPlayer::State newState);
+    void processPositionChange();
+    void processMediaLoadError();
+
+    void processLoadStateChange();
+    void processLoadStateFailure();
+
+    void processBufferStateChange(int bufferStatus);
+
+    void processDurationChange(qint64 duration);
+
+    void streamReady();
+    void streamDestroyed();
+    void updateTracks();
+    void setActiveTrack(QPlatformMediaPlayer::TrackType type, int index) override;
+    int activeTrack(QPlatformMediaPlayer::TrackType type) override;
+    int trackCount(TrackType) override;
+    QMediaMetaData trackMetaData(TrackType type, int trackNumber) override;
+
+public:
+    QList<QMediaMetaData> tracks[QPlatformMediaPlayer::NTrackTypes];
+    QList<AVPlayerItemTrack *> nativeTracks[QPlatformMediaPlayer::NTrackTypes];
+
 private:
-    AVFMediaPlayerSession *m_session;
+    void setAudioAvailable(bool available);
+    void setVideoAvailable(bool available);
+    void setSeekable(bool seekable);
+    void resetStream(QIODevice *stream = nullptr);
+
+    AVFVideoRendererControl *m_videoOutput;
+
+    QMediaPlayer::State m_state;
+    QMediaPlayer::MediaStatus m_mediaStatus;
+    QIODevice *m_mediaStream;
+    QUrl m_resources;
     QMediaMetaData m_metaData;
+
+    bool m_muted;
+    bool m_tryingAsync;
+    int m_volume;
+    qreal m_rate;
+    qint64 m_requestedPosition;
+
+    qint64 m_duration;
+    int m_bufferStatus;
+    bool m_videoAvailable;
+    bool m_audioAvailable;
+    bool m_seekable;
+
+    AVFMediaPlayerObserver *m_observer;
 };
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayersession.mm b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayersession.mm
deleted file mode 100644
index a7462501c..000000000
--- a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayersession.mm
+++ /dev/null
@@ -1,1153 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd and/or its subsidiary(-ies).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "avfmediaplayersession_p.h"
-#include "avfmediaplayer_p.h"
-#include "avfvideorenderercontrol_p.h"
-#include "avfvideooutput_p.h"
-#include "avfmetadata_p.h"
-
-#include <qpointer.h>
-#include <QFileInfo>
-
-#import <AVFoundation/AVFoundation.h>
-
-QT_USE_NAMESPACE
-
-//AVAsset Keys
-static NSString* const AVF_TRACKS_KEY       = @"tracks";
-static NSString* const AVF_PLAYABLE_KEY     = @"playable";
-
-//AVPlayerItem keys
-static NSString* const AVF_STATUS_KEY                   = @"status";
-static NSString* const AVF_BUFFER_LIKELY_KEEP_UP_KEY    = @"playbackLikelyToKeepUp";
-
-//AVPlayer keys
-static NSString* const AVF_RATE_KEY                     = @"rate";
-static NSString* const AVF_CURRENT_ITEM_KEY             = @"currentItem";
-static NSString* const AVF_CURRENT_ITEM_DURATION_KEY    = @"currentItem.duration";
-
-static void *AVFMediaPlayerSessionObserverRateObservationContext = &AVFMediaPlayerSessionObserverRateObservationContext;
-static void *AVFMediaPlayerSessionObserverStatusObservationContext = &AVFMediaPlayerSessionObserverStatusObservationContext;
-static void *AVFMediaPlayerSessionObserverBufferLikelyToKeepUpContext = &AVFMediaPlayerSessionObserverBufferLikelyToKeepUpContext;
-static void *AVFMediaPlayerSessionObserverTracksContext = &AVFMediaPlayerSessionObserverTracksContext;
-static void *AVFMediaPlayerSessionObserverCurrentItemObservationContext = &AVFMediaPlayerSessionObserverCurrentItemObservationContext;
-static void *AVFMediaPlayerSessionObserverCurrentItemDurationObservationContext = &AVFMediaPlayerSessionObserverCurrentItemDurationObservationContext;
-
-@interface AVFMediaPlayerSessionObserver : NSObject<AVAssetResourceLoaderDelegate>
-
-@property (readonly, getter=player) AVPlayer* m_player;
-@property (readonly, getter=playerItem) AVPlayerItem* m_playerItem;
-@property (readonly, getter=playerLayer) AVPlayerLayer* m_playerLayer;
-@property (readonly, getter=session) AVFMediaPlayerSession* m_session;
-@property (retain) AVPlayerItemTrack *videoTrack;
-
-- (AVFMediaPlayerSessionObserver *) initWithMediaPlayerSession:(AVFMediaPlayerSession *)session;
-- (void) setURL:(NSURL *)url mimeType:(NSString *)mimeType;
-- (void) unloadMedia;
-- (void) prepareToPlayAsset:(AVURLAsset *)asset withKeys:(NSArray *)requestedKeys;
-- (void) assetFailedToPrepareForPlayback:(NSError *)error;
-- (void) playerItemDidReachEnd:(NSNotification *)notification;
-- (void) playerItemTimeJumped:(NSNotification *)notification;
-- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
-                         change:(NSDictionary *)change context:(void *)context;
-- (void) detatchSession;
-- (void) dealloc;
-- (BOOL) resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest;
-@end
-
-@implementation AVFMediaPlayerSessionObserver
-{
-@private
-    AVFMediaPlayerSession *m_session;
-    AVPlayer *m_player;
-    AVPlayerItem *m_playerItem;
-    AVPlayerLayer *m_playerLayer;
-    NSURL *m_URL;
-    BOOL m_bufferIsLikelyToKeepUp;
-    NSData *m_data;
-    NSString *m_mimeType;
-}
-
-@synthesize m_player, m_playerItem, m_playerLayer, m_session;
-
-- (AVFMediaPlayerSessionObserver *) initWithMediaPlayerSession:(AVFMediaPlayerSession *)session
-{
-    if (!(self = [super init]))
-        return nil;
-
-    self->m_session = session;
-    self->m_bufferIsLikelyToKeepUp = FALSE;
-    return self;
-}
-
-- (void) setURL:(NSURL *)url mimeType:(NSString *)mimeType
-{
-    [m_mimeType release];
-    m_mimeType = [mimeType retain];
-
-    if (m_URL != url)
-    {
-        [m_URL release];
-        m_URL = [url copy];
-
-        //Create an asset for inspection of a resource referenced by a given URL.
-        //Load the values for the asset keys "tracks", "playable".
-
-        // use __block to avoid maintaining strong references on variables captured by the
-        // following block callback
-        __block AVURLAsset *asset = [[AVURLAsset URLAssetWithURL:m_URL options:nil] retain];
-        [asset.resourceLoader setDelegate:self queue:dispatch_get_main_queue()];
-
-        __block NSArray *requestedKeys = [[NSArray arrayWithObjects:AVF_TRACKS_KEY, AVF_PLAYABLE_KEY, nil] retain];
-
-        __block AVFMediaPlayerSessionObserver *blockSelf = self;
-        QPointer<AVFMediaPlayerSession> session(m_session);
-
-        // Tells the asset to load the values of any of the specified keys that are not already loaded.
-        [asset loadValuesAsynchronouslyForKeys:requestedKeys completionHandler:
-         ^{
-             dispatch_async( dispatch_get_main_queue(),
-                           ^{
-                                if (session)
-                                    [blockSelf prepareToPlayAsset:asset withKeys:requestedKeys];
-                                 [asset release];
-                                 [requestedKeys release];
-                            });
-         }];
-    }
-}
-
-- (void) unloadMedia
-{
-    if (m_playerItem) {
-        [m_playerItem removeObserver:self forKeyPath:AVF_STATUS_KEY];
-        [m_playerItem removeObserver:self forKeyPath:AVF_BUFFER_LIKELY_KEEP_UP_KEY];
-        [m_playerItem removeObserver:self forKeyPath:AVF_TRACKS_KEY];
-
-        [[NSNotificationCenter defaultCenter] removeObserver:self
-                                                    name:AVPlayerItemDidPlayToEndTimeNotification
-                                                    object:m_playerItem];
-        [[NSNotificationCenter defaultCenter] removeObserver:self
-                                                    name:AVPlayerItemTimeJumpedNotification
-                                                    object:m_playerItem];
-        m_playerItem = 0;
-    }
-    if (m_player) {
-        [m_player setRate:0.0];
-        [m_player removeObserver:self forKeyPath:AVF_CURRENT_ITEM_DURATION_KEY];
-        [m_player removeObserver:self forKeyPath:AVF_CURRENT_ITEM_KEY];
-        [m_player removeObserver:self forKeyPath:AVF_RATE_KEY];
-        [m_player release];
-        m_player = 0;
-    }
-    if (m_playerLayer) {
-        [m_playerLayer release];
-        m_playerLayer = 0;
-    }
-#if defined(Q_OS_IOS)
-    [[AVAudioSession sharedInstance] setActive:NO error:nil];
-#endif
-}
-
-- (void) prepareToPlayAsset:(AVURLAsset *)asset
-                   withKeys:(NSArray *)requestedKeys
-{
-    //Make sure that the value of each key has loaded successfully.
-    for (NSString *thisKey in requestedKeys)
-    {
-        NSError *error = nil;
-        AVKeyValueStatus keyStatus = [asset statusOfValueForKey:thisKey error:&error];
-#ifdef QT_DEBUG_AVF
-        qDebug() << Q_FUNC_INFO << [thisKey UTF8String] << " status: " << keyStatus;
-#endif
-        if (keyStatus == AVKeyValueStatusFailed)
-        {
-            [self assetFailedToPrepareForPlayback:error];
-            return;
-        }
-    }
-
-    //Use the AVAsset playable property to detect whether the asset can be played.
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << "isPlayable: " << [asset isPlayable];
-#endif
-    if (!asset.playable)
-    {
-        //Generate an error describing the failure.
-        NSString *localizedDescription = NSLocalizedString(@"Item cannot be played", @"Item cannot be played description");
-        NSString *localizedFailureReason = NSLocalizedString(@"The assets tracks were loaded, but could not be made playable.", @"Item cannot be played failure reason");
-        NSDictionary *errorDict = [NSDictionary dictionaryWithObjectsAndKeys:
-                localizedDescription, NSLocalizedDescriptionKey,
-                localizedFailureReason, NSLocalizedFailureReasonErrorKey,
-                nil];
-        NSError *assetCannotBePlayedError = [NSError errorWithDomain:@"StitchedStreamPlayer" code:0 userInfo:errorDict];
-
-        [self assetFailedToPrepareForPlayback:assetCannotBePlayedError];
-
-        return;
-    }
-
-    //At this point we're ready to set up for playback of the asset.
-    //Stop observing our prior AVPlayerItem, if we have one.
-    if (m_playerItem)
-    {
-        //Remove existing player item key value observers and notifications.
-        [self unloadMedia];
-    }
-
-    //Create a new instance of AVPlayerItem from the now successfully loaded AVAsset.
-    m_playerItem = [AVPlayerItem playerItemWithAsset:asset];
-
-    //Observe the player item "status" key to determine when it is ready to play.
-    [m_playerItem addObserver:self
-                   forKeyPath:AVF_STATUS_KEY
-                      options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
-                      context:AVFMediaPlayerSessionObserverStatusObservationContext];
-
-    [m_playerItem addObserver:self
-                   forKeyPath:AVF_BUFFER_LIKELY_KEEP_UP_KEY
-                      options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
-                      context:AVFMediaPlayerSessionObserverBufferLikelyToKeepUpContext];
-
-    [m_playerItem addObserver:self
-                   forKeyPath:AVF_TRACKS_KEY
-                      options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
-                      context:AVFMediaPlayerSessionObserverTracksContext];
-
-    //When the player item has played to its end time we'll toggle
-    //the movie controller Pause button to be the Play button
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(playerItemDidReachEnd:)
-                                                 name:AVPlayerItemDidPlayToEndTimeNotification
-                                               object:m_playerItem];
-
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(playerItemTimeJumped:)
-                                                 name:AVPlayerItemTimeJumpedNotification
-                                               object:m_playerItem];
-
-    //Get a new AVPlayer initialized to play the specified player item.
-    m_player = [AVPlayer playerWithPlayerItem:m_playerItem];
-    [m_player retain];
-
-    //Set the initial volume on new player object
-    if (self.session) {
-        [m_player setVolume:m_session->volume() / 100.0f];
-        [m_player setMuted:m_session->isMuted()];
-    }
-
-    //Create a new player layer if we don't have one already
-    if (!m_playerLayer)
-    {
-        m_playerLayer = [AVPlayerLayer playerLayerWithPlayer:m_player];
-        [m_playerLayer retain];
-        m_playerLayer.videoGravity = AVLayerVideoGravityResizeAspectFill;
-        m_playerLayer.anchorPoint = CGPointMake(0.0f, 0.0f);
-    }
-
-    //Observe the AVPlayer "currentItem" property to find out when any
-    //AVPlayer replaceCurrentItemWithPlayerItem: replacement will/did
-    //occur.
-    [m_player addObserver:self
-                          forKeyPath:AVF_CURRENT_ITEM_KEY
-                          options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
-                          context:AVFMediaPlayerSessionObserverCurrentItemObservationContext];
-
-    //Observe the AVPlayer "rate" property to update the scrubber control.
-    [m_player addObserver:self
-                          forKeyPath:AVF_RATE_KEY
-                          options:NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew
-                          context:AVFMediaPlayerSessionObserverRateObservationContext];
-
-    //Observe the duration for getting the buffer state
-    [m_player addObserver:self
-                          forKeyPath:AVF_CURRENT_ITEM_DURATION_KEY
-                          options:0
-                          context:AVFMediaPlayerSessionObserverCurrentItemDurationObservationContext];
-#if defined(Q_OS_IOS)
-    [[AVAudioSession sharedInstance] setCategory:AVAudioSessionCategoryPlayback withOptions:AVAudioSessionCategoryOptionMixWithOthers error:nil];
-    [[AVAudioSession sharedInstance] setActive:YES error:nil];
-#endif
-}
-
--(void) assetFailedToPrepareForPlayback:(NSError *)error
-{
-    Q_UNUSED(error);
-    QMetaObject::invokeMethod(m_session, "processMediaLoadError", Qt::AutoConnection);
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO;
-    qDebug() << [[error localizedDescription] UTF8String];
-    qDebug() << [[error localizedFailureReason] UTF8String];
-    qDebug() << [[error localizedRecoverySuggestion] UTF8String];
-#endif
-}
-
-- (void) playerItemDidReachEnd:(NSNotification *)notification
-{
-    Q_UNUSED(notification);
-    if (self.session)
-        QMetaObject::invokeMethod(m_session, "processEOS", Qt::AutoConnection);
-}
-
-- (void) playerItemTimeJumped:(NSNotification *)notification
-{
-    Q_UNUSED(notification);
-    if (self.session)
-        QMetaObject::invokeMethod(m_session, "processPositionChange", Qt::AutoConnection);
-}
-
-- (void) observeValueForKeyPath:(NSString*) path
-                       ofObject:(id)object
-                         change:(NSDictionary*)change
-                        context:(void*)context
-{
-    //AVPlayerItem "status" property value observer.
-    if (context == AVFMediaPlayerSessionObserverStatusObservationContext)
-    {
-        AVPlayerStatus status = (AVPlayerStatus)[[change objectForKey:NSKeyValueChangeNewKey] integerValue];
-        switch (status)
-        {
-            //Indicates that the status of the player is not yet known because
-            //it has not tried to load new media resources for playback
-            case AVPlayerStatusUnknown:
-            {
-                //QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
-            }
-            break;
-
-            case AVPlayerStatusReadyToPlay:
-            {
-                //Once the AVPlayerItem becomes ready to play, i.e.
-                //[playerItem status] == AVPlayerItemStatusReadyToPlay,
-                //its duration can be fetched from the item.
-                if (self.session)
-                    QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
-            }
-            break;
-
-            case AVPlayerStatusFailed:
-            {
-                AVPlayerItem *playerItem = static_cast<AVPlayerItem*>(object);
-                [self assetFailedToPrepareForPlayback:playerItem.error];
-
-                if (self.session)
-                    QMetaObject::invokeMethod(m_session, "processLoadStateFailure", Qt::AutoConnection);
-            }
-            break;
-        }
-    }
-    else if (context == AVFMediaPlayerSessionObserverBufferLikelyToKeepUpContext)
-    {
-        const bool isPlaybackLikelyToKeepUp = [m_playerItem isPlaybackLikelyToKeepUp];
-        if (isPlaybackLikelyToKeepUp != m_bufferIsLikelyToKeepUp) {
-            m_bufferIsLikelyToKeepUp = isPlaybackLikelyToKeepUp;
-            QMetaObject::invokeMethod(m_session, "processBufferStateChange", Qt::AutoConnection,
-                                      Q_ARG(int, isPlaybackLikelyToKeepUp ? 100 : 0));
-        }
-    }
-    else if (context == AVFMediaPlayerSessionObserverTracksContext)
-    {
-        QMetaObject::invokeMethod(m_session, "updateTracks", Qt::AutoConnection);
-    }
-    //AVPlayer "rate" property value observer.
-    else if (context == AVFMediaPlayerSessionObserverRateObservationContext)
-    {
-        //QMetaObject::invokeMethod(m_session, "setPlaybackRate",  Qt::AutoConnection, Q_ARG(qreal, [m_player rate]));
-    }
-    //AVPlayer "currentItem" property observer.
-    //Called when the AVPlayer replaceCurrentItemWithPlayerItem:
-    //replacement will/did occur.
-    else if (context == AVFMediaPlayerSessionObserverCurrentItemObservationContext)
-    {
-        AVPlayerItem *newPlayerItem = [change objectForKey:NSKeyValueChangeNewKey];
-        if (m_playerItem != newPlayerItem)
-            m_playerItem = newPlayerItem;
-    }
-    else if (context == AVFMediaPlayerSessionObserverCurrentItemDurationObservationContext)
-    {
-        const CMTime time = [m_playerItem duration];
-        const qint64 duration =  static_cast<qint64>(float(time.value) / float(time.timescale) * 1000.0f);
-        if (self.session)
-            QMetaObject::invokeMethod(m_session, "processDurationChange",  Qt::AutoConnection, Q_ARG(qint64, duration));
-    }
-    else
-    {
-        [super observeValueForKeyPath:path ofObject:object change:change context:context];
-    }
-}
-
-- (void) detatchSession
-{
-#ifdef QT_DEBUG_AVF
-        qDebug() << Q_FUNC_INFO;
-#endif
-        m_session = 0;
-}
-
-- (void) dealloc
-{
-#ifdef QT_DEBUG_AVF
-        qDebug() << Q_FUNC_INFO;
-#endif
-    [self unloadMedia];
-
-    if (m_URL) {
-        [m_URL release];
-    }
-
-    [m_mimeType release];
-    [super dealloc];
-}
-
-- (BOOL) resourceLoader:(AVAssetResourceLoader *)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest *)loadingRequest
-{
-    Q_UNUSED(resourceLoader);
-
-    if (![loadingRequest.request.URL.scheme isEqualToString:@"iodevice"])
-        return NO;
-
-    QIODevice *device = m_session->mediaStream();
-    if (!device)
-        return NO;
-
-    device->seek(loadingRequest.dataRequest.requestedOffset);
-    if (loadingRequest.contentInformationRequest) {
-        loadingRequest.contentInformationRequest.contentType = m_mimeType;
-        loadingRequest.contentInformationRequest.contentLength = device->size();
-        loadingRequest.contentInformationRequest.byteRangeAccessSupported = YES;
-    }
-
-    if (loadingRequest.dataRequest) {
-        NSInteger requestedLength = loadingRequest.dataRequest.requestedLength;
-        int maxBytes = qMin(32 * 1064, int(requestedLength));
-        char buffer[maxBytes];
-        NSInteger submitted = 0;
-        while (submitted < requestedLength) {
-            qint64 len = device->read(buffer, maxBytes);
-            if (len < 1)
-                break;
-
-            [loadingRequest.dataRequest respondWithData:[NSData dataWithBytes:buffer length:len]];
-            submitted += len;
-        }
-
-        // Finish loading even if not all bytes submitted.
-        [loadingRequest finishLoading];
-    }
-
-    return YES;
-}
-@end
-
-AVFMediaPlayerSession::AVFMediaPlayerSession(AVFMediaPlayer *player, QObject *parent)
-    : QObject(parent)
-    , m_player(player)
-    , m_videoOutput(nullptr)
-    , m_state(QMediaPlayer::StoppedState)
-    , m_mediaStatus(QMediaPlayer::NoMedia)
-    , m_mediaStream(nullptr)
-    , m_muted(false)
-    , m_tryingAsync(false)
-    , m_volume(100)
-    , m_rate(1.0)
-    , m_requestedPosition(-1)
-    , m_duration(0)
-    , m_bufferStatus(0)
-    , m_videoAvailable(false)
-    , m_audioAvailable(false)
-    , m_seekable(false)
-{
-    m_observer = [[AVFMediaPlayerSessionObserver alloc] initWithMediaPlayerSession:this];
-    setVideoOutput(new AVFVideoRendererControl(this));
-}
-
-AVFMediaPlayerSession::~AVFMediaPlayerSession()
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO;
-#endif
-    //Detatch the session from the sessionObserver (which could still be alive trying to communicate with this session).
-    [m_observer detatchSession];
-    [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) release];
-}
-
-void AVFMediaPlayerSession::setVideoSurface(QAbstractVideoSurface *surface)
-{
-    m_videoOutput->setSurface(surface);
-}
-
-void AVFMediaPlayerSession::setVideoOutput(AVFVideoRendererControl *output)
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << output;
-#endif
-
-    if (m_videoOutput == output)
-        return;
-
-    //Set the current output layer to null to stop rendering
-    if (m_videoOutput) {
-        m_videoOutput->setLayer(nullptr);
-    }
-
-    m_videoOutput = output;
-
-    if (m_videoOutput && m_state != QMediaPlayer::StoppedState)
-        m_videoOutput->setLayer([static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerLayer]);
-}
-
-AVAsset *AVFMediaPlayerSession::currentAssetHandle()
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO;
-#endif
-    AVAsset *currentAsset = [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerItem] asset];
-    return currentAsset;
-}
-
-QMediaPlayer::State AVFMediaPlayerSession::state() const
-{
-    return m_state;
-}
-
-QMediaPlayer::MediaStatus AVFMediaPlayerSession::mediaStatus() const
-{
-    return m_mediaStatus;
-}
-
-QUrl AVFMediaPlayerSession::media() const
-{
-    return m_resources;
-}
-
-QIODevice *AVFMediaPlayerSession::mediaStream() const
-{
-    return m_mediaStream;
-}
-
-static void setURL(AVFMediaPlayerSessionObserver *observer, const QByteArray &url, const QString &mimeType = QString())
-{
-    NSString *urlString = [NSString stringWithUTF8String:url.constData()];
-    NSURL *nsurl = [NSURL URLWithString:urlString];
-    [observer setURL:nsurl mimeType:[NSString stringWithUTF8String:mimeType.toLatin1().constData()]];
-}
-
-static void setStreamURL(AVFMediaPlayerSessionObserver *observer, const QByteArray &url)
-{
-    setURL(observer, QByteArrayLiteral("iodevice://") + url, QFileInfo(QString::fromUtf8(url)).suffix());
-}
-
-void AVFMediaPlayerSession::setMedia(const QUrl &content, QIODevice *stream)
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << content.request().url();
-#endif
-
-    [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) unloadMedia];
-
-    m_resources = content;
-    resetStream(stream);
-
-    setAudioAvailable(false);
-    setVideoAvailable(false);
-    setSeekable(false);
-    m_requestedPosition = -1;
-    Q_EMIT positionChanged(position());
-
-    const QMediaPlayer::MediaStatus oldMediaStatus = m_mediaStatus;
-    const QMediaPlayer::State oldState = m_state;
-
-    if (!m_mediaStream && content.isEmpty()) {
-        m_mediaStatus = QMediaPlayer::NoMedia;
-        if (m_mediaStatus != oldMediaStatus)
-            Q_EMIT mediaStatusChanged(m_mediaStatus);
-
-        m_state = QMediaPlayer::StoppedState;
-        if (m_state != oldState)
-            Q_EMIT stateChanged(m_state);
-
-        return;
-    }
-
-    m_mediaStatus = QMediaPlayer::LoadingMedia;
-    if (m_mediaStatus != oldMediaStatus)
-        Q_EMIT mediaStatusChanged(m_mediaStatus);
-
-    if (m_mediaStream) {
-        // If there is a data, try to load it,
-        // otherwise wait for readyRead.
-        if (m_mediaStream->size())
-            setStreamURL(m_observer, m_resources.toEncoded());
-    } else {
-        //Load AVURLAsset
-        //initialize asset using content's URL
-        setURL(m_observer, m_resources.toEncoded());
-    }
-
-    m_state = QMediaPlayer::StoppedState;
-    if (m_state != oldState)
-        Q_EMIT stateChanged(m_state);
-}
-
-qint64 AVFMediaPlayerSession::position() const
-{
-    AVPlayerItem *playerItem = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerItem];
-
-    if (!playerItem)
-        return m_requestedPosition != -1 ? m_requestedPosition : 0;
-
-    CMTime time = [playerItem currentTime];
-    return static_cast<quint64>(float(time.value) / float(time.timescale) * 1000.0f);
-}
-
-qint64 AVFMediaPlayerSession::duration() const
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO;
-#endif
-    return m_duration;
-}
-
-int AVFMediaPlayerSession::bufferStatus() const
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO;
-#endif
-    return m_bufferStatus;
-}
-
-int AVFMediaPlayerSession::volume() const
-{
-    return m_volume;
-}
-
-bool AVFMediaPlayerSession::isMuted() const
-{
-    return m_muted;
-}
-
-void AVFMediaPlayerSession::setAudioAvailable(bool available)
-{
-    if (m_audioAvailable == available)
-        return;
-
-    m_audioAvailable = available;
-    Q_EMIT audioAvailableChanged(available);
-}
-
-bool AVFMediaPlayerSession::isAudioAvailable() const
-{
-    return m_audioAvailable;
-}
-
-void AVFMediaPlayerSession::setVideoAvailable(bool available)
-{
-    if (m_videoAvailable == available)
-        return;
-
-    m_videoAvailable = available;
-    Q_EMIT videoAvailableChanged(available);
-}
-
-bool AVFMediaPlayerSession::isVideoAvailable() const
-{
-    return m_videoAvailable;
-}
-
-bool AVFMediaPlayerSession::isSeekable() const
-{
-    return m_seekable;
-}
-
-void AVFMediaPlayerSession::setSeekable(bool seekable)
-{
-    if (m_seekable == seekable)
-        return;
-
-    m_seekable = seekable;
-    Q_EMIT seekableChanged(seekable);
-}
-
-QMediaTimeRange AVFMediaPlayerSession::availablePlaybackRanges() const
-{
-    AVPlayerItem *playerItem = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerItem];
-
-    if (playerItem) {
-        QMediaTimeRange timeRanges;
-
-        NSArray *ranges = [playerItem loadedTimeRanges];
-        for (NSValue *timeRange in ranges) {
-            CMTimeRange currentTimeRange = [timeRange CMTimeRangeValue];
-            qint64 startTime = qint64(float(currentTimeRange.start.value) / currentTimeRange.start.timescale * 1000.0);
-            timeRanges.addInterval(startTime, startTime + qint64(float(currentTimeRange.duration.value) / currentTimeRange.duration.timescale * 1000.0));
-        }
-        if (!timeRanges.isEmpty())
-            return timeRanges;
-    }
-    return QMediaTimeRange(0, duration());
-}
-
-qreal AVFMediaPlayerSession::playbackRate() const
-{
-    return m_rate;
-}
-
-#ifdef Q_OS_MACOS
-bool AVFMediaPlayerSession::setAudioOutput(const QAudioDeviceInfo &info)
-{
-    m_audioOutput = info;
-
-    AVPlayer *player = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player];
-    if (info.isNull()) {
-        player.audioOutputDeviceUniqueID = nil;
-    } else {
-        NSString *str = QString::fromUtf8(info.id()).toNSString();
-        player.audioOutputDeviceUniqueID = str;
-    }
-    return true;
-}
-
-QAudioDeviceInfo AVFMediaPlayerSession::audioOutput() const
-{
-    return m_audioOutput;
-}
-#endif
-
-void AVFMediaPlayerSession::setPlaybackRate(qreal rate)
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << rate;
-#endif
-
-    if (qFuzzyCompare(m_rate, rate))
-        return;
-
-    m_rate = rate;
-
-    AVPlayer *player = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player];
-    if (player && m_state == QMediaPlayer::PlayingState)
-        [player setRate:m_rate];
-
-    Q_EMIT playbackRateChanged(m_rate);
-}
-
-void AVFMediaPlayerSession::setPosition(qint64 pos)
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << pos;
-#endif
-
-    if (pos == position())
-        return;
-
-    AVPlayerItem *playerItem = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerItem];
-    if (!playerItem) {
-        m_requestedPosition = pos;
-        Q_EMIT positionChanged(m_requestedPosition);
-        return;
-    }
-
-    if (!isSeekable()) {
-        if (m_requestedPosition != -1) {
-            m_requestedPosition = -1;
-            Q_EMIT positionChanged(position());
-        }
-        return;
-    }
-
-    pos = qMax(qint64(0), pos);
-    if (duration() > 0)
-        pos = qMin(pos, duration());
-
-    CMTime newTime = [playerItem currentTime];
-    newTime.value = (pos / 1000.0f) * newTime.timescale;
-    [playerItem seekToTime:newTime toleranceBefore:kCMTimeZero toleranceAfter:kCMTimeZero completionHandler:nil];
-
-    Q_EMIT positionChanged(pos);
-
-    // Reset media status if the current status is EndOfMedia
-    if (m_mediaStatus == QMediaPlayer::EndOfMedia) {
-        QMediaPlayer::MediaStatus newMediaStatus = (m_state == QMediaPlayer::PausedState) ? QMediaPlayer::BufferedMedia
-                                                                                          : QMediaPlayer::LoadedMedia;
-        Q_EMIT mediaStatusChanged((m_mediaStatus = newMediaStatus));
-    }
-}
-
-void AVFMediaPlayerSession::play()
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << "currently: " << m_state;
-#endif
-
-    if (m_mediaStatus == QMediaPlayer::NoMedia || m_mediaStatus == QMediaPlayer::InvalidMedia)
-        return;
-
-    if (m_state == QMediaPlayer::PlayingState)
-        return;
-
-    if (m_videoOutput) {
-        m_videoOutput->setLayer([static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerLayer]);
-    }
-
-    // Reset media status if the current status is EndOfMedia
-    if (m_mediaStatus == QMediaPlayer::EndOfMedia)
-        setPosition(0);
-
-    if (m_mediaStatus == QMediaPlayer::LoadedMedia || m_mediaStatus == QMediaPlayer::BufferedMedia) {
-        // Setting the rate starts playback
-        [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player] setRate:m_rate];
-    }
-
-    m_state = QMediaPlayer::PlayingState;
-    processLoadStateChange();
-
-    Q_EMIT stateChanged(m_state);
-}
-
-void AVFMediaPlayerSession::pause()
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << "currently: " << m_state;
-#endif
-
-    if (m_mediaStatus == QMediaPlayer::NoMedia)
-        return;
-
-    if (m_state == QMediaPlayer::PausedState)
-        return;
-
-    m_state = QMediaPlayer::PausedState;
-
-    if (m_videoOutput) {
-        m_videoOutput->setLayer([static_cast<AVFMediaPlayerSessionObserver*>(m_observer) playerLayer]);
-    }
-
-    [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player] pause];
-
-    // Reset media status if the current status is EndOfMedia
-    if (m_mediaStatus == QMediaPlayer::EndOfMedia)
-        setPosition(0);
-
-
-    Q_EMIT stateChanged(m_state);
-}
-
-void AVFMediaPlayerSession::stop()
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << "currently: " << m_state;
-#endif
-
-    if (m_state == QMediaPlayer::StoppedState)
-        return;
-
-    // AVPlayer doesn't have stop(), only pause() and play().
-    [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player] pause];
-    setPosition(0);
-
-    if (m_videoOutput) {
-        m_videoOutput->setLayer(nullptr);
-    }
-
-    if (m_mediaStatus == QMediaPlayer::BufferedMedia)
-        Q_EMIT mediaStatusChanged((m_mediaStatus = QMediaPlayer::LoadedMedia));
-
-    Q_EMIT positionChanged(position());
-    Q_EMIT stateChanged((m_state = QMediaPlayer::StoppedState));
-}
-
-void AVFMediaPlayerSession::setVolume(int volume)
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << volume;
-#endif
-
-    if (m_volume == volume)
-        return;
-
-    m_volume = volume;
-
-    AVPlayer *player = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player];
-    if (player)
-        [player setVolume:volume / 100.0f];
-
-    Q_EMIT volumeChanged(m_volume);
-}
-
-void AVFMediaPlayerSession::setMuted(bool muted)
-{
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << muted;
-#endif
-
-    if (m_muted == muted)
-        return;
-
-    m_muted = muted;
-
-    AVPlayer *player = [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player];
-    if (player)
-        [player setMuted:muted];
-
-    Q_EMIT mutedChanged(muted);
-}
-
-void AVFMediaPlayerSession::processEOS()
-{
-    //AVPlayerItem has reached end of track/stream
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO;
-#endif
-    Q_EMIT positionChanged(position());
-    m_mediaStatus = QMediaPlayer::EndOfMedia;
-    m_state = QMediaPlayer::StoppedState;
-
-    // At this point, frames should not be rendered anymore.
-    // Clear the output layer to make sure of that.
-    if (m_videoOutput)
-        m_videoOutput->setLayer(nullptr);
-
-    Q_EMIT mediaStatusChanged(m_mediaStatus);
-    Q_EMIT stateChanged(m_state);
-}
-
-void AVFMediaPlayerSession::processLoadStateChange(QMediaPlayer::State newState)
-{
-    AVPlayerStatus currentStatus = [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player] status];
-
-#ifdef QT_DEBUG_AVF
-    qDebug() << Q_FUNC_INFO << currentStatus << ", " << m_mediaStatus << ", " << newState;
-#endif
-
-    if (m_mediaStatus == QMediaPlayer::NoMedia)
-        return;
-
-    if (currentStatus == AVPlayerStatusReadyToPlay) {
-
-        QMediaPlayer::MediaStatus newStatus = m_mediaStatus;
-
-        AVPlayerItem *playerItem = [m_observer playerItem];
-
-        // get the meta data
-        QMediaMetaData metaData = AVFMetaData::fromAsset(playerItem.asset);
-        m_player->setMetaData(metaData);
-        updateTracks();
-
-        if (playerItem) {
-            setSeekable([[playerItem seekableTimeRanges] count] > 0);
-
-            // Get the native size of the video, and reset the bounds of the player layer
-            AVPlayerLayer *playerLayer = [m_observer playerLayer];
-            if (m_observer.videoTrack && playerLayer) {
-                if (!playerLayer.bounds.size.width || !playerLayer.bounds.size.height) {
-                    playerLayer.bounds = CGRectMake(0.0f, 0.0f,
-                                                    m_observer.videoTrack.assetTrack.naturalSize.width,
-                                                    m_observer.videoTrack.assetTrack.naturalSize.height);
-                }
-
-                if (m_videoOutput && newState != QMediaPlayer::StoppedState) {
-                    m_videoOutput->setLayer(playerLayer);
-                }
-            }
-
-            if (m_requestedPosition != -1) {
-                setPosition(m_requestedPosition);
-                m_requestedPosition = -1;
-            }
-        }
-
-        newStatus = (newState != QMediaPlayer::StoppedState) ? QMediaPlayer::BufferedMedia
-                                                             : QMediaPlayer::LoadedMedia;
-
-        if (newStatus != m_mediaStatus)
-            Q_EMIT mediaStatusChanged((m_mediaStatus = newStatus));
-
-    }
-
-    if (newState == QMediaPlayer::PlayingState && [static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player]) {
-        // Setting the rate is enough to start playback, no need to call play()
-        [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player] setRate:m_rate];
-    }
-}
-
-
-void AVFMediaPlayerSession::processLoadStateChange()
-{
-    processLoadStateChange(m_state);
-}
-
-
-void AVFMediaPlayerSession::processLoadStateFailure()
-{
-    Q_EMIT stateChanged((m_state = QMediaPlayer::StoppedState));
-}
-
-void AVFMediaPlayerSession::processBufferStateChange(int bufferStatus)
-{
-    if (bufferStatus == m_bufferStatus)
-        return;
-
-    auto status = m_mediaStatus;
-    // Buffered -> unbuffered.
-    if (!bufferStatus) {
-        status = QMediaPlayer::StalledMedia;
-    } else if (status == QMediaPlayer::StalledMedia) {
-        status = QMediaPlayer::BufferedMedia;
-        // Resume playback.
-        if (m_state == QMediaPlayer::PlayingState)
-            [[static_cast<AVFMediaPlayerSessionObserver*>(m_observer) player] setRate:m_rate];
-    }
-
-    if (m_mediaStatus != status)
-        Q_EMIT mediaStatusChanged(m_mediaStatus = status);
-
-    m_bufferStatus = bufferStatus;
-    Q_EMIT bufferStatusChanged(bufferStatus);
-}
-
-void AVFMediaPlayerSession::processDurationChange(qint64 duration)
-{
-    if (duration == m_duration)
-        return;
-
-    m_duration = duration;
-    Q_EMIT durationChanged(duration);
-}
-
-void AVFMediaPlayerSession::processPositionChange()
-{
-    if (m_state == QMediaPlayer::StoppedState)
-        return;
-
-    Q_EMIT positionChanged(position());
-}
-
-void AVFMediaPlayerSession::processMediaLoadError()
-{
-    if (m_requestedPosition != -1) {
-        m_requestedPosition = -1;
-        Q_EMIT positionChanged(position());
-    }
-
-    Q_EMIT mediaStatusChanged((m_mediaStatus = QMediaPlayer::InvalidMedia));
-
-    Q_EMIT error(QMediaPlayer::FormatError, tr("Failed to load media"));
-}
-
-void AVFMediaPlayerSession::streamReady()
-{
-    setStreamURL(m_observer, m_resources.toEncoded());
-}
-
-void AVFMediaPlayerSession::streamDestroyed()
-{
-    resetStream(nullptr);
-}
-
-void AVFMediaPlayerSession::updateTracks()
-{
-    for (int i = 0; i < QPlatformMediaPlayer::NTrackTypes; ++i) {
-        tracks[i].clear();
-        nativeTracks[i].clear();
-    }
-    AVPlayerItem *playerItem = [m_observer playerItem];
-    if (playerItem) {
-        // Check each track for audio and video content
-        NSArray *tracks =  playerItem.tracks;
-        for (AVPlayerItemTrack *track in tracks) {
-            AVAssetTrack *assetTrack = track.assetTrack;
-            if (assetTrack) {
-                int qtTrack = -1;
-                if ([assetTrack.mediaType isEqualToString:AVMediaTypeAudio]) {
-                    qtTrack = QPlatformMediaPlayer::AudioStream;
-                    setAudioAvailable(true);
-                } else if ([assetTrack.mediaType isEqualToString:AVMediaTypeVideo]) {
-                    qtTrack = QPlatformMediaPlayer::VideoStream;
-                    setVideoAvailable(true);
-                    if (!m_observer.videoTrack)
-                        m_observer.videoTrack = track;
-                }
-                else if ([assetTrack.mediaType isEqualToString:AVMediaTypeSubtitle]) {
-                    qtTrack = QPlatformMediaPlayer::SubtitleStream;
-                    setVideoAvailable(true);
-                    if (!m_observer.videoTrack)
-                        m_observer.videoTrack = track;
-                }
-                if (qtTrack != -1) {
-                    QMediaMetaData metaData = AVFMetaData::fromAssetTrack(assetTrack);
-                    this->tracks[qtTrack].append(metaData);
-                    nativeTracks[qtTrack].append(track);
-                }
-            }
-        }
-    }
-    emit m_player->tracksChanged();
-}
-
-void AVFMediaPlayerSession::setActiveTrack(QPlatformMediaPlayer::TrackType type, int index)
-{
-    const auto &t = nativeTracks[type];
-    for (int i = 0; i < t.count(); ++i)
-        t.at(i).enabled = (i == index);
-}
-
-int AVFMediaPlayerSession::activeTrack(QPlatformMediaPlayer::TrackType type)
-{
-    const auto &t = nativeTracks[type];
-    for (int i = 0; i < t.count(); ++i)
-        if (t.at(i).enabled)
-            return i;
-    return -1;
-}
-
-void AVFMediaPlayerSession::resetStream(QIODevice *stream)
-{
-    if (m_mediaStream) {
-        disconnect(m_mediaStream, &QIODevice::readyRead, this, &AVFMediaPlayerSession::streamReady);
-        disconnect(m_mediaStream, &QIODevice::destroyed, this, &AVFMediaPlayerSession::streamDestroyed);
-    }
-
-    m_mediaStream = stream;
-
-    if (m_mediaStream) {
-        connect(m_mediaStream, &QIODevice::readyRead, this, &AVFMediaPlayerSession::streamReady);
-        connect(m_mediaStream, &QIODevice::destroyed, this, &AVFMediaPlayerSession::streamDestroyed);
-    }
-}
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayersession_p.h b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayersession_p.h
deleted file mode 100644
index a42ec9205..000000000
--- a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayersession_p.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef AVFMEDIAPLAYERSESSION_H
-#define AVFMEDIAPLAYERSESSION_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Qt API.  It exists purely as an
-// implementation detail.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QtCore/QObject>
-#include <QtCore/QByteArray>
-#include <QtCore/QSet>
-#include <QtCore/QResource>
-#include <QtCore/QUrl>
-
-#include <private/qplatformmediaplayer_p.h>
-#include <QtMultimedia/QMediaPlayer>
-
-Q_FORWARD_DECLARE_OBJC_CLASS(AVAsset);
-Q_FORWARD_DECLARE_OBJC_CLASS(AVPlayerItemTrack);
-Q_FORWARD_DECLARE_OBJC_CLASS(AVFMediaPlayerSessionObserver);
-
-QT_BEGIN_NAMESPACE
-
-class AVFMediaPlayer;
-class AVFVideoOutput;
-class AVFVideoRendererControl;
-
-class AVFMediaPlayerSession : public QObject
-{
-    Q_OBJECT
-public:
-    AVFMediaPlayerSession(AVFMediaPlayer *control, QObject *parent = nullptr);
-    virtual ~AVFMediaPlayerSession();
-
-    void setVideoSurface(QAbstractVideoSurface *surface);
-    void setVideoOutput(AVFVideoRendererControl *output);
-    AVAsset *currentAssetHandle();
-
-    QMediaPlayer::State state() const;
-    QMediaPlayer::MediaStatus mediaStatus() const;
-
-    QUrl media() const;
-    QIODevice *mediaStream() const;
-    void setMedia(const QUrl &content, QIODevice *stream);
-
-    qint64 position() const;
-    qint64 duration() const;
-
-    int bufferStatus() const;
-
-    int volume() const;
-    bool isMuted() const;
-
-    bool isAudioAvailable() const;
-    bool isVideoAvailable() const;
-
-    bool isSeekable() const;
-    QMediaTimeRange availablePlaybackRanges() const;
-
-    qreal playbackRate() const;
-
-#ifdef Q_OS_MACOS
-    bool setAudioOutput(const QAudioDeviceInfo &);
-    QAudioDeviceInfo audioOutput() const;
-    QAudioDeviceInfo m_audioOutput;
-#endif
-
-public Q_SLOTS:
-    void setPlaybackRate(qreal rate);
-
-    void setPosition(qint64 pos);
-
-    void play();
-    void pause();
-    void stop();
-
-    void setVolume(int volume);
-    void setMuted(bool muted);
-
-    void processEOS();
-    void processLoadStateChange(QMediaPlayer::State newState);
-    void processPositionChange();
-    void processMediaLoadError();
-
-    void processLoadStateChange();
-    void processLoadStateFailure();
-
-    void processBufferStateChange(int bufferStatus);
-
-    void processDurationChange(qint64 duration);
-
-    void streamReady();
-    void streamDestroyed();
-    void updateTracks();
-    void setActiveTrack(QPlatformMediaPlayer::TrackType type, int index);
-    int activeTrack(QPlatformMediaPlayer::TrackType type);
-
-public:
-    QList<QMediaMetaData> tracks[QPlatformMediaPlayer::NTrackTypes];
-    QList<AVPlayerItemTrack *> nativeTracks[QPlatformMediaPlayer::NTrackTypes];
-
-Q_SIGNALS:
-    void positionChanged(qint64 position);
-    void durationChanged(qint64 duration);
-    void stateChanged(QMediaPlayer::State newState);
-    void bufferStatusChanged(int bufferStatus);
-    void mediaStatusChanged(QMediaPlayer::MediaStatus status);
-    void volumeChanged(int volume);
-    void mutedChanged(bool muted);
-    void audioAvailableChanged(bool audioAvailable);
-    void videoAvailableChanged(bool videoAvailable);
-    void playbackRateChanged(qreal rate);
-    void seekableChanged(bool seekable);
-    void error(int error, const QString &errorString);
-
-private:
-    void setAudioAvailable(bool available);
-    void setVideoAvailable(bool available);
-    void setSeekable(bool seekable);
-    void resetStream(QIODevice *stream = nullptr);
-
-    AVFMediaPlayer *m_player;
-    AVFVideoRendererControl *m_videoOutput;
-
-    QMediaPlayer::State m_state;
-    QMediaPlayer::MediaStatus m_mediaStatus;
-    QIODevice *m_mediaStream;
-    QUrl m_resources;
-
-    bool m_muted;
-    bool m_tryingAsync;
-    int m_volume;
-    qreal m_rate;
-    qint64 m_requestedPosition;
-
-    qint64 m_duration;
-    int m_bufferStatus;
-    bool m_videoAvailable;
-    bool m_audioAvailable;
-    bool m_seekable;
-
-    AVFMediaPlayerSessionObserver *m_observer;
-};
-
-QT_END_NAMESPACE
-
-#endif // AVFMEDIAPLAYERSESSION_H
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmetadata_p.h b/src/multimedia/platform/darwin/mediaplayer/avfmetadata_p.h
index 7ece65943..a02af556a 100644
--- a/src/multimedia/platform/darwin/mediaplayer/avfmetadata_p.h
+++ b/src/multimedia/platform/darwin/mediaplayer/avfmetadata_p.h
@@ -59,7 +59,7 @@ QT_BEGIN_NAMESPACE
 Q_FORWARD_DECLARE_OBJC_CLASS(AVAsset);
 Q_FORWARD_DECLARE_OBJC_CLASS(AVAssetTrack);
 
-class AVFMediaPlayerSession;
+class AVFMediaPlayer;
 
 class AVFMetaData
 {
diff --git a/src/multimedia/platform/darwin/mediaplayer/mediaplayer.pri b/src/multimedia/platform/darwin/mediaplayer/mediaplayer.pri
index 546673d62..e0c5ae349 100644
--- a/src/multimedia/platform/darwin/mediaplayer/mediaplayer.pri
+++ b/src/multimedia/platform/darwin/mediaplayer/mediaplayer.pri
@@ -3,14 +3,12 @@ QT += opengl network
 HEADERS += \
     $$PWD/avfmediaplayer_p.h \
     $$PWD/avfmetadata_p.h \
-    $$PWD/avfmediaplayersession_p.h \
     $$PWD/avfvideooutput_p.h \
     $$PWD/avfvideowindowcontrol_p.h
 
 SOURCES += \
     $$PWD/avfmediaplayer.mm \
     $$PWD/avfmetadata.mm \
-    $$PWD/avfmediaplayersession.mm \
     $$PWD/avfvideooutput.mm \
     $$PWD/avfvideowindowcontrol.mm