Revision control
++ // Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qohosmediaplayer_p.h"
++
++ #include "qohosglobal_p.h"
++ #include "common/qohosvideooutput_p.h"
++ #include "common/qohosvideosink_p.h"
++
++ #include <private/qplatformaudiooutput_p.h>
++
++ #include <QtMultimedia/qaudiooutput.h>
++ #include <QtMultimedia/qmediaplayer.h>
++ #include <QtMultimedia/qmediametadata.h>
++ #include <QtMultimedia/qmediatimerange.h>
++ #include <QtMultimedia/qvideosink.h>
++
++ #include <QtCore/qfile.h>
++ #include <QtCore/qtimer.h>
++ #include <QtCore/qfileinfo.h>
++ #include <QtCore/qtemporaryfile.h>
++ #include <QtCore/qloggingcategory.h>
++ #include <QtCore/qmetaobject.h>
++ #include <QtCore/qpointer.h>
++
++ #include <multimedia/player_framework/native_averrors.h>
++
++ QT_BEGIN_NAMESPACE
++
++ static constexpr int surfaceWaitTimeoutMs = 500;
++
++ namespace {
++
++ QMediaPlayer::MediaStatus mediaStatusFor(AVPlayerState state, bool atEnd)
++ {
++ if (atEnd)
++ return QMediaPlayer::EndOfMedia;
++
++ switch (state) {
++ case AV_IDLE:
++ return QMediaPlayer::NoMedia;
++ case AV_INITIALIZED:
++ return QMediaPlayer::LoadingMedia;
++ case AV_PREPARED:
++ case AV_STOPPED:
++ return QMediaPlayer::LoadedMedia;
++ case AV_PLAYING:
++ case AV_PAUSED:
++ return QMediaPlayer::BufferedMedia;
++ case AV_COMPLETED:
++ return QMediaPlayer::EndOfMedia;
++ case AV_RELEASED:
++ case AV_ERROR:
++ return QMediaPlayer::InvalidMedia;
++ }
++ return QMediaPlayer::NoMedia;
++ }
++
++ QMediaPlayer::PlaybackState playbackStateFor(AVPlayerState state)
++ {
++ switch (state) {
++ case AV_PLAYING:
++ return QMediaPlayer::PlayingState;
++ case AV_PAUSED:
++ return QMediaPlayer::PausedState;
++ case AV_IDLE:
++ case AV_INITIALIZED:
++ case AV_PREPARED:
++ case AV_STOPPED:
++ case AV_COMPLETED:
++ case AV_RELEASED:
++ case AV_ERROR:
++ break;
++ }
++ return QMediaPlayer::StoppedState;
++ }
++
++ AVPlaybackSpeed playbackSpeedFor(qreal rate)
++ {
++ // Map onto the closest discrete OH speed enum (SetPlaybackRate is API 20+).
++ if (rate <= 0.1875)
++ return AV_SPEED_FORWARD_0_125_X;
++ if (rate <= 0.375)
++ return AV_SPEED_FORWARD_0_25_X;
++ if (rate <= 0.625)
++ return AV_SPEED_FORWARD_0_50_X;
++ if (rate <= 0.875)
++ return AV_SPEED_FORWARD_0_75_X;
++ if (rate < 1.125)
++ return AV_SPEED_FORWARD_1_00_X;
++ if (rate < 1.375)
++ return AV_SPEED_FORWARD_1_25_X;
++ if (rate < 1.625)
++ return AV_SPEED_FORWARD_1_50_X;
++ if (rate < 1.875)
++ return AV_SPEED_FORWARD_1_75_X;
++ if (rate < 2.5)
++ return AV_SPEED_FORWARD_2_00_X;
++ return AV_SPEED_FORWARD_3_00_X;
++ }
++
++ } // namespace
++
++ QOhosMediaPlayer::QOhosMediaPlayer(QMediaPlayer *parent)
++ : QObject(parent), QPlatformMediaPlayer(parent)
++ {
++ }
++
++ QOhosMediaPlayer::~QOhosMediaPlayer()
++ {
++ releasePlayer();
++ }
++
++ qint64 QOhosMediaPlayer::duration() const
++ {
++ return m_duration;
++ }
++
++ qint64 QOhosMediaPlayer::position() const
++ {
++ return m_position.load();
++ }
++
++ void QOhosMediaPlayer::setPosition(qint64 position)
++ {
++ if (!m_player)
++ return;
++ OH_AVPlayer_Seek(m_player, static_cast<int32_t>(position), AV_SEEK_NEXT_SYNC);
++ }
++
++ float QOhosMediaPlayer::bufferProgress() const
++ {
++ return m_bufferProgress;
++ }
++
++ bool QOhosMediaPlayer::isSeekable() const
++ {
++ return m_seekable;
++ }
++
++ QMediaTimeRange QOhosMediaPlayer::availablePlaybackRanges() const
++ {
++ if (m_duration <= 0)
++ return {};
++ return QMediaTimeRange{ 0, m_duration };
++ }
++
++ qreal QOhosMediaPlayer::playbackRate() const
++ {
++ return m_playbackRate;
++ }
++
++ void QOhosMediaPlayer::setPlaybackRate(qreal rate)
++ {
++ if (qFuzzyCompare(m_playbackRate, rate))
++ return;
++ m_playbackRate = rate;
++ if (m_player)
++ OH_AVPlayer_SetPlaybackSpeed(m_player, playbackSpeedFor(rate));
++ playbackRateChanged(rate);
++ }
++
++ QUrl QOhosMediaPlayer::media() const
++ {
++ return m_media;
++ }
++
++ const QIODevice *QOhosMediaPlayer::mediaStream() const
++ {
++ return m_stream;
++ }
++
++ void QOhosMediaPlayer::setMedia(const QUrl &media, QIODevice *stream)
++ {
++ m_media = media;
++ m_stream = stream;
++
++ if (m_player)
++ OH_AVPlayer_Reset(m_player);
++ clearSource();
++
++ if (media.isEmpty()) {
++ m_duration = 0;
++ m_position.store(0);
++ m_pendingSetMedia = false;
++ mediaStatusChanged(QMediaPlayer::NoMedia);
++ stateChanged(QMediaPlayer::StoppedState);
++ return;
++ }
++
++ // Reject obviously bad file-like sources synchronously so the test
++ // QMediaPlayer-style "invalid file" cases see ResourceError immediately
++ // instead of waiting forever on the deferred surface. QMediaPlayer's
++ // observable contract is "Loading -> Invalid", so emit Loading first even
++ // when the failure is immediate.
++ const QString scheme = media.scheme();
++ if (media.isLocalFile() || scheme.isEmpty() || scheme == QLatin1String("qrc")) {
++ QString openPath;
++ if (media.isLocalFile())
++ openPath = media.toLocalFile();
++ else if (scheme == QLatin1String("qrc"))
++ openPath = QLatin1Char(':') + media.path();
++ else
++ openPath = media.toString();
++ QFile probe(openPath);
++ if (!probe.open(QIODevice::ReadOnly)) {
++ mediaStatusChanged(QMediaPlayer::LoadingMedia);
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ QStringLiteral("Cannot open '%1'").arg(openPath));
++ return;
++ }
++ }
++
++ m_pendingSetMedia = false;
++ m_sourceApplied = false;
++ m_surfaceWaitStarted = false;
++ // Apply on the next event-loop cycle so a videoOutput assigned right after
++ // the source is in place before we pick a prepare path.
++ QMetaObject::invokeMethod(this, &QOhosMediaPlayer::tryApplyPendingSource,
++ Qt::QueuedConnection);
++ }
++
++ void QOhosMediaPlayer::tryApplyPendingSource()
++ {
++ if (m_sourceApplied || m_media.isEmpty())
++ return;
++
++ // The surface can only be attached between SetSource and Prepare, so wait
++ // for it. A sink with no renderer never gets an RHI: give up and prepare
++ // without video rather than stall.
++ if (m_videoOutput && m_videoSink && !m_videoSink->rhi()) {
++ if (!m_surfaceWaitStarted) {
++ m_surfaceWaitStarted = true;
++ QTimer::singleShot(surfaceWaitTimeoutMs, this, [this] {
++ if (!m_sourceApplied && m_pendingSetMedia && !m_media.isEmpty()) {
++ m_pendingSetMedia = false;
++ m_sourceApplied = true;
++ applyPendingSource();
++ }
++ });
++ }
++ m_pendingSetMedia = true;
++ mediaStatusChanged(QMediaPlayer::LoadingMedia);
++ return;
++ }
++
++ m_sourceApplied = true;
++ applyPendingSource();
++ }
++
++ void QOhosMediaPlayer::applyPendingSource()
++ {
++ if (!ensurePlayer()) {
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ QStringLiteral("Failed to create OH_AVPlayer"));
++ return;
++ }
++
++ OH_AVPlayer_SetAudioRendererInfo(m_player, AUDIOSTREAM_USAGE_MOVIE);
++
++ m_videoSurfaceAttached = false;
++
++ // Surface the LoadingMedia status before we hand the source to OH_AVPlayer
++ // so any synchronous SetURLSource/SetFDSource rejection still produces the
++ // observable Loading -> Invalid transition QMediaPlayer guarantees.
++ mediaStatusChanged(QMediaPlayer::LoadingMedia);
++
++ OH_AVErrCode result = AV_ERR_OK;
++ const QString scheme = m_media.scheme();
++ const bool isQrc = scheme == QLatin1String("qrc");
++ const bool isFileLike = m_media.isLocalFile() || scheme.isEmpty() || isQrc;
++ if (isFileLike) {
++ QString openPath;
++ if (m_media.isLocalFile()) {
++ openPath = m_media.toLocalFile();
++ } else if (isQrc) {
++ // QFile understands ":/path" for embedded resources.
++ openPath = QLatin1Char(':') + m_media.path();
++ } else {
++ // Bare relative paths.
++ openPath = m_media.toString();
++ }
++ auto file = std::make_unique<QFile>(openPath);
++ if (!file->open(QIODevice::ReadOnly)) {
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ QStringLiteral("Cannot open '%1'").arg(openPath));
++ return;
++ }
++ const int fd = file->handle();
++ const qint64 size = file->size();
++ if (fd < 0) {
++ // Resource-backed QFile is mapped, not file-descriptor-backed —
++ // AVPlayer needs a real fd, so spool to a temp file before handing
++ // it off.
++ auto temp = std::make_unique<QTemporaryFile>();
++ if (!temp->open() || temp->write(file->readAll()) < 0) {
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ QStringLiteral("Cannot stage '%1'").arg(openPath));
++ return;
++ }
++ temp->flush();
++ temp->seek(0);
++ const int tempFd = temp->handle();
++ const qint64 tempSize = temp->size();
++ result = OH_AVPlayer_SetFDSource(m_player, tempFd, 0, tempSize);
++ m_sourceFile = std::move(temp);
++ } else {
++ result = OH_AVPlayer_SetFDSource(m_player, fd, 0, size);
++ m_sourceFile = std::move(file);
++ }
++ } else {
++ const QByteArray url = m_media.toString(QUrl::FullyEncoded).toUtf8();
++ result = OH_AVPlayer_SetURLSource(m_player, url.constData());
++ }
++
++ if (result != AV_ERR_OK) {
++ qCWarning(qLcOhosMediaPlugin) << "Source rejected, error" << int(result);
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ QStringLiteral("OH_AVPlayer rejected the source"));
++ clearSource();
++ return;
++ }
++
++ if (m_videoOutput) {
++ if (auto *window = m_videoOutput->nativeWindow()) {
++ if (OH_AVPlayer_SetVideoSurface(m_player, window) == AV_ERR_OK)
++ m_videoSurfaceAttached = true;
++ else
++ qCWarning(qLcOhosMediaPlugin) << "OH_AVPlayer_SetVideoSurface failed";
++ }
++ }
++
++ result = OH_AVPlayer_Prepare(m_player);
++ if (result != AV_ERR_OK) {
++ qCWarning(qLcOhosMediaPlugin) << "Prepare failed, error" << int(result);
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ QStringLiteral("OH_AVPlayer_Prepare failed"));
++ clearSource();
++ }
++ }
++
++ void QOhosMediaPlayer::play()
++ {
++ if (!m_player) {
++ m_pendingPlay = !m_media.isEmpty();
++ return;
++ }
++
++ if (m_avState == AV_PREPARED || m_avState == AV_PAUSED || m_avState == AV_COMPLETED
++ || m_avState == AV_STOPPED) {
++ m_pendingPlay = false;
++ OH_AVPlayer_Play(m_player);
++ } else {
++ // Prepare hasn't finished yet — defer play to AV_INFO_TYPE_STATE_CHANGE
++ m_pendingPlay = true;
++ }
++ }
++
++ void QOhosMediaPlayer::pause()
++ {
++ m_pendingPlay = false;
++ if (m_player && m_avState == AV_PLAYING)
++ OH_AVPlayer_Pause(m_player);
++ }
++
++ void QOhosMediaPlayer::stop()
++ {
++ m_pendingPlay = false;
++ if (!m_player)
++ return;
++ if (m_avState == AV_PLAYING || m_avState == AV_PAUSED || m_avState == AV_PREPARED
++ || m_avState == AV_COMPLETED)
++ OH_AVPlayer_Stop(m_player);
++ }
++
++ void QOhosMediaPlayer::setAudioOutput(QPlatformAudioOutput *output)
++ {
++ m_audioOutput = output;
++ applyVolume();
++ }
++
++ void QOhosMediaPlayer::setVideoSink(QVideoSink *sink)
++ {
++ m_videoSink = sink;
++
++ if (!sink) {
++ m_videoOutput.reset();
++ return;
++ }
++
++ if (!m_videoOutput) {
++ m_videoOutput = std::make_unique<QOhosVideoOutput>(
++ sink, QOhosVideoOutput::ContentSource::MediaPlayer, this);
++ connect(m_videoOutput.get(), &QOhosVideoOutput::surfaceReady, this,
++ &QOhosMediaPlayer::onVideoSurfaceReady);
++ }
++ }
++
++ int QOhosMediaPlayer::trackCount(TrackType type)
++ {
++ // OH_AVPlayer doesn't enumerate per-stream metadata up front; expose the
++ // detected presence of audio/video as a single default track so QMediaPlayer
++ // consumers can ask for activeTrack(0) and get a sensible answer.
++ switch (type) {
++ case TrackType::VideoStream:
++ return m_hasVideoTrack ? 1 : 0;
++ case TrackType::AudioStream:
++ return m_hasAudioTrack ? 1 : 0;
++ case TrackType::SubtitleStream:
++ break;
++ }
++ return 0;
++ }
++
++ QMediaMetaData QOhosMediaPlayer::trackMetaData(TrackType type, int streamNumber)
++ {
++ if (streamNumber != 0 || trackCount(type) == 0)
++ return {};
++ QMediaMetaData md;
++ md.insert(QMediaMetaData::Language, QVariant::fromValue(QLocale::AnyLanguage));
++ return md;
++ }
++
++ QMediaMetaData QOhosMediaPlayer::metaData() const
++ {
++ QMediaMetaData md;
++ if (m_duration > 0)
++ md.insert(QMediaMetaData::Duration, m_duration);
++ if (m_videoWidth > 0 && m_videoHeight > 0)
++ md.insert(QMediaMetaData::Resolution, QSize{ m_videoWidth, m_videoHeight });
++ return md;
++ }
++
++ int QOhosMediaPlayer::activeTrack(TrackType type)
++ {
++ return trackCount(type) > 0 ? 0 : -1;
++ }
++
++ void QOhosMediaPlayer::onVideoSurfaceReady()
++ {
++ if (m_pendingSetMedia && !m_media.isEmpty()) {
++ m_pendingSetMedia = false;
++ m_sourceApplied = true;
++ applyPendingSource();
++ }
++ }
++
++ void QOhosMediaPlayer::handleStateChange(AVPlayerState newState)
++ {
++ if (m_avState == newState)
++ return;
++ m_avState = newState;
++
++ // AV_IDLE is a transient state that OH_AVPlayer enters during Reset() as
++ // setMedia() is replacing the source. The user-facing NoMedia status is
++ // already emitted from setMedia(QUrl{}); leaking another NoMedia between a
++ // LoadingMedia/Invalid transition breaks observable status sequences.
++ if (newState == AV_IDLE)
++ return;
++
++ if (newState == AV_PREPARED) {
++ int32_t durationMs = 0;
++ if (OH_AVPlayer_GetDuration(m_player, &durationMs) == AV_ERR_OK) {
++ if (m_duration != durationMs) {
++ m_duration = durationMs;
++ durationChanged(m_duration);
++ }
++ }
++ m_seekable = m_duration > 0;
++ seekableChanged(m_seekable);
++
++ int32_t videoWidth = 0;
++ int32_t videoHeight = 0;
++ OH_AVPlayer_GetVideoWidth(m_player, &videoWidth);
++ OH_AVPlayer_GetVideoHeight(m_player, &videoHeight);
++ const bool hasVideo = videoWidth > 0 && videoHeight > 0;
++ if (hasVideo && m_videoOutput)
++ m_videoOutput->setVideoSize(QSize{ videoWidth, videoHeight });
++ videoAvailableChanged(hasVideo);
++ audioAvailableChanged(true);
++ const bool prevHasVideo = m_hasVideoTrack;
++ const bool prevHasAudio = m_hasAudioTrack;
++ m_hasVideoTrack = hasVideo;
++ m_hasAudioTrack = true;
++ if (prevHasVideo != m_hasVideoTrack || prevHasAudio != m_hasAudioTrack) {
++ tracksChanged();
++ activeTracksChanged();
++ }
++ m_videoWidth = videoWidth;
++ m_videoHeight = videoHeight;
++ metaDataChanged();
++ }
++
++ mediaStatusChanged(mediaStatusFor(newState, false));
++ stateChanged(playbackStateFor(newState));
++
++ if (newState == AV_PREPARED && m_pendingPlay) {
++ m_pendingPlay = false;
++ OH_AVPlayer_Play(m_player);
++ }
++ }
++
++ void QOhosMediaPlayer::handleEndOfStream()
++ {
++ mediaStatusChanged(QMediaPlayer::EndOfMedia);
++ stateChanged(QMediaPlayer::StoppedState);
++ }
++
++ void QOhosMediaPlayer::handleSeekDone()
++ {
++ // Position will refresh via AV_INFO_TYPE_POSITION_UPDATE.
++ }
++
++ void QOhosMediaPlayer::handleResolutionChange()
++ {
++ if (!m_player)
++ return;
++ int32_t width = 0;
++ int32_t height = 0;
++ OH_AVPlayer_GetVideoWidth(m_player, &width);
++ OH_AVPlayer_GetVideoHeight(m_player, &height);
++ m_videoWidth = width;
++ m_videoHeight = height;
++ if (m_videoOutput && width > 0 && height > 0)
++ m_videoOutput->setVideoSize(QSize{ width, height });
++ videoAvailableChanged(width > 0 && height > 0);
++ }
++
++ void QOhosMediaPlayer::handleBufferingUpdate(int bufferingPercent)
++ {
++ const float progress = std::clamp(bufferingPercent / 100.0f, 0.0f, 1.0f);
++ if (qFuzzyCompare(m_bufferProgress, progress))
++ return;
++ m_bufferProgress = progress;
++ bufferProgressChanged(progress);
++ }
++
++ void QOhosMediaPlayer::handleError(int32_t errorCode, const QString &errorMsg)
++ {
++ qCWarning(qLcOhosMediaPlugin) << "OH_AVPlayer error" << errorCode << errorMsg;
++ setInvalidMediaWithError(QMediaPlayer::ResourceError,
++ errorMsg.isEmpty() ? QStringLiteral("AVPlayer error %1").arg(errorCode)
++ : errorMsg);
++ }
++
++ void QOhosMediaPlayer::releasePlayer()
++ {
++ if (!m_player)
++ return;
++ OH_AVPlayer_SetOnInfoCallback(m_player, nullptr, nullptr);
++ OH_AVPlayer_SetOnErrorCallback(m_player, nullptr, nullptr);
++ OH_AVPlayer_ReleaseSync(m_player);
++ m_player = nullptr;
++ clearSource();
++ }
++
++ void QOhosMediaPlayer::clearSource()
++ {
++ m_sourceFile.reset();
++ const bool changed = m_hasVideoTrack || m_hasAudioTrack;
++ m_hasVideoTrack = false;
++ m_hasAudioTrack = false;
++ const bool hadMetadata = m_duration > 0 || m_videoWidth > 0 || m_videoHeight > 0;
++ m_videoWidth = 0;
++ m_videoHeight = 0;
++ if (changed) {
++ tracksChanged();
++ activeTracksChanged();
++ }
++ if (hadMetadata)
++ metaDataChanged();
++ }
++
++ bool QOhosMediaPlayer::ensurePlayer()
++ {
++ if (m_player)
++ return true;
++ m_player = OH_AVPlayer_Create();
++ if (!m_player) {
++ qCWarning(qLcOhosMediaPlugin) << "OH_AVPlayer_Create failed";
++ return false;
++ }
++ OH_AVPlayer_SetOnInfoCallback(m_player, &QOhosMediaPlayer::onInfoTrampoline, this);
++ OH_AVPlayer_SetOnErrorCallback(m_player, &QOhosMediaPlayer::onErrorTrampoline, this);
++ return true;
++ }
++
++ void QOhosMediaPlayer::applyVolume()
++ {
++ if (!m_player)
++ return;
++
++ float volume = 1.0f;
++ if (m_audioOutput)
++ volume = m_audioOutput->muted ? 0.0f : m_audioOutput->volume;
++
++ OH_AVPlayer_SetVolume(m_player, volume, volume);
++ }
++
++ void QOhosMediaPlayer::onInfoTrampoline(OH_AVPlayer *player, AVPlayerOnInfoType type,
++ OH_AVFormat *body, void *userData)
++ {
++ Q_UNUSED(body)
++ Q_UNUSED(player)
++ auto *self = reinterpret_cast<QOhosMediaPlayer *>(userData);
++ if (!self)
++ return;
++
++ switch (type) {
++ case AV_INFO_TYPE_STATE_CHANGE: {
++ AVPlayerState state{ AV_IDLE };
++ OH_AVPlayer_GetState(player, &state);
++ QMetaObject::invokeMethod(
++ self, [self, state]() { self->handleStateChange(state); }, Qt::QueuedConnection);
++ break;
++ }
++ case AV_INFO_TYPE_POSITION_UPDATE: {
++ int32_t pos = 0;
++ OH_AVPlayer_GetCurrentTime(player, &pos);
++ self->m_position.store(pos);
++ QMetaObject::invokeMethod(
++ self, [self, pos]() { self->positionChanged(qint64{ pos }); },
++ Qt::QueuedConnection);
++ break;
++ }
++ case AV_INFO_TYPE_DURATION_UPDATE: {
++ int32_t dur = 0;
++ OH_AVPlayer_GetDuration(player, &dur);
++ QMetaObject::invokeMethod(
++ self,
++ [self, dur]() {
++ if (self->m_duration == dur)
++ return;
++ self->m_duration = dur;
++ self->durationChanged(qint64{ dur });
++ },
++ Qt::QueuedConnection);
++ break;
++ }
++ case AV_INFO_TYPE_EOS:
++ QMetaObject::invokeMethod(
++ self, [self]() { self->handleEndOfStream(); }, Qt::QueuedConnection);
++ break;
++ case AV_INFO_TYPE_SEEKDONE:
++ QMetaObject::invokeMethod(
++ self, [self]() { self->handleSeekDone(); }, Qt::QueuedConnection);
++ break;
++ case AV_INFO_TYPE_RESOLUTION_CHANGE:
++ QMetaObject::invokeMethod(
++ self, [self]() { self->handleResolutionChange(); }, Qt::QueuedConnection);
++ break;
++ default:
++ break;
++ }
++ }
++
++ void QOhosMediaPlayer::onErrorTrampoline(OH_AVPlayer *, int32_t errorCode, const char *errorMsg,
++ void *userData)
++ {
++ auto *self = reinterpret_cast<QOhosMediaPlayer *>(userData);
++ if (!self)
++ return;
++ QString message = errorMsg ? QString::fromUtf8(errorMsg) : QString{};
++ QMetaObject::invokeMethod(
++ self, [self, errorCode, message]() { self->handleError(errorCode, message); },
++ Qt::QueuedConnection);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qohosmediaplayer_p.cpp"