MusicManager.cpp

// SPDX-License-Identifier: GPL-2.0-or-later
// Copyright (C) 2026 The MMapper Authors

#include "MusicManager.h"

#include "../configuration/configuration.h"
#include "../global/ConfigConsts-Computed.h"
#include "MediaLibrary.h"

#ifndef MMAPPER_NO_AUDIO
#include <QAudioDevice>
#include <QAudioOutput>
#include <QMediaPlayer>
#include <QUrl>
#endif

#include <memory>

#include <QDir>
#include <QFileInfo>
#include <QTemporaryFile>
#include <QTimer>

MusicManager::MusicManager(MediaLibrary &library, QObject *const parent)
    : QObject(parent)
    , m_library(library)
{
#ifndef MMAPPER_NO_AUDIO
    m_cachedPositions.setMaxCost(10);
    m_wasmFiles.setMaxCost(3);
    for (int i = 0; i < 2; ++i) {
        m_channels[i].player = new QMediaPlayer(this);
        m_channels[i].audioOutput = new QAudioOutput(this);
        m_channels[i].player->setAudioOutput(m_channels[i].audioOutput);
        m_channels[i].player->setLoops(QMediaPlayer::Infinite);

        connect(m_channels[i].player,
                &QMediaPlayer::mediaStatusChanged,
                this,
                [this, i](QMediaPlayer::MediaStatus status) {
                    if (status == QMediaPlayer::LoadedMedia || status == QMediaPlayer::BufferedMedia
                        || status == QMediaPlayer::BufferingMedia) {
                        applyPendingPosition(i);
                    }
                });

        connect(m_channels[i].player, &QMediaPlayer::seekableChanged, this, [this, i](bool seekable) {
            if (seekable) {
                applyPendingPosition(i);
            }
        });
    }

    m_fadeStep = static_cast<float>(FADE_INTERVAL_MS) / CROSSFADE_DURATION_MS;
    m_fadeTimer = new QTimer(this);
    m_fadeTimer->setInterval(FADE_INTERVAL_MS);

    connect(&m_library, &MediaLibrary::sig_mediaChanged, this, &MusicManager::slot_onMediaChanged);

    connect(m_fadeTimer, &QTimer::timeout, this, [this]() {
        bool changed = false;
        for (int i = 0; i < 2; ++i) {
            float target = 0.0f;
            if (!m_fadingToSilence && i == m_activeChannel) {
                target = 1.0f;
            }

            if (m_channels[i].fadeVolume < target) {
                m_channels[i].fadeVolume = std::min(target, m_channels[i].fadeVolume + m_fadeStep);
                changed = true;
            } else if (m_channels[i].fadeVolume > target) {
                m_channels[i].fadeVolume = std::max(target, m_channels[i].fadeVolume - m_fadeStep);
                changed = true;
            }
            updateChannelVolume(i);
        }

        if (!changed) {
            m_fadeTimer->stop();
            int inactive = (m_activeChannel + 1) % 2;
            if (m_channels[inactive].fadeVolume <= 0.0f) {
                if (!m_channels[inactive].file.isEmpty()) {
                    if (m_channels[inactive].player->playbackState() == QMediaPlayer::PlayingState) {
                        m_cachedPositions.insert(m_channels[inactive].file,
                                                 new qint64(
                                                     m_channels[inactive].player->position()));
                    }
                    m_channels[inactive].player->stop();
                    m_channels[inactive].file.clear();
                }
            }
            if (m_fadingToSilence && m_channels[m_activeChannel].fadeVolume <= 0.0f) {
                if (m_channels[m_activeChannel].player->playbackState()
                    == QMediaPlayer::PlayingState) {
                    m_cachedPositions.insert(m_channels[m_activeChannel].file,
                                             new qint64(
                                                 m_channels[m_activeChannel].player->position()));
                }
                m_channels[m_activeChannel].player->stop();
                m_channels[m_activeChannel].file.clear();
            }
        }
    });
#endif
}

MusicManager::~MusicManager()
{
    shutdown();
}

void MusicManager::shutdown()
{
#ifndef MMAPPER_NO_AUDIO
    if (m_fadeTimer) {
        m_fadeTimer->stop();
    }
    for (int i = 0; i < 2; ++i) {
        auto &player = deref(m_channels[i].player);
        player.stop();
        player.setSource(QUrl());
        m_channels[i].file.clear();
    }
#endif
}

void MusicManager::playMusic(MAYBE_UNUSED const QString &musicFile)
{
#ifndef MMAPPER_NO_AUDIO
    if (musicFile.isEmpty() || NO_AUDIO) {
        stopMusic();
        return;
    }

    auto playMusic2 = [this, musicFile](const QUrl &url) {
        const int ch = prepareChannel(musicFile);
        if (ch < 0) {
            return;
        }
        activateChannel(ch, musicFile, url);
    };

    if constexpr (CURRENT_PLATFORM == PlatformEnum::Wasm) {
        if (QTemporaryFile *tempFile = m_wasmFiles.object(musicFile)) {
            playMusic2(QUrl::fromLocalFile(tempFile->fileName()));
            return;
        }
        m_library.fetchAsync(musicFile, [this, musicFile, playMusic2](const QByteArray &data) {
            if (data.isEmpty()) {
                qWarning() << "MusicManager: received empty data for" << musicFile
                           << "- skipping playback";
                return;
            }
            auto tempFile = std::make_unique<QTemporaryFile>(QDir::tempPath() + "/mmapper_XXXXXX."
                                                             + QFileInfo(musicFile).suffix());
            if (!tempFile->open()) {
                qWarning() << "MusicManager: failed to create temp file for" << musicFile;
                return;
            }
            const qint64 bytesWritten = tempFile->write(data);
            if (bytesWritten != static_cast<qint64>(data.size())) {
                qWarning() << "MusicManager: failed to write temp file for" << musicFile
                           << "- expected" << data.size() << "bytes, wrote" << bytesWritten;
                return;
            }
            tempFile->close();
            const QString fileName = tempFile->fileName();
            m_wasmFiles.insert(musicFile, tempFile.release());
            playMusic2(QUrl::fromLocalFile(fileName));
        });
        return;
    }

    playMusic2(musicFile.startsWith(":/") ? QUrl(QStringLiteral("qrc") + musicFile)
                                          : QUrl::fromLocalFile(musicFile));
#endif
}

