Revision control
Copy as Markdown
// Copyright (C) 2022 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 "qwasmaudiooutput_p.h"
#include <QtMultimedia/qaudiodevice.h>
#include <QtMultimedia/qaudiooutput.h>
#include <QtMultimedia/qmediadevices.h>
#include <QtCore/qfile.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qmimedatabase.h>
#include <QtCore/qurl.h>
QT_BEGIN_NAMESPACE
using namespace Qt::Literals;
Q_STATIC_LOGGING_CATEGORY(qWasmMediaAudioOutput, "qt.multimedia.wasm.audiooutput");
QWasmAudioOutput::QWasmAudioOutput(QAudioOutput *parent)
: QPlatformAudioOutput(parent)
{
}
QWasmAudioOutput::~QWasmAudioOutput() = default;
void QWasmAudioOutput::setAudioDevice(const QAudioDevice &audioDevice)
{
qCDebug(qWasmMediaAudioOutput) << Q_FUNC_INFO << device.id();
device = audioDevice;
}
void QWasmAudioOutput::setVideoElement(emscripten::val videoElement)
{
m_videoElement = videoElement;
}
emscripten::val QWasmAudioOutput::videoElement()
{
return m_videoElement;
}
void QWasmAudioOutput::setMuted(bool muted)
{
emscripten::val realElement = videoElement();
if (!realElement.isUndefined()) {
realElement.set("muted", muted);
return;
}
if (m_audio.isUndefined() || m_audio.isNull()) {
qCDebug(qWasmMediaAudioOutput) << "Error"
<< "Audio element could not be created";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Media file could not be opened"));
return;
}
m_audio.set("mute", muted);
}
void QWasmAudioOutput::setVolume(float volume)
{
volume = qBound(qreal(0.0), volume, qreal(1.0));
emscripten::val realElement = videoElement();
if (!realElement.isUndefined()) {
realElement.set("volume", volume);
return;
}
if (m_audio.isUndefined() || m_audio.isNull()) {
qCDebug(qWasmMediaAudioOutput) << "Error"
<< "Audio element not available";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Media file could not be opened"));
return;
}
m_audio.set("volume", volume);
}
void QWasmAudioOutput::setSource(const QUrl &url)
{
qCDebug(qWasmMediaAudioOutput) << Q_FUNC_INFO << url;
if (url.isEmpty()) {
stop();
return;
}
createAudioElement(device.id().toStdString());
if (m_audio.isUndefined() || m_audio.isNull()) {
qCDebug(qWasmMediaAudioOutput) << "Error"
<< "Audio element could not be created";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Audio element could not be created"));
return;
}
emscripten::val document = emscripten::val::global("document");
emscripten::val body = document["body"];
m_audio.set("id", device.id().toStdString());
body.call<void>("appendChild", m_audio);
if (url.isLocalFile()) { // is localfile
qCDebug(qWasmMediaAudioOutput) << "is localfile";
m_source = url.toLocalFile();
QFile mediaFile(m_source);
if (!mediaFile.exists()) {
qCDebug(qWasmMediaAudioOutput) << "Error"
<< "Media file does not exist";
QMetaObject::invokeMethod(this, &QWasmAudioOutput::errorOccured, Qt::QueuedConnection,
QMediaPlayer::ResourceError,
QStringLiteral("Media file does not exist"));
return;
}
if (!mediaFile.open(QIODevice::ReadOnly)) {
qCDebug(qWasmMediaAudioOutput) << "Error"
<< "Media file could not be opened";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Media file could not be opened"));
return;
}
// local files are relatively small due to browser filesystem being restricted
QByteArray content = mediaFile.readAll();
QMimeDatabase db;
qCDebug(qWasmMediaAudioOutput) << db.mimeTypeForData(content).name();
qstdweb::Blob contentBlob = qstdweb::Blob::copyFrom(content.constData(), content.size());
emscripten::val contentUrl =
qstdweb::window()["URL"].call<emscripten::val>("createObjectURL", contentBlob.val());
emscripten::val audioSourceElement =
document.call<emscripten::val>("createElement", std::string("source"));
audioSourceElement.set("src", contentUrl);
// work around Safari not being able to read audio from blob URLs.
QFileInfo info(m_source);
QMimeType mimeType = db.mimeTypeForFile(info);
audioSourceElement.set("type", mimeType.name().toStdString());
m_audio.call<void>("appendChild", audioSourceElement);
m_audio.call<void>("setAttribute", emscripten::val("srcObject"), contentUrl);
} else {
m_source = url.toString();
m_audio.set("src", m_source.toStdString());
}
m_audio.set("id", device.id().toStdString());
body.call<void>("appendChild", m_audio);
qCDebug(qWasmMediaAudioOutput) << Q_FUNC_INFO << device.id();
doElementCallbacks();
}
void QWasmAudioOutput::setSource(QIODevice *stream)
{
m_audioIODevice = stream;
}
void QWasmAudioOutput::start()
{
if (m_audio.isNull() || m_audio.isUndefined()) {
qCDebug(qWasmMediaAudioOutput) << "audio failed to start";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Audio element resource error"));
return;
}
m_audio.call<void>("play");
}
void QWasmAudioOutput::stop()
{
if (m_audio.isNull() || m_audio.isUndefined()) {
qCDebug(qWasmMediaAudioOutput) << "audio failed to start";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Audio element resource error"));
return;
}
if (!m_source.isEmpty()) {
pause();
m_audio.set("currentTime", emscripten::val(0));
}
if (m_audioIODevice) {
m_audioIODevice->close();
delete m_audioIODevice;
m_audioIODevice = 0;
}
}
void QWasmAudioOutput::pause()
{
if (m_audio.isNull() || m_audio.isUndefined()) {
qCDebug(qWasmMediaAudioOutput) << "audio failed to start";
Q_EMIT errorOccured(QMediaPlayer::ResourceError,
QStringLiteral("Audio element resource error"));
return;
}
m_audio.call<emscripten::val>("pause");
}
void QWasmAudioOutput::createAudioElement(const std::string &id)
{
emscripten::val document = emscripten::val::global("document");
m_audio = document.call<emscripten::val>("createElement", std::string("audio"));
if (id == "System output") { // defaul output, no perms needed
emscripten::val audioContext = emscripten::val::global("window")["AudioContext"].new_();
emscripten::val sourceNode = audioContext.call<emscripten::val>("createMediaElementSource", m_audio);
sourceNode.call<void>("connect", audioContext["destination"]);
// or control volume // is this needed?
// emscripten::val volumeNode = audioContext.call<emscripten::val>("createGain");
// sourceNode.call<void>("connect", volumeNode);
// volumeNode.call<void>("connect", audioContext["destination"]);
}
// only works in chrome and firefox.
// Firefox this feature is behind media.setsinkid.enabled preferences
// allows user to choose audio output device
if (!m_audio.hasOwnProperty("sinkId") || m_audio["sinkId"].isUndefined()) {
return;
}
std::string usableId = id;
if (usableId.empty() || usableId == "System output")
usableId = QMediaDevices::defaultAudioOutput().id();
qstdweb::PromiseCallbacks sinkIdCallbacks{
.thenFunc = [](emscripten::val) { qCWarning(qWasmMediaAudioOutput) << "setSinkId ok"; },
.catchFunc =
[](emscripten::val) {
qCWarning(qWasmMediaAudioOutput) << "Error while trying to setSinkId";
},
.finallyFunc = nullptr
};
qstdweb::Promise::make(m_audio, u"setSinkId"_s, std::move(sinkIdCallbacks), std::move(usableId));
m_audio.set("id", usableId.c_str());
}
void QWasmAudioOutput::doElementCallbacks()
{
// error
auto errorCallback = [&](emscripten::val event) {
qCDebug(qWasmMediaAudioOutput) << "error";
if (event.isUndefined() || event.isNull())
return;
Q_EMIT errorOccured(m_audio["error"]["code"].as<int>(),
QString::fromStdString(m_audio["error"]["message"].as<std::string>()));
QString errorMessage =
QString::fromStdString(m_audio["error"]["message"].as<std::string>());
if (errorMessage.isEmpty()) {
switch (m_audio["error"]["code"].as<int>()) {
case AudioElementError::MEDIA_ERR_ABORTED:
errorMessage = QStringLiteral("aborted by the user agent at the user's request.");
break;
case AudioElementError::MEDIA_ERR_NETWORK:
errorMessage = QStringLiteral("network error.");
break;
case AudioElementError::MEDIA_ERR_DECODE:
errorMessage = QStringLiteral("decoding error.");
break;
case AudioElementError::MEDIA_ERR_SRC_NOT_SUPPORTED:
errorMessage = QStringLiteral("src attribute not suitable.");
break;
};
}
qCDebug(qWasmMediaAudioOutput) << m_audio["error"]["code"].as<int>() << errorMessage;
Q_EMIT errorOccured(m_audio["error"]["code"].as<int>(), errorMessage);
};
m_errorChangeEvent.reset(new qstdweb::EventCallback(m_audio, "error", errorCallback));
// loadeddata
auto loadedDataCallback = [&](emscripten::val event) {
Q_UNUSED(event)
qCDebug(qWasmMediaAudioOutput) << "loaded data";
qstdweb::window()["URL"].call<emscripten::val>("revokeObjectURL", m_audio["src"]);
};
m_loadedDataEvent.reset(new qstdweb::EventCallback(m_audio, "loadeddata", loadedDataCallback));
// canplay
auto canPlayCallback = [&](emscripten::val event) {
if (event.isUndefined() || event.isNull())
return;
qCDebug(qWasmMediaAudioOutput) << "can play";
Q_EMIT readyChanged(true);
Q_EMIT stateChanged(QWasmMediaPlayer::Preparing);
};
m_canPlayChangeEvent.reset(new qstdweb::EventCallback(m_audio, "canplay", canPlayCallback));
// canplaythrough
auto canPlayThroughCallback = [&](emscripten::val event) {
Q_UNUSED(event)
Q_EMIT stateChanged(QWasmMediaPlayer::Prepared);
};
m_canPlayThroughChangeEvent.reset(
new qstdweb::EventCallback(m_audio, "canplaythrough", canPlayThroughCallback));
// play
auto playCallback = [&](emscripten::val event) {
Q_UNUSED(event)
qCDebug(qWasmMediaAudioOutput) << "play";
Q_EMIT stateChanged(QWasmMediaPlayer::Started);
};
m_playEvent.reset(new qstdweb::EventCallback(m_audio, "play", playCallback));
// durationchange
auto durationChangeCallback = [&](emscripten::val event) {
qCDebug(qWasmMediaAudioOutput) << "durationChange";
// duration in ms
Q_EMIT durationChanged(event["target"]["duration"].as<double>() * 1000);
};
m_durationChangeEvent.reset(
new qstdweb::EventCallback(m_audio, "durationchange", durationChangeCallback));
// ended
auto endedCallback = [&](emscripten::val event) {
Q_UNUSED(event)
qCDebug(qWasmMediaAudioOutput) << "ended";
m_currentMediaStatus = QMediaPlayer::EndOfMedia;
Q_EMIT statusChanged(m_currentMediaStatus);
};
m_endedEvent.reset(new qstdweb::EventCallback(m_audio, "ended", endedCallback));
// progress (buffering progress)
auto progesssCallback = [&](emscripten::val event) {
if (event.isUndefined() || event.isNull())
return;
qCDebug(qWasmMediaAudioOutput) << "progress";
float duration = event["target"]["duration"].as<int>();
if (duration < 0) // track not exactly ready yet
return;
emscripten::val timeRanges = event["target"]["buffered"];
if ((!timeRanges.isNull() || !timeRanges.isUndefined())
&& timeRanges["length"].as<int>() == 1) {
emscripten::val dVal = timeRanges.call<emscripten::val>("end", 0);
if (!dVal.isNull() || !dVal.isUndefined()) {
double bufferedEnd = dVal.as<double>();
if (duration > 0 && bufferedEnd > 0) {
float bufferedValue = (bufferedEnd / duration * 100);
qCDebug(qWasmMediaAudioOutput) << "progress buffered" << bufferedValue;
Q_EMIT bufferingChanged(m_currentBufferedValue);
if (bufferedEnd == duration)
m_currentMediaStatus = QMediaPlayer::BufferedMedia;
else
m_currentMediaStatus = QMediaPlayer::BufferingMedia;
Q_EMIT statusChanged(m_currentMediaStatus);
}
}
}
};
m_progressChangeEvent.reset(new qstdweb::EventCallback(m_audio, "progress", progesssCallback));
// timupdate
auto timeUpdateCallback = [&](emscripten::val event) {
qCDebug(qWasmMediaAudioOutput)
<< "timeupdate" << (event["target"]["currentTime"].as<double>() * 1000);
// qt progress is ms
Q_EMIT progressChanged(event["target"]["currentTime"].as<double>() * 1000);
};
m_timeUpdateEvent.reset(new qstdweb::EventCallback(m_audio, "timeupdate", timeUpdateCallback));
// pause
auto pauseCallback = [&](emscripten::val event) {
Q_UNUSED(event)
qCDebug(qWasmMediaAudioOutput) << "pause";
int currentTime = m_audio["currentTime"].as<int>(); // in seconds
int duration = m_audio["duration"].as<int>(); // in seconds
if ((currentTime > 0 && currentTime < duration)) {
Q_EMIT stateChanged(QWasmMediaPlayer::Paused);
} else {
Q_EMIT stateChanged(QWasmMediaPlayer::Stopped);
}
};
m_pauseChangeEvent.reset(new qstdweb::EventCallback(m_audio, "pause", pauseCallback));
}
QT_END_NAMESPACE