bool SoundFile::openRead(const void* data, std::size_t sizeInBytes)
{
// If the file is already opened, first close it
if (m_file)
sf_close(m_file);
// Prepare the memory I/O structure
SF_VIRTUAL_IO io;
io.get_filelen = &Memory::getLength;
io.read = &Memory::read;
io.seek = &Memory::seek;
io.tell = &Memory::tell;
// Initialize the memory data
m_memory.begin = static_cast<const char*>(data);
m_memory.current = m_memory.begin;
m_memory.size = sizeInBytes;
// Open the sound file
SF_INFO fileInfo;
fileInfo.format = 0;
m_file = sf_open_virtual(&io, SFM_READ, &fileInfo, &m_memory);
if (!m_file)
{
err() << "Failed to open sound file from memory (" << sf_strerror(m_file) << ")" << std::endl;
return false;
}
// Initialize the internal state from the loaded information
initialize(fileInfo);
return true;
}
////////////////////////////////////////////////////////////
/// /see sf::SoundFile::OpenRead
////////////////////////////////////////////////////////////
bool SoundFileDefault::OpenRead(const char* Data, std::size_t SizeInBytes, std::size_t& NbSamples, unsigned int& ChannelsCount, unsigned int& SampleRate)
{
// If the file is already opened, first close it
if (myFile)
sf_close(myFile);
// Define the I/O custom functions for reading from memory
SF_VIRTUAL_IO VirtualIO;
VirtualIO.get_filelen = &SoundFileDefault::MemoryGetLength;
VirtualIO.read = &SoundFileDefault::MemoryRead;
VirtualIO.seek = &SoundFileDefault::MemorySeek;
VirtualIO.tell = &SoundFileDefault::MemoryTell;
VirtualIO.write = &SoundFileDefault::MemoryWrite;
// Initialize the memory data
myMemory.DataStart = Data;
myMemory.DataPtr = Data;
myMemory.TotalSize = SizeInBytes;
// Open the sound file
SF_INFO FileInfos;
myFile = sf_open_virtual(&VirtualIO, SFM_READ, &FileInfos, &myMemory);
if (!myFile)
{
std::cerr << "Failed to read sound file from memory" << std::endl;
return false;
}
// Set the sound parameters
ChannelsCount = FileInfos.channels;
SampleRate = FileInfos.samplerate;
NbSamples = static_cast<std::size_t>(FileInfos.frames) * ChannelsCount;
return true;
}
bool SoundFile::openRead(InputStream& stream)
{
// If the file is already opened, first close it
if (m_file)
sf_close(m_file);
// Prepare the memory I/O structure
SF_VIRTUAL_IO io;
io.get_filelen = &Stream::getLength;
io.read = &Stream::read;
io.seek = &Stream::seek;
io.tell = &Stream::tell;
// Initialize the stream data
m_stream.source = &stream;
m_stream.size = stream.getSize();
// Make sure that the stream's reading position is at the beginning
stream.seek(0);
// Open the sound file
SF_INFO fileInfo;
fileInfo.format = 0;
m_file = sf_open_virtual(&io, SFM_READ, &fileInfo, &m_stream);
if (!m_file)
{
err() << "Failed to open sound file from stream (" << sf_strerror(m_file) << ")" << std::endl;
return false;
}
// Initialize the internal state from the loaded information
initialize(fileInfo);
return true;
}
bool SoundFile::openRead(const void* data, std::size_t sizeInBytes)
{
// If the file is already opened, first close it
if (m_file)
sf_close(m_file);
// Prepare the memory I/O structure
SF_VIRTUAL_IO io;
io.get_filelen = &Memory::getLength;
io.read = &Memory::read;
io.seek = &Memory::seek;
io.tell = &Memory::tell;
// Initialize the memory data
m_memory.DataStart = static_cast<const char*>(data);
m_memory.DataPtr = m_memory.DataStart;
m_memory.TotalSize = sizeInBytes;
// Open the sound file
SF_INFO fileInfos;
m_file = sf_open_virtual(&io, SFM_READ, &fileInfos, &m_memory);
if (!m_file)
{
err() << "Failed to open sound file from memory (" << sf_strerror(m_file) << ")" << std::endl;
return false;
}
// Set the sound parameters
m_channelCount = fileInfos.channels;
m_sampleRate = fileInfos.samplerate;
m_sampleCount = static_cast<std::size_t>(fileInfos.frames) * m_channelCount;
return true;
}
int EncoderWave::initEncoder(int samplerate, QString errorMessage) {
// set sfInfo.
// m_sfInfo.format is setup on setEncoderSettings previous to calling initEncoder.
m_sfInfo.samplerate = samplerate;
m_sfInfo.channels = 2;
m_sfInfo.frames = 0;
m_sfInfo.sections = 0;
m_sfInfo.seekable = 0;
// Opens a soundfile from a virtual file I/O context which is provided by the caller.
// This is usually used to interface libsndfile to a stream or buffer based system.
// Apart from the sfvirtual and the user_data parameters this function behaves like sf_open.
m_pSndfile = sf_open_virtual (&m_virtualIo, SFM_WRITE, &m_sfInfo, m_pCallback) ;
int ret=0;
if (m_pSndfile == nullptr) {
errorMessage = QString("Error initializing Wave recording. sf_open_virtual returned: ")
+ sf_strerror(nullptr);
qDebug() << errorMessage;
ret = -1;
} else {
initStream();
};
return ret;
}
static void
sndfile_stream_decode(struct decoder *decoder, struct input_stream *is)
{
GError *error = NULL;
SNDFILE *sf;
SF_INFO info;
struct audio_format audio_format;
size_t frame_size;
sf_count_t read_frames, num_frames;
int buffer[4096];
enum decoder_command cmd;
info.format = 0;
sf = sf_open_virtual(&vio, SFM_READ, &info, is);
if (sf == NULL) {
g_warning("sf_open_virtual() failed");
return;
}
/* for now, always read 32 bit samples. Later, we could lower
MPD's CPU usage by reading 16 bit samples with
sf_readf_short() on low-quality source files. */
if (!audio_format_init_checked(&audio_format, info.samplerate,
SAMPLE_FORMAT_S32,
info.channels, &error)) {
g_warning("%s", error->message);
g_error_free(error);
return;
}
decoder_initialized(decoder, &audio_format, info.seekable,
frame_to_time(info.frames, &audio_format));
frame_size = audio_format_frame_size(&audio_format);
read_frames = sizeof(buffer) / frame_size;
do {
num_frames = sf_readf_int(sf, buffer, read_frames);
if (num_frames <= 0)
break;
cmd = decoder_data(decoder, is,
buffer, num_frames * frame_size,
0);
if (cmd == DECODE_COMMAND_SEEK) {
sf_count_t c =
time_to_frame(decoder_seek_where(decoder),
&audio_format);
c = sf_seek(sf, c, SEEK_SET);
if (c < 0)
decoder_seek_error(decoder);
else
decoder_command_finished(decoder);
cmd = DECODE_COMMAND_NONE;
}
} while (cmd == DECODE_COMMAND_NONE);
sf_close(sf);
}
bool SoundFile::openRead(InputStream& stream)
{
// If the file is already opened, first close it
if (m_file)
sf_close(m_file);
// Prepare the memory I/O structure
SF_VIRTUAL_IO io;
io.get_filelen = &Stream::getLength;
io.read = &Stream::read;
io.seek = &Stream::seek;
io.tell = &Stream::tell;
// Open the sound file
SF_INFO fileInfos;
m_file = sf_open_virtual(&io, SFM_READ, &fileInfos, &stream);
if (!m_file)
{
err() << "Failed to open sound file from stream (" << sf_strerror(m_file) << ")" << std::endl;
return false;
}
// Set the sound parameters
m_channelCount = fileInfos.channels;
m_sampleRate = fileInfos.samplerate;
m_sampleCount = static_cast<std::size_t>(fileInfos.frames) * m_channelCount;
return true;
}
////////////////////////////////////////////////////////////
/// Check if a given file in memory is supported by this loader
////////////////////////////////////////////////////////////
bool SoundFileDefault::IsFileSupported(const char* Data, std::size_t SizeInBytes)
{
// Define the I/O custom functions for reading from memory
SF_VIRTUAL_IO VirtualIO;
VirtualIO.get_filelen = &SoundFileDefault::MemoryGetLength;
VirtualIO.read = &SoundFileDefault::MemoryRead;
VirtualIO.seek = &SoundFileDefault::MemorySeek;
VirtualIO.tell = &SoundFileDefault::MemoryTell;
VirtualIO.write = &SoundFileDefault::MemoryWrite;
// Initialize the memory data
MemoryInfos Memory;
Memory.DataStart = Data;
Memory.DataPtr = Data;
Memory.TotalSize = SizeInBytes;
// Open the sound file
SF_INFO FileInfos;
SNDFILE* File = sf_open_virtual(&VirtualIO, SFM_READ, &FileInfos, &Memory);
if (File)
{
sf_close(File);
return true;
}
else
{
return false;
}
}
bool LibsndfileDecoder::Open(FILE* file) {
file_=file;
soundfile=sf_open_virtual(&vio,SFM_READ,&soundinfo,file);
sf_command(soundfile, SFC_SET_SCALE_FLOAT_INT_READ, NULL, SF_TRUE);
output_format=Format::F32;
finished=false;
return soundfile!=0;
}
SFReader::SFReader(IO &fp)
{
fp.seekS(0);
memset(&sfinfo, 0, sizeof(sfinfo));
if(!(sf = sf_open_virtual(&IOAPI::sndfile, SFM_READ, &sfinfo, &fp)))
throw(0);
}
bool CSndFile::open(QIODevice *io, int mode)
{
if (io)
{
m_snd = sf_open_virtual(&m_vioPtr, mode, &m_info, io);
return (m_snd != 0);
}
return false;
}
bool CSndFile::open(int mode)
{
if (m_io)
{
m_snd = sf_open_virtual(&m_vioPtr, mode, &m_info, m_io);
return (m_snd != 0);
}
return false;
}
SndFile(Reader reader)
: file(NULL), reader(buffer.frontReader())
{
info.format = 0;
buffer.resize(reader.resource().size() - reader.position());
reader.read(buffer.data(), buffer.size());
file = sf_open_virtual(ioInterface(), SFM_READ, &info, this);
if (!file)
throw std::runtime_error(std::string(sf_strerror(NULL)));
}
bool M_loadSound(const char * filename, void * data)
{
SF_VIRTUAL_IO io;
io.get_filelen = &M_SFGetFileLen;
io.seek = &M_SFSeek;
io.read = &M_SFRead;
io.write = &M_SFWrite;
io.tell = &M_SFTell;
// open file
SF_INFO infos;
MFile* File = M_fopen(filename, "rb");
SNDFILE * file = sf_open_virtual(&io, SFM_READ, &infos, File);
if(! file){
M_fclose(File);
printf("ERROR Load Sound : unable to read %s file\n", filename);
return false;
}
int nbSamples = infos.channels * (int)infos.frames;
int sampleRate = infos.samplerate;
M_SOUND_FORMAT format;
switch(infos.channels)
{
case 1 :
format = M_SOUND_FORMAT_MONO16;
break;
case 2 :
format = M_SOUND_FORMAT_STEREO16;
break;
default :
printf("ERROR Load Sound : non supported format\n");
M_fclose(File);
return false;
}
MSound * sound = (MSound *)data;
unsigned int size = nbSamples*2;
sound->create(format, size, (unsigned int)sampleRate);
// 16 bits file reading
if(sf_read_short(file, (short*)sound->getData(), nbSamples) < nbSamples)
{
printf("ERROR Load Sound : unable to read samples\n");
M_fclose(File);
return false;
}
sf_close(file);
M_fclose(File);
return true;
}
yz::AlBuffer::AlBuffer(yz::physfs* file, const int number) {
LOG_FUNCTION
this->number = number;
SF_INFO fileInfo;
SF_VIRTUAL_IO io;
io.get_filelen = &yz::AlBuffer::Stream::getLength;
io.read = &yz::AlBuffer::Stream::read;
io.seek = &yz::AlBuffer::Stream::seek;
io.tell = &yz::AlBuffer::Stream::tell;
this->soundFile = sf_open_virtual(&io, SFM_READ, &fileInfo, file);
this->init(fileInfo);
}
SndFile(const std::wstring& filename)
: file(NULL), reader(buffer.frontReader())
{
info.format = 0;
#ifdef GOSU_IS_WIN
loadFile(buffer, filename);
file = sf_open_virtual(ioInterface(), SFM_READ, &info, this);
#else
file = sf_open(wstringToUTF8(filename).c_str(), SFM_READ, &info);
#endif
if (!file)
throw std::runtime_error(std::string(sf_strerror(NULL)));
}
bool SndfileDecoder::Open(FileSpecifier& File)
{
Close();
sfinfo.format = 0;
OpenedFile openedFile;
if (File.Open(openedFile)) {
rwops = openedFile.TakeRWops();
sndfile = sf_open_virtual(&sf_virtual, SFM_READ, &sfinfo, rwops);
}
return sndfile;
}
sndStream(std::istream *_fstream)
: alureStream(_fstream), sndFile(NULL), format(AL_NONE)
{
memset(&sndInfo, 0, sizeof(sndInfo));
if(!sndfile_handle) return;
static SF_VIRTUAL_IO streamIO = {
get_filelen, seek,
read, write, tell
};
sndFile = sf_open_virtual(&streamIO, SFM_READ, &sndInfo, this);
}
static const char *GuessSndFile (char *buf, int len)
{
SF_VIRTUAL_IO io;
io.get_filelen = dummy_vio_get_filelen;
io.seek = dummy_vio_seek;
io.read = dummy_vio_read;
io.write = dummy_vio_write;
io.tell = dummy_vio_tell;
struct dummy_file file;
file.buffer = buf;
file.length = len;
file.curpos = 0;
SF_INFO info;
memset(&info, 0, sizeof(SF_INFO));
SNDFILE* sndfile = sf_open_virtual (&io, SFM_READ, &info, &file);
if( sndfile == NULL )
{
int err = sf_error(NULL);
fprintf(stderr, "Error occurred: %s\n", sf_error_number(err));
switch(err)
{
case SF_ERR_UNRECOGNISED_FORMAT:
case SF_ERR_UNSUPPORTED_ENCODING:
sf_close(sndfile);
return NULL;
case SF_ERR_SYSTEM:
case SF_ERR_MALFORMED_FILE:
default:
sf_close(sndfile);
return QUE_STRING;
break;
}
}
else
{
sf_close(sndfile);
SF_FORMAT_INFO format_info;
format_info.format = info.format;
int ret = sf_command (NULL /* sndfile */, SFC_GET_FORMAT_INFO, &format_info, sizeof(SF_FORMAT_INFO)) ;
/* fprintf(stderr, "%s [%s]\n", format_info.name, format_info.extension); */
return format_info.name;
}
return NULL;
}
static PyObject*
_rpitx_broadcast_fm(PyObject* self, PyObject* args) {
float frequency;
assert(sizeof(sampleBase) == sizeof(unsigned long));
if (!PyArg_ParseTuple(args, "Lif", &sampleBase, &sampleLength, &frequency)) {
struct module_state *st = GETSTATE(self);
PyErr_SetString(st->error, "Invalid arguments");
return NULL;
}
sampleOffset = 0;
SF_VIRTUAL_IO virtualIo = {
.get_filelen = virtualSndfileGetLength,
.seek = virtualSndfileSeek,
.read = virtualSndfileRead,
.write = NULL,
.tell = virtualSndfileTell
};
SF_INFO sfInfo;
sndFile = sf_open_virtual(&virtualIo, SFM_READ, &sfInfo, sampleBase);
if (sf_error(sndFile) != SF_ERR_NO_ERROR) {
char message[100];
snprintf(
message,
COUNT_OF(message),
"Unable to open sound file: %s",
sf_strerror(sndFile));
message[COUNT_OF(message) - 1] = '\0';
struct module_state *st = GETSTATE(self);
PyErr_SetString(st->error, message);
return NULL;
}
bitRate = sfInfo.samplerate;
int skipSignals[] = {
SIGALRM,
SIGVTALRM,
SIGCHLD, // We fork whenever calling broadcast_fm
SIGWINCH, // Window resized
0
};
pitx_run(MODE_RF, bitRate, frequency * 1000.0, 0.0, 0, formatRfWrapper, reset, skipSignals);
sf_close(sndFile);
Py_RETURN_NONE;
}
Sample* ZInstrument::readSample(const QString& s, QZipReader* uz)
{
if (uz) {
QList<QZipReader::FileInfo> fi = uz->fileInfoList();
buf = uz->fileData(s);
if (buf.isEmpty()) {
printf("Sample::read: cannot read sample data <%s>\n", qPrintable(s));
return 0;
}
}
else {
QFile f(s);
if (!f.open(QIODevice::ReadOnly)) {
printf("Sample::read: open <%s> failed\n", qPrintable(s));
return 0;
}
buf = f.readAll();
}
SF_INFO info;
memset(&info, 0, sizeof(info));
idx = 0;
SNDFILE* sf = sf_open_virtual(&sfio, SFM_READ, &info, this);
if (sf == 0) {
printf("open <%s> failed: %s\n", qPrintable(s), sf_strerror(0));
return 0;
}
short* data = new short[(info.frames + 3) * info.channels];
int channel = info.channels;
int frames = info.frames;
int sr = info.samplerate;
Sample* sa = new Sample(channel, data, frames, sr);
if (info.frames != sf_readf_short(sf, data + channel, frames)) {
printf("Sample read failed: %s\n", sf_strerror(sf));
delete[] data;
delete sa;
sa = 0;
}
for (int i = 0; i < channel; ++i) {
data[i] = data[channel + i];
data[(frames-1) * channel + i] = data[(frames-3) * channel + i];
data[(frames-2) * channel + i] = data[(frames-3) * channel + i];
}
sf_close(sf);
return sa;
}
SoundFile::SoundFile(const QString &fname) {
siInfo.frames = 0;
siInfo.channels = 1;
siInfo.samplerate = 0;
siInfo.sections = 0;
siInfo.seekable = 0;
sfFile = NULL;
qfFile.setFileName(fname);
if (qfFile.open(QIODevice::ReadOnly)) {
static SF_VIRTUAL_IO svi = {&SoundFile::vio_get_filelen, &SoundFile::vio_seek, &SoundFile::vio_read, &SoundFile::vio_write, &SoundFile::vio_tell};
sfFile = sf_open_virtual(&svi, SFM_READ, &siInfo, this);
}
}
static gboolean
xmms_sndfile_init (xmms_xform_t *xform)
{
xmms_sndfile_data_t *data;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_sndfile_data_t, 1);
g_return_val_if_fail (data, FALSE);
xmms_xform_private_data_set (xform, data);
data->sfvirtual.get_filelen = &xmms_sf_virtual_get_filelen;
data->sfvirtual.seek = &xmms_sf_virtual_seek;
data->sfvirtual.read = &xmms_sf_virtual_read;
data->sfvirtual.write = &xmms_sf_virtual_write;
data->sfvirtual.tell = &xmms_sf_virtual_tell;
data->sndfile = sf_open_virtual (&data->sfvirtual, SFM_READ,
&data->sf_info, xform);
if (data->sndfile == NULL) {
char errstr[1024];
sf_error_str (NULL, errstr, sizeof (errstr));
xmms_log_error ("libsndfile: sf_open_virtual failed with \"%s\".",
errstr);
g_free (data);
return FALSE;
}
xmms_sndfile_get_media_info (xform);
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm",
XMMS_STREAM_TYPE_FMT_FORMAT,
XMMS_SAMPLE_FORMAT_S32,
XMMS_STREAM_TYPE_FMT_CHANNELS,
data->sf_info.channels,
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
data->sf_info.samplerate,
XMMS_STREAM_TYPE_END);
return TRUE;
}
bool SndFileDecoder::open(FileReader *reader)
{
if (!IsSndFilePresent()) return false;
SF_VIRTUAL_IO sfio = { file_get_filelen, file_seek, file_read, file_write, file_tell };
Reader = reader;
SndInfo.format = 0;
SndFile = sf_open_virtual(&sfio, SFM_READ, &SndInfo, this);
if (SndFile)
{
if (SndInfo.channels == 1 || SndInfo.channels == 2)
return true;
sf_close(SndFile);
SndFile = 0;
}
return false;
}
gboolean
ags_sndfile_rw_open(AgsPlayable *playable, gchar *name,
gboolean create)
{
AgsSndfile *sndfile;
sf_count_t multi_frames;
sndfile = AGS_SNDFILE(playable);
sndfile->info->frames = 0;
sndfile->info->seekable = 0;
sndfile->info->sections = 0;
g_message("export to: %s\n samplerate: %d\n channels: %d\n format: %x\0",
name,
sndfile->info->samplerate,
sndfile->info->channels,
sndfile->info->format);
if(!sf_format_check(sndfile->info)){
g_warning("invalid format");
}
if((AGS_SNDFILE_VIRTUAL & (sndfile->flags)) == 0){
if(name != NULL){
sndfile->file = (SNDFILE *) sf_open(name, SFM_RDWR, sndfile->info);
}
}else{
sndfile->file = (SNDFILE *) sf_open_virtual(ags_sndfile_virtual_io, SFM_RDWR, sndfile->info, sndfile);
}
multi_frames = sndfile->info->frames * sndfile->info->channels;
// sf_command(sndfile->file, SFC_FILE_TRUNCATE, &(multi_frames), sizeof(multi_frames));
// sf_command (sndfile, SFC_SET_SCALE_INT_FLOAT_WRITE, NULL, SF_TRUE);
// sf_seek(sndfile->file, 0, SEEK_SET);
// sndfile->info->frames = multi_frames;
if(sndfile->file == NULL)
return(FALSE);
else
return(TRUE);
}
bool SoundFile::openRead(File& stream)
{
// -- Close any previously open self made stream
if(m_ownedStream)
{
delete m_ownedStream;
m_ownedStream = NULL;
}
// If the file is already opened, first close it
if (m_file)
sf_close(m_file);
// Prepare the memory I/O structure
SF_VIRTUAL_IO io;
io.get_filelen = &Stream::getLength;
io.read = &Stream::read;
io.seek = &Stream::seek;
io.tell = &Stream::tell;
// Initialize the stream data
m_stream.source = &stream;
m_stream.size = stream.getSize();
// Make sure that the stream's reading position is at the beginning
stream.seek(0);
// Open the sound file
SF_INFO fileInfo;
fileInfo.format = 0;
m_file = sf_open_virtual(&io, SFM_READ, &fileInfo, &m_stream);
if (!m_file)
{
Log("Failed to open sound file from stream (%s)", sf_strerror(m_file));
return false;
}
// Initialize the internal state from the loaded information
initialize(fileInfo);
return true;
}
bool SoundBuffer::LoadFromFile(const std::string& filePath)
{
SF_INFO soundInfo;
#if defined(UTH_SYSTEM_ANDROID)
AAsset* asset = FileReader::loadSound(filePath);
SF_VIRTUAL_IO virtualIO;
virtualIO.get_filelen = &FileReader::getAssetLength;
virtualIO.seek = &FileReader::seekAsset;
virtualIO.read = &FileReader::readAsset;
virtualIO.tell = &FileReader::tellAsset;
SNDFILE* file = sf_open_virtual(&virtualIO, SFM_READ, &soundInfo, asset);
#elif defined(UTH_SYSTEM_WINDOWS)
SNDFILE* file = sf_open(("assets/" + filePath).c_str(), SFM_READ, &soundInfo);
#endif
if (!file)
{
int error = sf_error(file);
WriteError("Failed to open sound file, error &d", file, error);
WriteError(sf_error_number(error));
}
WriteLog("Frames: %d\n" , soundInfo.frames);
WriteLog("Samplerae: %d\n" , soundInfo.samplerate);
WriteLog("Channels: %d\n" , soundInfo.channels);
WriteLog("Format: %d\n" , soundInfo.format);
m_soundInfo.frames = static_cast<int>(soundInfo.frames * soundInfo.channels);
m_soundInfo.channels = soundInfo.channels;
m_soundInfo.sampleRate = soundInfo.samplerate;
m_soundInfo.soundBuffer = new short[m_soundInfo.frames];
sf_read_short(file, m_soundInfo.soundBuffer, m_soundInfo.frames);
sf_close(file);
return true;
}
/*
* call-seq:
* CSound.new(path, mode, info) => snd
* CSound.new(io, mode, info) => snd
*
* Returns a new <code>CSound</code> object for the audio file at the given path
* or using the given fixed-length IO-like object with the given mode. Valid modes
* are <code>"r"</code>, <code>"w"</code>, or <code>"rw"</code>.
* <code>StringIO</code> is the only valid IO-like object in the standard library,
* although any object that implements <code>size</code>, <code>seek</code>,
* <code>read</code>, <code>write</code>, and <code>tell</code> will work.
*/
static VALUE ra_sound_init(VALUE self, VALUE source, VALUE mode, VALUE info) {
RA_SOUND *snd;
Data_Get_Struct(self, RA_SOUND, snd);
// Get mode
const char *m = StringValueCStr(mode);
if(strcmp(m, "rw") == 0) snd->mode = SFM_RDWR;
else if(strcmp(m, "r") == 0) snd->mode = SFM_READ;
else if(strcmp(m, "w") == 0) snd->mode = SFM_WRITE;
else rb_raise(rb_eArgError, "invalid access mode %s", m);
// Set info
snd->info = info;
// Open sound file
SF_INFO *sf_info;
Data_Get_Struct(info, SF_INFO, sf_info);
if(TYPE(source) == T_STRING) {
// Open sound file at the path
const char *p = StringValueCStr(source);
snd->snd = sf_open(p, snd->mode, sf_info);
} else {
// Check if the source implements the right methods
if(!rb_respond_to(source, id_size)) rb_raise(eRubyAudioError, "source does not implement size");
if(!rb_respond_to(source, id_seek)) rb_raise(eRubyAudioError, "source does not implement seek");
if(!rb_respond_to(source, id_read)) rb_raise(eRubyAudioError, "source does not implement read");
if(!rb_respond_to(source, id_write)) rb_raise(eRubyAudioError, "source does not implement write");
if(!rb_respond_to(source, id_tell)) rb_raise(eRubyAudioError, "source does not implement tell");
// Open sound using the virtual IO API
snd->vio_source = source;
SF_VIRTUAL_IO vir_io = {ra_vir_size, ra_vir_seek, ra_vir_read, ra_vir_write, ra_vir_tell};
snd->snd = sf_open_virtual(&vir_io, snd->mode, sf_info, (void*)source);
}
if(snd->snd == NULL) rb_raise(eRubyAudioError, sf_strerror(snd->snd));
snd->closed = 0;
return self;
}
gboolean
ags_sndfile_open(AgsPlayable *playable, gchar *name)
{
AgsSndfile *sndfile;
sndfile = AGS_SNDFILE(playable);
sndfile->info = (SF_INFO *) malloc(sizeof(SF_INFO));
sndfile->info->format = 0;
if((AGS_SNDFILE_VIRTUAL & (sndfile->flags)) == 0){
if(name != NULL){
sndfile->file = (SNDFILE *) sf_open(name, SFM_READ, sndfile->info);
}
}else{
sndfile->file = (SNDFILE *) sf_open_virtual(ags_sndfile_virtual_io, SFM_READ, sndfile->info, sndfile);
}
if(sndfile->file == NULL)
return(FALSE);
else
return(TRUE);
}
void Sound::createFromEmbed(File& file) {
uint32_t size = file.readDword();
SNDFILE* stream = NULL;
SF_INFO info;
vio_Stream vio = {file.tell(), size, &file};
//Open stream
if(!(stream = sf_open_virtual(&sfio, SFM_READ, &info, &vio)))
goto end;
//Read audio data
c_samples = info.frames;
channels = info.channels;
sample_rate = info.samplerate;
samples = new float[c_samples * channels];
if(sf_readf_float(stream, samples, c_samples) != c_samples) {
goto error;
}
goto end;
error:
if(samples) {
delete [] samples;
samples = nullptr;
}
c_samples = 0;
channels = 0;
end:
if(stream)
sf_close(stream);
//Make sure file's in the right spot for the next thing
file.seek(vio.origin + vio.size);
}