#ifndef MMAPPER_NO_AUDIO
int MusicManager::prepareChannel(const QString &musicFile)
{
    if (musicFile == m_channels[m_activeChannel].file) {
        if constexpr (CURRENT_PLATFORM == PlatformEnum::Wasm) {
            // Browser does not let music loop on Wasm, so we have to restart it manually with user input
            if (m_channels[m_activeChannel].player->playbackState() != QMediaPlayer::PlayingState) {
                const auto &cfg = getConfig().audio;
                if (cfg.isUnlocked() && cfg.getMusicVolume() > 0) {
                    m_channels[m_activeChannel].player->setPosition(0);
                    m_channels[m_activeChannel].player->play();
                }
                return -1;
            }
        }
        startFade(false);
        return -1;
    }

    const int inactiveChannel = (m_activeChannel + 1) % 2;
    if (musicFile == m_channels[inactiveChannel].file) {
        m_activeChannel = inactiveChannel;
        startFade(false);
        return -1;
    }

    // Save position of the current track before crossfading away from it
    if (!m_channels[m_activeChannel].file.isEmpty()
        && m_channels[m_activeChannel].player->playbackState() == QMediaPlayer::PlayingState) {
        m_cachedPositions.insert(m_channels[m_activeChannel].file,
                                 new qint64(m_channels[m_activeChannel].player->position()));
    }

    return inactiveChannel;
}

void MusicManager::activateChannel(const int channelIndex,
                                   const QString &musicFile,
                                   const QUrl &source)
{
    m_activeChannel = channelIndex;
    auto &ch = m_channels[m_activeChannel];
    ch.file = musicFile;
    ch.fadeVolume = 0.0f;
    if (qint64 *pos = m_cachedPositions.object(musicFile)) {
        ch.pendingPosition = *pos;
    } else {
        ch.pendingPosition = -1;
    }
    ch.player->setSource(source);

    const auto &cfg = getConfig().audio;
    if (cfg.isUnlocked() && cfg.getMusicVolume() > 0) {
        ch.player->play();
        applyPendingPosition(m_activeChannel);
    }

    startFade(false);
}
#endif

void MusicManager::stopMusic()
{
#ifndef MMAPPER_NO_AUDIO
    startFade(true);
#endif
}

void MusicManager::updateVolumes()
{
#ifndef MMAPPER_NO_AUDIO
    for (int i = 0; i < 2; ++i) {
        updateChannelVolume(i);
    }

    auto &cfg = getConfig().audio;
    float masterVol = static_cast<float>(cfg.getMusicVolume()) / 100.0f;
    bool canPlay = cfg.isUnlocked() && masterVol > 0;
    auto &active = m_channels[m_activeChannel];
    if (canPlay && active.player->playbackState() == QMediaPlayer::StoppedState
        && !active.file.isEmpty()) {
        if (qint64 *pos = m_cachedPositions.object(active.file)) {
            active.pendingPosition = *pos;
        }
        active.player->play();
        applyPendingPosition(m_activeChannel);
    } else if (masterVol <= 0 && active.player->playbackState() == QMediaPlayer::PlayingState) {
        if (!active.file.isEmpty()) {
            m_cachedPositions.insert(active.file, new qint64(active.player->position()));
        }
        active.player->stop();
    }
#endif
}

void MusicManager::slot_onMediaChanged()
{
#ifndef MMAPPER_NO_AUDIO
    m_cachedPositions.clear();
    QString currentFile = m_channels[m_activeChannel].file;
    if (!currentFile.isEmpty()) {
        m_channels[m_activeChannel].file.clear();
        playMusic(currentFile);
    }
#endif
}

#ifndef MMAPPER_NO_AUDIO
void MusicManager::updateOutputDevice(const QAudioDevice &device)
{
    for (int i = 0; i < 2; ++i) {
        if (m_channels[i].audioOutput->device() != device) {
            m_channels[i].audioOutput->setDevice(device);
        }
    }
}

void MusicManager::applyPendingPosition(int channelIndex)
{
    auto &ch = m_channels[channelIndex];
    if (ch.pendingPosition != -1 && ch.player->isSeekable()) {
        ch.player->setPosition(ch.pendingPosition);
        ch.pendingPosition = -1;
    }
}

void MusicManager::updateChannelVolume(int channelIndex)
{
    float masterVol = static_cast<float>(getConfig().audio.getMusicVolume()) / 100.0f;
    m_channels[channelIndex].audioOutput->setVolume(masterVol * m_channels[channelIndex].fadeVolume);
}

void MusicManager::startFade(bool toSilence)
{
    m_fadingToSilence = toSilence;
    if (m_fadeTimer && !m_fadeTimer->isActive()) {
        m_fadeTimer->start();
    }
}
#endif