Sound.cpp

浏览该文件的文档.

#include "Sound.h"
#include "Decoder.h"
#include "SoundData.h"
 
#include "common/Exception.h"
#include "common/config.h"
#include "common/Resource.h"
#include "filesystem/FileData.h"
#include "filesystem/Filesystem.h"
 
#include "medialoader/Exception.h"
#include "medialoader/sound/WaveDecoder.h"
#include "medialoader/sound/VorbisDecoder.h"
#include "medialoader/sound/Mpg123Decoder.h"
#include "medialoader/sound/FLACDecoder.h"
#include "medialoader/sound/ModPlugDecoder.h"
 
#include <simplesquirrel/simplesquirrel.hpp>
 
#include <cctype>
#include <cstring>
#include <fstream>
#include <string>
 
#if defined(_WIN32)
#include <stdlib.h>
#else
#include <cstdlib>
#endif
 
namespace eve {
namespace sound {
 
Module_IMPL(Sound, new Sound());
 
namespace {
 
#if defined(EVENGINE_MACOSX) || defined(EVENGINE_LINUX) || defined(EVENGINE_WINDOWS)
 
bool fileExists(const std::string &path) {
    std::ifstream in(path, std::ios::binary);
    return in.good();
}
 
std::string parentPath(std::string path) {
    while (!path.empty() && (path.back() == '/' || path.back() == '\\'))
        path.pop_back();
    auto slash = path.find_last_of("/\\");
    if (slash == std::string::npos)
        return {};
    if (slash == 0)
        return path.substr(0, 1);
    return path.substr(0, slash);
}
 
std::string joinPath(const std::string &a, const std::string &b) {
    if (a.empty())
        return b;
    if (a.back() == '/' || a.back() == '\\')
        return a + b;
    return a + "/" + b;
}
 
// Prefer installed / staged share/eve/timidity next to the executable.
// Does not override an existing MMPAT_PATH_TO_CFG (user trim / custom banks).
void ensureDesktopTimidityShare() {
    if (const char *existing = std::getenv("MMPAT_PATH_TO_CFG")) {
        if (existing[0] != '\0')
            return;
    }
 
    auto *fs = filesystem::Filesystem::create();
    std::string exe = fs->getExecutablePath();
    if (exe.empty())
        return;
 
    std::string dir = parentPath(exe);
    const char *relatives[] = {
        "share/eve/timidity",
        "../share/eve/timidity",
        "../../share/eve/timidity",
        "../../../share/eve/timidity",
    };
 
    std::string found;
    for (const char *rel : relatives) {
        std::string cand = joinPath(dir, rel);
        if (fileExists(joinPath(cand, "timidity.cfg"))) {
            found = cand;
            break;
        }
    }
    if (found.empty())
        return;
 
#if defined(_WIN32)
    _putenv_s("MMPAT_PATH_TO_CFG", found.c_str());
#else
    setenv("MMPAT_PATH_TO_CFG", found.c_str(), 0);
#endif
}
 
#endif  // desktop
 
}  // namespace
 
Sound::Sound() {
#if defined(EVENGINE_MACOSX) || defined(EVENGINE_LINUX) || defined(EVENGINE_WINDOWS)
    ensureDesktopTimidityShare();
#endif
}
 
Sound::~Sound() = default;
 
namespace {
 
std::string lowerExt(std::string ext) {
    for (char &c : ext)
        c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
    return ext;
}
 
template <typename T>
std::unique_ptr<medialoader::Decoder> tryMake(const char *data, size_t size, int bufferSize) {
    try {
        return std::unique_ptr<medialoader::Decoder>(new T(data, size, bufferSize));
    } catch (const medialoader::Exception &) {
        return nullptr;
    } catch (...) {
        return nullptr;
    }
}
 
}  // namespace
 
Decoder *Sound::newDecoder(Data *data, int bufferSize) {
    if (data == nullptr || data->getData() == nullptr || data->getSize() == 0)
        throw eve::Exception("Cannot decode empty sound data");
 
    std::vector<char> owned(static_cast<const char *>(data->getData()),
                            static_cast<const char *>(data->getData()) + data->getSize());
 
    std::string ext;
    if (auto *fd = dynamic_cast<filesystem::FileData *>(data))
        ext = lowerExt(fd->getExtension());
 
    const char *ptr = owned.data();
    size_t size = owned.size();
 
    auto tryByExt = [&](const std::string &e) -> std::unique_ptr<medialoader::Decoder> {
        if (e.empty())
            return nullptr;
        if (medialoader::WaveDecoder::accepts(e))
            return tryMake<medialoader::WaveDecoder>(ptr, size, bufferSize);
        if (medialoader::VorbisDecoder::accepts(e))
            return tryMake<medialoader::VorbisDecoder>(ptr, size, bufferSize);
        if (medialoader::Mpg123Decoder::accepts(e))
            return tryMake<medialoader::Mpg123Decoder>(ptr, size, bufferSize);
        if (medialoader::FLACDecoder::accepts(e))
            return tryMake<medialoader::FLACDecoder>(ptr, size, bufferSize);
        if (medialoader::ModPlugDecoder::accepts(e))
            return tryMake<medialoader::ModPlugDecoder>(ptr, size, bufferSize);
        return nullptr;
    };
 
    auto impl = tryByExt(ext);
    if (!impl) {
        if (!impl) impl = tryMake<medialoader::WaveDecoder>(ptr, size, bufferSize);
        if (!impl) impl = tryMake<medialoader::VorbisDecoder>(ptr, size, bufferSize);
        if (!impl) impl = tryMake<medialoader::Mpg123Decoder>(ptr, size, bufferSize);
        if (!impl) impl = tryMake<medialoader::FLACDecoder>(ptr, size, bufferSize);
        if (!impl) impl = tryMake<medialoader::ModPlugDecoder>(ptr, size, bufferSize);
    }
 
    if (!impl)
        throw eve::Exception("Could not decode sound data: unsupported format");
 
    return new Decoder(std::move(impl), std::move(owned));
}
 
SoundData *Sound::newSoundDataFromDecoder(Decoder *decoder) {
    if (decoder == nullptr)
        throw eve::Exception("Decoder is null");
 
    std::vector<uint8_t> pcm;
    while (!decoder->isFinished()) {
        int n = decoder->decode();
        if (n <= 0)
            break;
        auto *buf = static_cast<const uint8_t *>(decoder->getBuffer());
        pcm.insert(pcm.end(), buf, buf + n);
    }
 
    return new SoundData(std::move(pcm), decoder->getSampleRate(), decoder->getBitDepth(),
                         decoder->getChannelCount());
}
 
SoundData *Sound::newSoundData(Data *data) {
    Decoder *dec = newDecoder(data);
    try {
        SoundData *sd = newSoundDataFromDecoder(dec);
        delete dec;
        return sd;
    } catch (...) {
        delete dec;
        throw;
    }
}
 
SoundData *Sound::newSoundDataFromFile(std::string path) {
    if (path.empty())
        throw eve::Exception("Sound::newSoundDataFromFile: empty path");
 
    eve::Resource *resource = eve::ResourceManager::getInstance().get(path);
    if (!resource)
        throw eve::Exception("Could not load sound file: %s", path.c_str());
    return static_cast<SoundData *>(resource);
}
 
SoundData *Sound::newSoundDataEmpty(int samples, int rate, int bitDepth, int channels) {
    if (samples < 0)
        throw eve::Exception("Invalid sample count");
    size_t bytes = static_cast<size_t>(samples) * static_cast<size_t>(bitDepth / 8) * static_cast<size_t>(channels);
    std::vector<uint8_t> pcm(bytes, 0);
    return new SoundData(std::move(pcm), rate, bitDepth, channels);
}
 
void Sound::expose(ssq::Table& table) {
    auto cls = table.addClass(name, Sound::create, false);
    expose(cls);
 
    auto dec = table.addClass<Decoder>(
        "Decoder", std::function<Decoder *()>([]() -> Decoder * { return nullptr; }), true);
    dec.addFunc("decode", &Decoder::decode);
    dec.addFunc("getSize", &Decoder::getSize);
    dec.addFunc("seek", &Decoder::seek);
    dec.addFunc("rewind", &Decoder::rewind);
    dec.addFunc("isSeekable", &Decoder::isSeekable);
    dec.addFunc("isFinished", &Decoder::isFinished);
    dec.addFunc("getChannelCount", &Decoder::getChannelCount);
    dec.addFunc("getBitDepth", &Decoder::getBitDepth);
    dec.addFunc("getSampleRate", &Decoder::getSampleRate);
    dec.addFunc("getDuration", &Decoder::getDuration);
 
    auto sd = table.addClass<SoundData>(
        "SoundData", std::function<SoundData *()>([]() -> SoundData * { return nullptr; }), true);
    sd.addFunc("getSampleCount", &SoundData::getSampleCount);
    sd.addFunc("getSampleRate", &SoundData::getSampleRate);
    sd.addFunc("getBitDepth", &SoundData::getBitDepth);
    sd.addFunc("getChannelCount", &SoundData::getChannelCount);
    sd.addFunc("getDuration", &SoundData::getDuration);
    sd.addFunc("getSize", &SoundData::getSize);
}
 
void Sound::expose(ssq::Class& cls) {
    cls.addFunc("getName", &Sound::getName);
    cls.addFunc("newDecoder", &Sound::newDecoder);
    cls.addFunc("newSoundData", &Sound::newSoundData);
    cls.addFunc("newSoundDataFromDecoder", &Sound::newSoundDataFromDecoder);
    cls.addFunc("newSoundDataFromFile", &Sound::newSoundDataFromFile);
    cls.addFunc("newSoundDataEmpty", &Sound::newSoundDataEmpty);
}
 
}  // namespace sound
}  // namespace eve