Revision control
++ // 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 "qqnxaudiorecorder_p.h"
++ #include "qqnxmediaeventthread_p.h"
++
++ #include <QtCore/qcoreapplication.h>
++
++ #include <private/qmediastoragelocation_p.h>
++
++ #include <mm/renderer.h>
++
++ #include <sys/stat.h>
++ #include <sys/strm.h>
++
++ static QByteArray buildDevicePath(const QByteArray &deviceId, const QMediaEncoderSettings &settings)
++ {
++ QByteArray devicePath = QByteArrayLiteral("snd:/dev/snd/") + deviceId + QByteArrayLiteral("?");
++
++ if (settings.audioSampleRate() > 0)
++ devicePath += QByteArrayLiteral("frate=") + QByteArray::number(settings.audioSampleRate());
++
++ if (settings.audioChannelCount() > 0)
++ devicePath += QByteArrayLiteral("nchan=") + QByteArray::number(settings.audioChannelCount());
++
++ return devicePath;
++ }
++
++ QT_BEGIN_NAMESPACE
++
++ QQnxAudioRecorder::QQnxAudioRecorder(QObject *parent)
++ : QObject(parent)
++ {
++ openConnection();
++ }
++
++ QQnxAudioRecorder::~QQnxAudioRecorder()
++ {
++ stop();
++ closeConnection();
++ }
++
++ void QQnxAudioRecorder::openConnection()
++ {
++ static int idCounter = 0;
++
++ m_connection = ConnectionUniquePtr { mmr_connect(nullptr) };
++
++ if (!m_connection) {
++ qWarning("QQnxAudioRecorder: Unable to connect to the multimedia renderer");
++ return;
++ }
++
++ m_id = idCounter++;
++
++ char contextName[256];
++
++ std::snprintf(contextName, sizeof contextName, "QQnxAudioRecorder_%d_%llu",
++ m_id, QCoreApplication::applicationPid());
++
++ m_context = ContextUniquePtr { mmr_context_create(m_connection.get(),
++ contextName, 0, S_IRWXU|S_IRWXG|S_IRWXO) };
++
++ if (m_context) {
++ startMonitoring();
++ } else {
++ qWarning("QQnxAudioRecorder: Unable to create context");
++ closeConnection();
++ }
++ }
++
++ void QQnxAudioRecorder::closeConnection()
++ {
++ m_context.reset();
++ m_context.reset();
++
++ stopMonitoring();
++ }
++
++ void QQnxAudioRecorder::attach()
++ {
++ if (isAttached())
++ return;
++
++ const QString container = m_encoderSettings.preferredSuffix();
++ const QString location = QMediaStorageLocation::generateFileName(m_outputUrl.toLocalFile(),
++ QStandardPaths::MusicLocation, container);
++
++ m_audioId = mmr_output_attach(m_context.get(), qPrintable(location), "file");
++
++ if (m_audioId == -1) {
++ qWarning("QQnxAudioRecorder: mmr_output_attach() for file failed");
++ return;
++ }
++
++ configureOutputBitRate();
++
++ const QByteArray devicePath = buildDevicePath(m_inputDeviceId, m_encoderSettings);
++
++ if (mmr_input_attach(m_context.get(), devicePath.constData(), "track") != 0) {
++ qWarning("QQnxAudioRecorder: mmr_input_attach() failed");
++ detach();
++ } else {
++ Q_EMIT actualLocationChanged(QUrl{location});
++ }
++ }
++
++ void QQnxAudioRecorder::detach()
++ {
++ if (!isAttached())
++ return;
++
++ mmr_input_detach(m_context.get());
++ mmr_output_detach(m_context.get(), m_audioId);
++
++ m_audioId = -1;
++ }
++
++ void QQnxAudioRecorder::configureOutputBitRate()
++ {
++ const int bitRate = m_encoderSettings.audioBitRate();
++
++ if (!isAttached() || bitRate <= 0)
++ return;
++
++ char buf[12];
++ std::snprintf(buf, sizeof buf, "%d", bitRate);
++
++ strm_dict_t *dict = strm_dict_new();
++ dict = strm_dict_set(dict, "audio_bitrate", buf);
++
++ if (mmr_output_parameters(m_context.get(), m_audioId, dict) != 0)
++ qWarning("mmr_output_parameters: setting bitrate failed");
++ }
++
++ bool QQnxAudioRecorder::isAttached() const
++ {
++ return m_context && m_audioId != -1;
++ }
++
++ void QQnxAudioRecorder::setInputDeviceId(const QByteArray &id)
++ {
++ m_inputDeviceId = id;
++ }
++
++ void QQnxAudioRecorder::setOutputUrl(const QUrl &url)
++ {
++ m_outputUrl = url;
++ }
++
++ void QQnxAudioRecorder::setMediaEncoderSettings(const QMediaEncoderSettings &settings)
++ {
++ m_encoderSettings = settings;
++ }
++
++ void QQnxAudioRecorder::record()
++ {
++ if (!isAttached()) {
++ attach();
++
++ if (!isAttached())
++ return;
++ }
++
++ if (mmr_play(m_context.get()) != 0)
++ qWarning("QQnxAudioRecorder: mmr_play() failed");
++ }
++
++ void QQnxAudioRecorder::stop()
++ {
++ if (!isAttached())
++ return;
++
++ mmr_stop(m_context.get());
++
++ detach();
++ }
++
++ void QQnxAudioRecorder::startMonitoring()
++ {
++ m_eventThread = std::make_unique<QQnxMediaEventThread>(m_context.get());
++
++ connect(m_eventThread.get(), &QQnxMediaEventThread::eventPending,
++ this, &QQnxAudioRecorder::readEvents);
++
++ m_eventThread->setObjectName(QStringLiteral("MmrAudioEventThread-") + QString::number(m_id));
++ m_eventThread->start();
++ }
++
++ void QQnxAudioRecorder::stopMonitoring()
++ {
++ if (m_eventThread)
++ m_eventThread.reset();
++ }
++
++ void QQnxAudioRecorder::readEvents()
++ {
++ while (const mmr_event_t *event = mmr_event_get(m_context.get())) {
++ if (event->type == MMR_EVENT_NONE)
++ break;
++
++ switch (event->type) {
++ case MMR_EVENT_STATUS:
++ handleMmEventStatus(event);
++ break;
++ case MMR_EVENT_STATE:
++ handleMmEventState(event);
++ break;
++ case MMR_EVENT_ERROR:
++ handleMmEventError(event);
++ break;
++ case MMR_EVENT_METADATA:
++ case MMR_EVENT_NONE:
++ case MMR_EVENT_OVERFLOW:
++ case MMR_EVENT_WARNING:
++ case MMR_EVENT_PLAYLIST:
++ case MMR_EVENT_INPUT:
++ case MMR_EVENT_OUTPUT:
++ case MMR_EVENT_CTXTPAR:
++ case MMR_EVENT_TRKPAR:
++ case MMR_EVENT_OTHER:
++ break;
++ }
++ }
++
++ if (m_eventThread)
++ m_eventThread->signalRead();
++ }
++
++ void QQnxAudioRecorder::handleMmEventStatus(const mmr_event_t *event)
++ {
++ if (!event || event->type != MMR_EVENT_STATUS)
++ return;
++
++ if (!event->pos_str)
++ return;
++
++ const QByteArray valueBa(event->pos_str);
++
++ bool ok;
++ const qint64 duration = valueBa.toLongLong(&ok);
++
++ if (!ok)
++ qCritical("Could not parse duration from '%s'", valueBa.constData());
++ else
++ durationChanged(duration);
++ }
++
++ void QQnxAudioRecorder::handleMmEventState(const mmr_event_t *event)
++ {
++ if (!event || event->type != MMR_EVENT_STATE)
++ return;
++
++ switch (event->state) {
++ case MMR_STATE_DESTROYED:
++ case MMR_STATE_IDLE:
++ case MMR_STATE_STOPPED:
++ Q_EMIT stateChanged(QMediaRecorder::StoppedState);
++ break;
++ case MMR_STATE_PLAYING:
++ Q_EMIT stateChanged(QMediaRecorder::RecordingState);
++ break;
++ }
++ }
++
++ void QQnxAudioRecorder::handleMmEventError(const mmr_event_t *event)
++ {
++ if (!event)
++ return;
++
++ // When playback is explicitly stopped using mmr_stop(), mm-renderer
++ // generates a STATE event. When the end of media is reached, an ERROR
++ // event is generated and the error code contained in the event information
++ // is set to MMR_ERROR_NONE. When an error causes playback to stop,
++ // the error code is set to something else.
++ if (event->details.error.info.error_code == MMR_ERROR_NONE) {
++ //TODO add error
++ Q_EMIT stateChanged(QMediaRecorder::StoppedState);
++ detach();
++ }
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqnxaudiorecorder_p.cpp"