383 lines
10 KiB
C++
383 lines
10 KiB
C++
// Copyright (C) 2017 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - Audio module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/Audio/Formats/sndfileLoader.hpp>
|
|
#include <Nazara/Audio/Algorithm.hpp>
|
|
#include <Nazara/Audio/Audio.hpp>
|
|
#include <Nazara/Audio/Config.hpp>
|
|
#include <Nazara/Audio/Music.hpp>
|
|
#include <Nazara/Audio/SoundBuffer.hpp>
|
|
#include <Nazara/Audio/SoundStream.hpp>
|
|
#include <Nazara/Core/CallOnExit.hpp>
|
|
#include <Nazara/Core/Endianness.hpp>
|
|
#include <Nazara/Core/Error.hpp>
|
|
#include <Nazara/Core/File.hpp>
|
|
#include <Nazara/Core/MemoryView.hpp>
|
|
#include <Nazara/Core/Mutex.hpp>
|
|
#include <Nazara/Core/Stream.hpp>
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <vector>
|
|
#include <sndfile/sndfile.h>
|
|
#include <Nazara/Audio/Debug.hpp>
|
|
|
|
namespace Nz
|
|
{
|
|
namespace Detail
|
|
{
|
|
sf_count_t GetSize(void* user_data)
|
|
{
|
|
Stream* stream = static_cast<Stream*>(user_data);
|
|
return stream->GetSize();
|
|
}
|
|
|
|
sf_count_t Read(void* ptr, sf_count_t count, void* user_data)
|
|
{
|
|
Stream* stream = static_cast<Stream*>(user_data);
|
|
return static_cast<sf_count_t>(stream->Read(ptr, static_cast<std::size_t>(count)));
|
|
}
|
|
|
|
sf_count_t Seek(sf_count_t offset, int whence, void* user_data)
|
|
{
|
|
Stream* stream = static_cast<Stream*>(user_data);
|
|
switch (whence)
|
|
{
|
|
case SEEK_CUR:
|
|
stream->Read(nullptr, static_cast<std::size_t>(offset));
|
|
break;
|
|
|
|
case SEEK_END:
|
|
stream->SetCursorPos(stream->GetSize() + offset); // L'offset est négatif ici
|
|
break;
|
|
|
|
case SEEK_SET:
|
|
stream->SetCursorPos(offset);
|
|
break;
|
|
|
|
default:
|
|
NazaraInternalError("Seek mode not handled");
|
|
}
|
|
|
|
return stream->GetCursorPos();
|
|
}
|
|
|
|
sf_count_t Tell(void* user_data)
|
|
{
|
|
Stream* stream = static_cast<Stream*>(user_data);
|
|
return stream->GetCursorPos();
|
|
}
|
|
|
|
static SF_VIRTUAL_IO callbacks = {GetSize, Seek, Read, nullptr, Tell};
|
|
|
|
class sndfileStream : public SoundStream
|
|
{
|
|
public:
|
|
sndfileStream() :
|
|
m_handle(nullptr)
|
|
{
|
|
}
|
|
|
|
~sndfileStream()
|
|
{
|
|
if (m_handle)
|
|
sf_close(m_handle);
|
|
}
|
|
|
|
UInt32 GetDuration() const override
|
|
{
|
|
return m_duration;
|
|
}
|
|
|
|
AudioFormat GetFormat() const override
|
|
{
|
|
// Nous avons besoin du nombre de canaux d'origine pour convertir en mono, nous trichons donc un peu...
|
|
if (m_mixToMono)
|
|
return AudioFormat_Mono;
|
|
else
|
|
return m_format;
|
|
}
|
|
|
|
Mutex& GetMutex() override
|
|
{
|
|
return m_mutex;
|
|
}
|
|
|
|
UInt64 GetSampleCount() const override
|
|
{
|
|
return m_sampleCount;
|
|
}
|
|
|
|
UInt32 GetSampleRate() const override
|
|
{
|
|
return m_sampleRate;
|
|
}
|
|
|
|
bool Open(const String& filePath, bool forceMono)
|
|
{
|
|
// Nous devons gérer nous-même le flux car il doit rester ouvert après le passage du loader
|
|
// (les flux automatiquement ouverts par le ResourceLoader étant fermés après celui-ci)
|
|
std::unique_ptr<File> file(new File);
|
|
if (!file->Open(filePath, OpenMode_ReadOnly))
|
|
{
|
|
NazaraError("Failed to open stream from file: " + Error::GetLastError());
|
|
return false;
|
|
}
|
|
|
|
m_ownedStream = std::move(file);
|
|
return Open(*m_ownedStream, forceMono);
|
|
}
|
|
|
|
bool Open(const void* data, std::size_t size, bool forceMono)
|
|
{
|
|
m_ownedStream = std::make_unique<MemoryView>(data, size);
|
|
return Open(*m_ownedStream, forceMono);
|
|
}
|
|
|
|
bool Open(Stream& stream, bool forceMono)
|
|
{
|
|
SF_INFO infos;
|
|
infos.format = 0; // Unknown format
|
|
|
|
m_handle = sf_open_virtual(&callbacks, SFM_READ, &infos, &stream);
|
|
if (!m_handle)
|
|
{
|
|
NazaraError("Failed to open sound: " + String(sf_strerror(m_handle)));
|
|
return false;
|
|
}
|
|
|
|
// Un peu de RRID
|
|
CallOnExit onExit([this]
|
|
{
|
|
sf_close(m_handle);
|
|
m_handle = nullptr;
|
|
});
|
|
|
|
m_format = Audio::GetAudioFormat(infos.channels);
|
|
if (m_format == AudioFormat_Unknown)
|
|
{
|
|
NazaraError("Channel count not handled");
|
|
return false;
|
|
}
|
|
|
|
m_sampleCount = infos.channels*infos.frames;
|
|
m_sampleRate = infos.samplerate;
|
|
|
|
// Durée de la musique (s) = samples / channels*rate
|
|
m_duration = static_cast<UInt32>(1000ULL*m_sampleCount / (m_format*m_sampleRate));
|
|
|
|
// https://github.com/LaurentGomila/SFML/issues/271
|
|
// http://www.mega-nerd.com/libsndfile/command.html#SFC_SET_SCALE_FLOAT_INT_READ
|
|
///FIXME: Seulement le Vorbis ?
|
|
if (infos.format & SF_FORMAT_VORBIS)
|
|
sf_command(m_handle, SFC_SET_SCALE_FLOAT_INT_READ, nullptr, SF_TRUE);
|
|
|
|
// On mixera en mono lors de la lecture
|
|
if (forceMono && m_format != AudioFormat_Mono)
|
|
{
|
|
m_mixToMono = true;
|
|
m_sampleCount = static_cast<UInt32>(infos.frames);
|
|
}
|
|
else
|
|
m_mixToMono = false;
|
|
|
|
onExit.Reset();
|
|
|
|
return true;
|
|
}
|
|
|
|
UInt64 Read(void* buffer, UInt64 sampleCount) override
|
|
{
|
|
// Si la musique a été demandée en mono, nous devons la convertir à la volée lors de la lecture
|
|
if (m_mixToMono)
|
|
{
|
|
// On garde un buffer sur le côté pour éviter la réallocation
|
|
m_mixBuffer.resize(m_format * sampleCount);
|
|
sf_count_t readSampleCount = sf_read_short(m_handle, m_mixBuffer.data(), m_format * sampleCount);
|
|
MixToMono(m_mixBuffer.data(), static_cast<Int16*>(buffer), m_format, sampleCount);
|
|
|
|
return readSampleCount / m_format;
|
|
}
|
|
else
|
|
return sf_read_short(m_handle, static_cast<Int16*>(buffer), sampleCount);
|
|
}
|
|
|
|
void Seek(UInt64 offset) override
|
|
{
|
|
sf_seek(m_handle, offset*m_sampleRate / 1000, SEEK_SET);
|
|
}
|
|
|
|
UInt64 Tell() override
|
|
{
|
|
return sf_seek(m_handle, 0, SEEK_CUR) * 1000 / m_sampleRate;
|
|
}
|
|
|
|
private:
|
|
std::vector<Int16> m_mixBuffer;
|
|
std::unique_ptr<Stream> m_ownedStream;
|
|
AudioFormat m_format;
|
|
SNDFILE* m_handle;
|
|
bool m_mixToMono;
|
|
Mutex m_mutex;
|
|
UInt32 m_duration;
|
|
UInt32 m_sampleRate;
|
|
UInt64 m_sampleCount;
|
|
};
|
|
|
|
bool IsSupported(const String& extension)
|
|
{
|
|
static std::set<String> supportedExtensions = {
|
|
"aiff", "au", "avr", "caf", "flac", "htk", "ircam", "mat4", "mat5", "mpc2k",
|
|
"nist","ogg", "pvf", "raw", "rf64", "sd2", "sds", "svx", "voc", "w64", "wav", "wve"
|
|
};
|
|
|
|
return supportedExtensions.find(extension) != supportedExtensions.end();
|
|
}
|
|
|
|
Ternary CheckSoundStream(Stream& stream, const SoundStreamParams& parameters)
|
|
{
|
|
NazaraUnused(parameters);
|
|
|
|
SF_INFO info;
|
|
info.format = 0; // Format inconnu
|
|
|
|
// Si on peut ouvrir le flux, c'est qu'il est dans un format compatible
|
|
SNDFILE* file = sf_open_virtual(&callbacks, SFM_READ, &info, &stream);
|
|
if (file)
|
|
{
|
|
sf_close(file);
|
|
return Ternary_True;
|
|
}
|
|
else
|
|
return Ternary_False;
|
|
}
|
|
|
|
SoundStreamRef LoadSoundStreamFile(const String& filePath, const SoundStreamParams& parameters)
|
|
{
|
|
std::unique_ptr<sndfileStream> soundStream(new sndfileStream);
|
|
if (!soundStream->Open(filePath, parameters.forceMono))
|
|
{
|
|
NazaraError("Failed to open sound stream");
|
|
return nullptr;
|
|
}
|
|
|
|
soundStream->SetPersistent(false);
|
|
return soundStream.release();
|
|
}
|
|
|
|
SoundStreamRef LoadSoundStreamMemory(const void* data, std::size_t size, const SoundStreamParams& parameters)
|
|
{
|
|
std::unique_ptr<sndfileStream> soundStream(new sndfileStream);
|
|
if (!soundStream->Open(data, size, parameters.forceMono))
|
|
{
|
|
NazaraError("Failed to open music stream");
|
|
return nullptr;
|
|
}
|
|
|
|
soundStream->SetPersistent(false);
|
|
return soundStream.release();
|
|
}
|
|
|
|
SoundStreamRef LoadSoundStreamStream(Stream& stream, const SoundStreamParams& parameters)
|
|
{
|
|
std::unique_ptr<sndfileStream> soundStream(new sndfileStream);
|
|
if (!soundStream->Open(stream, parameters.forceMono))
|
|
{
|
|
NazaraError("Failed to open music stream");
|
|
return nullptr;
|
|
}
|
|
|
|
soundStream->SetPersistent(false);
|
|
return soundStream.release();
|
|
}
|
|
|
|
Ternary CheckSoundBuffer(Stream& stream, const SoundBufferParams& parameters)
|
|
{
|
|
NazaraUnused(parameters);
|
|
|
|
SF_INFO info;
|
|
info.format = 0;
|
|
|
|
SNDFILE* file = sf_open_virtual(&callbacks, SFM_READ, &info, &stream);
|
|
if (file)
|
|
{
|
|
sf_close(file);
|
|
return Ternary_True;
|
|
}
|
|
else
|
|
return Ternary_False;
|
|
}
|
|
|
|
SoundBufferRef LoadSoundBuffer(Stream& stream, const SoundBufferParams& parameters)
|
|
{
|
|
SF_INFO info;
|
|
info.format = 0;
|
|
|
|
SNDFILE* file = sf_open_virtual(&callbacks, SFM_READ, &info, &stream);
|
|
if (!file)
|
|
{
|
|
NazaraError("Failed to load sound file: " + String(sf_strerror(file)));
|
|
return nullptr;
|
|
}
|
|
|
|
// Lynix utilise RAII...
|
|
// C'est très efficace !
|
|
// MemoryLeak est confus...
|
|
CallOnExit onExit([file]
|
|
{
|
|
sf_close(file);
|
|
});
|
|
|
|
AudioFormat format = Audio::GetAudioFormat(info.channels);
|
|
if (format == AudioFormat_Unknown)
|
|
{
|
|
NazaraError("Channel count not handled");
|
|
return nullptr;
|
|
}
|
|
|
|
// https://github.com/LaurentGomila/SFML/issues/271
|
|
// http://www.mega-nerd.com/libsndfile/command.html#SFC_SET_SCALE_FLOAT_INT_READ
|
|
///FIXME: Seulement le Vorbis ?
|
|
if (info.format & SF_FORMAT_VORBIS)
|
|
sf_command(file, SFC_SET_SCALE_FLOAT_INT_READ, nullptr, SF_TRUE);
|
|
|
|
unsigned int sampleCount = static_cast<unsigned int>(info.frames * info.channels);
|
|
std::unique_ptr<Int16[]> samples(new Int16[sampleCount]);
|
|
|
|
if (sf_read_short(file, samples.get(), sampleCount) != sampleCount)
|
|
{
|
|
NazaraError("Failed to read samples");
|
|
return nullptr;
|
|
}
|
|
|
|
// Une conversion en mono est-elle nécessaire ?
|
|
if (parameters.forceMono && format != AudioFormat_Mono)
|
|
{
|
|
// Nous effectuons la conversion en mono dans le même buffer (il va de toute façon être copié)
|
|
MixToMono(samples.get(), samples.get(), static_cast<unsigned int>(info.channels), static_cast<unsigned int>(info.frames));
|
|
|
|
format = AudioFormat_Mono;
|
|
sampleCount = static_cast<unsigned int>(info.frames);
|
|
}
|
|
|
|
return SoundBuffer::New(format, sampleCount, info.samplerate, samples.get());
|
|
}
|
|
}
|
|
|
|
namespace Loaders
|
|
{
|
|
void Register_sndfile()
|
|
{
|
|
SoundBufferLoader::RegisterLoader(Detail::IsSupported, Detail::CheckSoundBuffer, Detail::LoadSoundBuffer);
|
|
SoundStreamLoader::RegisterLoader(Detail::IsSupported, Detail::CheckSoundStream, Detail::LoadSoundStreamStream, Detail::LoadSoundStreamFile, Detail::LoadSoundStreamMemory);
|
|
}
|
|
|
|
void Unregister_sndfile()
|
|
{
|
|
SoundBufferLoader::UnregisterLoader(Detail::IsSupported, Detail::CheckSoundBuffer, Detail::LoadSoundBuffer);
|
|
SoundStreamLoader::UnregisterLoader(Detail::IsSupported, Detail::CheckSoundStream, Detail::LoadSoundStreamStream, Detail::LoadSoundStreamFile, Detail::LoadSoundStreamMemory);
|
|
}
|
|
}
|
|
}
|