MediaSourcePrivateRemote.cpp [plain text]
#include "config.h"
#include "MediaSourcePrivateRemote.h"
#if ENABLE(GPU_PROCESS) && ENABLE(MEDIA_SOURCE)
#include "Logging.h"
#include "MediaPlayerPrivateRemote.h"
#include "MediaSourcePrivateRemoteMessages.h"
#include "RemoteMediaSourceProxyMessages.h"
#include "RemoteSourceBufferIdentifier.h"
#include "SourceBufferPrivateRemote.h"
#include <WebCore/NotImplemented.h>
#include <wtf/Optional.h>
namespace WebCore {
#if !RELEASE_LOG_DISABLED
extern WTFLogChannel LogMedia;
#endif
}
namespace WebKit {
using namespace WebCore;
Ref<MediaSourcePrivateRemote> MediaSourcePrivateRemote::create(GPUProcessConnection& gpuProcessConnection, RemoteMediaSourceIdentifier identifier, RemoteMediaPlayerMIMETypeCache& mimeTypeCache, const MediaPlayerPrivateRemote& mediaPlayerPrivate, MediaSourcePrivateClient* client)
{
auto mediaSourcePrivate = adoptRef(*new MediaSourcePrivateRemote(gpuProcessConnection, identifier, mimeTypeCache, mediaPlayerPrivate, client));
client->setPrivateAndOpen(mediaSourcePrivate.copyRef());
return mediaSourcePrivate;
}
MediaSourcePrivateRemote::MediaSourcePrivateRemote(GPUProcessConnection& gpuProcessConnection, RemoteMediaSourceIdentifier identifier, RemoteMediaPlayerMIMETypeCache& mimeTypeCache, const MediaPlayerPrivateRemote& mediaPlayerPrivate, MediaSourcePrivateClient* client)
: m_gpuProcessConnection(gpuProcessConnection)
, m_identifier(identifier)
, m_mimeTypeCache(mimeTypeCache)
, m_mediaPlayerPrivate(makeWeakPtr(mediaPlayerPrivate))
, m_client(client)
#if !RELEASE_LOG_DISABLED
, m_logger(m_mediaPlayerPrivate->mediaPlayerLogger())
, m_logIdentifier(m_mediaPlayerPrivate->mediaPlayerLogIdentifier())
#endif
{
ALWAYS_LOG(LOGIDENTIFIER);
m_gpuProcessConnection.messageReceiverMap().addMessageReceiver(Messages::MediaSourcePrivateRemote::messageReceiverName(), m_identifier.toUInt64(), *this);
#if !RELEASE_LOG_DISABLED
m_client->setLogIdentifier(m_logIdentifier);
#endif
}
MediaSourcePrivateRemote::~MediaSourcePrivateRemote()
{
ALWAYS_LOG(LOGIDENTIFIER);
m_gpuProcessConnection.messageReceiverMap().removeMessageReceiver(Messages::MediaSourcePrivateRemote::messageReceiverName(), m_identifier.toUInt64());
for (auto it = m_sourceBuffers.begin(), end = m_sourceBuffers.end(); it != end; ++it)
(*it)->clearMediaSource();
}
MediaSourcePrivate::AddStatus MediaSourcePrivateRemote::addSourceBuffer(const ContentType& contentType, bool, RefPtr<SourceBufferPrivate>& outPrivate)
{
DEBUG_LOG(LOGIDENTIFIER, contentType);
MediaEngineSupportParameters parameters;
parameters.isMediaSource = true;
parameters.type = contentType;
if (m_mimeTypeCache.supportsTypeAndCodecs(parameters) == MediaPlayer::SupportsType::IsNotSupported)
return AddStatus::NotSupported;
AddStatus status;
Optional<RemoteSourceBufferIdentifier> remoteSourceBufferIdentifier;
if (!m_gpuProcessConnection.connection().sendSync(Messages::RemoteMediaSourceProxy::AddSourceBuffer(contentType), Messages::RemoteMediaSourceProxy::AddSourceBuffer::Reply(status, remoteSourceBufferIdentifier), m_identifier))
status = AddStatus::NotSupported;
if (status == AddStatus::Ok) {
ASSERT(remoteSourceBufferIdentifier.hasValue());
auto newSourceBuffer = SourceBufferPrivateRemote::create(m_gpuProcessConnection, *remoteSourceBufferIdentifier, *this, *m_mediaPlayerPrivate);
outPrivate = newSourceBuffer.copyRef();
m_sourceBuffers.append(WTFMove(newSourceBuffer));
}
return status;
}
void MediaSourcePrivateRemote::durationChanged(const MediaTime& duration)
{
m_gpuProcessConnection.connection().send(Messages::RemoteMediaSourceProxy::DurationChanged(duration), m_identifier);
}
void MediaSourcePrivateRemote::markEndOfStream(EndOfStreamStatus)
{
notImplemented();
}
void MediaSourcePrivateRemote::unmarkEndOfStream()
{
notImplemented();
}
bool MediaSourcePrivateRemote::isEnded() const
{
notImplemented();
return false;
}
MediaPlayer::ReadyState MediaSourcePrivateRemote::readyState() const
{
return m_mediaPlayerPrivate ? m_mediaPlayerPrivate->readyState() : MediaPlayer::ReadyState::HaveNothing;
}
void MediaSourcePrivateRemote::setReadyState(MediaPlayer::ReadyState readyState)
{
m_gpuProcessConnection.connection().send(Messages::RemoteMediaSourceProxy::SetReadyState(readyState), m_identifier);
}
void MediaSourcePrivateRemote::setIsSeeking(bool isSeeking)
{
MediaSourcePrivate::setIsSeeking(isSeeking);
m_gpuProcessConnection.connection().send(Messages::RemoteMediaSourceProxy::SetIsSeeking(isSeeking), m_identifier);
}
void MediaSourcePrivateRemote::waitForSeekCompleted()
{
m_gpuProcessConnection.connection().send(Messages::RemoteMediaSourceProxy::WaitForSeekCompleted(), m_identifier);
}
void MediaSourcePrivateRemote::seekCompleted()
{
m_gpuProcessConnection.connection().send(Messages::RemoteMediaSourceProxy::SeekCompleted(), m_identifier);
}
void MediaSourcePrivateRemote::setTimeFudgeFactor(const MediaTime& fudgeFactor)
{
MediaSourcePrivate::setTimeFudgeFactor(fudgeFactor);
m_gpuProcessConnection.connection().send(Messages::RemoteMediaSourceProxy::SetTimeFudgeFactor(fudgeFactor), m_identifier);
}
void MediaSourcePrivateRemote::seekToTime(const MediaTime& time)
{
m_client->seekToTime(time);
}
#if !RELEASE_LOG_DISABLED
WTFLogChannel& MediaSourcePrivateRemote::logChannel() const
{
return LogMedia;
}
#endif
}
#endif // ENABLE(GPU_PROCESS) && ENABLE(MEDIA_SOURCE)