bool OGGMusic::Load(const char * filename)
{
if (ov_fopen((char*)filename,&_ogg_file)!=0)
return false;
_frequency = _ogg_file.vi->rate;
_channels = _ogg_file.vi->channels;
_total_time = ov_time_total(&_ogg_file,-1);
if (_channels!=2 && _channels!=1)
return false;
//On alloue tout le temps pour 1sec de musique
_stream_block_size = _frequency*2*_channels;
_sound_data_size = _total_time*_frequency*2*_channels;
_sound_data[0] = new char[_stream_block_size];
_sound_data[1] = new char[_stream_block_size];
alGenBuffers(2,_buffer);
alGenSources(1,_source);
CreateThread(NULL,NULL,_thread_play_pause_stop_wrapper,(void*)this,0,NULL);
return true;
}
pair<ALuint, float> Sound_Buffer::load_ogg_vorbis(const string &
#ifndef DISABLE_AL
filename
#endif
) {
#ifndef DISABLE_AL
/*** Open VorbisFile ***/
OggVorbis_File oggFile;
if(ov_fopen(const_cast<char *>(filename.c_str()), &oggFile))
return make_pair(AL_NONE, 0.0f);
/*** Get Information About the Audio File ***/
vorbis_info *pInfo = ov_info(&oggFile, -1);
const ALenum format = pInfo->channels == 2 ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16;
const ALsizei freq = pInfo->rate;
const ALsizei bytes_per_sample = format == AL_FORMAT_STEREO16 ? 4 : 2;
const ogg_int64_t num_samples = ov_pcm_total(&oggFile, -1);
const ogg_int64_t pcm_size = num_samples * bytes_per_sample;
const float duration = float(num_samples) / freq;
#ifndef NDEBUG
if(format == AL_FORMAT_STEREO16)
cerr << "WARNING: '" << filename << "' is stereo and will be unaffected by the OpenAL positional audio system." << endl;
#endif
/*** Load the Audio File ***/
int bytes = 0;
int buffer_size = int(pcm_size);
vector<char> buffer( static_cast<size_t>(buffer_size) );
for(char *begin = &buffer[0], *end = begin + pcm_size;
begin != end;
begin += bytes, buffer_size -= bytes) {
bytes = ov_read(&oggFile, begin, buffer_size, 0, 2, 1, 0);
if(!bytes) {
ov_clear(&oggFile);
throw Sound_Buffer_Init_Failure();
}
}
/*** Generate Audio Buffer ***/
ALuint bufferID = AL_NONE;
alGenBuffers(1, &bufferID);
alBufferData(bufferID, format, &buffer[0], static_cast<ALsizei>(buffer.size()), freq);
return make_pair(bufferID, duration);
#else
return make_pair(AL_NONE, 0.0f);
#endif
}
void SourceFileOggVorbis::init()
{
CI_ASSERT( mDataSource );
#if ! defined( CINDER_ANDROID )
if( mDataSource->isFilePath() ) {
int status = ov_fopen( mDataSource->getFilePath().string().c_str(), &mOggVorbisFile );
if( status )
throw AudioFileExc( string( "Failed to open Ogg Vorbis file with error: " ), (int32_t)status );
}
else {
#endif
mStream = mDataSource->createStream();
ov_callbacks callbacks;
callbacks.read_func = readFn;
callbacks.seek_func = seekFn;
callbacks.close_func = closeFn;
callbacks.tell_func = tellFn;
int status = ov_open_callbacks( this, &mOggVorbisFile, NULL, 0, callbacks );
CI_VERIFY( status == 0 );
#if ! defined( CINDER_ANDROID )
}
#endif
vorbis_info *info = ov_info( &mOggVorbisFile, -1 );
mNumChannels = info->channels;
mSampleRate = info->rate;
ogg_int64_t totalFrames = ov_pcm_total( &mOggVorbisFile, -1 );
mNumFrames = mFileNumFrames = static_cast<uint32_t>( totalFrames );
}
int OGGDecoder::open(const char *url)
{
int ret=ov_fopen(url,&vf);
if (ret<0){
DBG("open fail");
return -1;
}
buffer = new float[VPBUFFER_FRAMES*ov_info(&vf,0)->channels];
half_buffer_size = VPBUFFER_FRAMES*ov_info(&vf,0)->channels*sizeof(float);
VPBuffer bin;
bin.srate = ov_info(&vf,0)->rate;
bin.chans = ov_info(&vf,0)->channels;
bin.buffer[0] = NULL;
bin.buffer[1] = NULL;
owner->setOutBuffers(&bin,&bout);
for (unsigned i=0;i<VPBUFFER_FRAMES*bout->chans;i++){
bout->buffer[0][i]=0.0f;
bout->buffer[1][i]=0.0f;
}
return 0;
}
int SoundSourceOggVorbis::open()
{
QByteArray qBAFilename = m_qFilename.toLocal8Bit();
#ifdef __WINDOWS__
if(ov_fopen(qBAFilename.constData(), &vf) < 0) {
qDebug() << "oggvorbis: Input does not appear to be an Ogg bitstream.";
filelength = 0;
return ERR;
}
#else
FILE *vorbisfile = fopen(qBAFilename.constData(), "r");
if (!vorbisfile) {
qDebug() << "oggvorbis: cannot open" << m_qFilename;
return ERR;
}
if(ov_open(vorbisfile, &vf, NULL, 0) < 0) {
qDebug() << "oggvorbis: Input does not appear to be an Ogg bitstream.";
filelength = 0;
return ERR;
}
#endif
// lookup the ogg's channels and samplerate
vorbis_info * vi = ov_info(&vf, -1);
channels = vi->channels;
m_iSampleRate = vi->rate;
if(channels > 2){
qDebug() << "oggvorbis: No support for more than 2 channels!";
ov_clear(&vf);
filelength = 0;
return ERR;
}
// ov_pcm_total returns the total number of frames in the ogg file. The
// frame is the channel-independent measure of samples. The total samples in
// the file is channels * ov_pcm_total. rryan 7/2009 I verified this by
// hand. a 30 second long 48khz mono ogg and a 48khz stereo ogg both report
// 1440000 for ov_pcm_total.
ogg_int64_t ret = ov_pcm_total(&vf, -1);
if (ret >= 0) {
// We pretend that the file is stereo to the rest of the world.
filelength = ret * 2;
}
else //error
{
if (ret == OV_EINVAL) {
//The file is not seekable. Not sure if any action is needed.
qDebug() << "oggvorbis: file is not seekable " << m_qFilename;
}
}
return OK;
}
void OggFileStream::init(const ALuint& source,
const int& position_in_file,
const int& position_in_buffer,
const bool& is_event)
{
// create buffers for reading in flip mode
alGenBuffers(2,m_buffers) ;
InternalMessage("Sound", "enter oggreader Init") ;
// Create Ogg Stream on the file
m_stream = new OggVorbis_File() ;
int error = ov_fopen((char*)m_file_name.c_str(),m_stream) ;
if (error < 0)
{
ErrorMessage("[OpenAL::OggReader] Can't read the samples") ;
return ;
}
// Get sound information
vorbis_info* Infos = ov_info(m_stream,-1) ;
m_sample_rate = Infos->rate ;
m_samples_by_buffer = (ALsizei)(Infos->channels * Infos->rate * m_update_time) ;
switch (Infos->channels)
{
case 1:
m_format = AL_FORMAT_MONO16 ;
break;
case 2:
m_format = AL_FORMAT_STEREO16 ;
break;
default:
ErrorMessage("[OpenAL::OggReader] Audio Format audio not supported (more than 2 channel)") ;
return ;
}
int pos = 0 ;
if (position_in_file > 0)
{
pos = position_in_file-m_samples_by_buffer+position_in_buffer+1 ;
}
ov_pcm_seek(m_stream,pos) ;
// Load the buffers
loadBuffer(m_buffers[0],is_event) ;
loadBuffer(m_buffers[1],is_event) ;
alSourceQueueBuffers(source,2,m_buffers) ;
if (alGetError() != AL_NO_ERROR)
{
InformationMessage("Sound",
"[OpenAL::OggReader] Impossible to queue the buffers") ;
return ;
}
InternalMessage("Sound", "leave oggreader Init") ;
}
static int private_load_vorbis (
LISndSample* self,
const char* file)
{
int bs = -1;
int freq;
long num;
void* buffer;
ogg_int64_t pos;
ogg_int64_t len;
vorbis_info* info;
OggVorbis_File vorbis;
/* Initialize the decoder. */
num = ov_fopen ((char*) file, &vorbis);
if (num != 0)
{
if (num == OV_EREAD)
lisys_error_set (EIO, "cannot open `%s'", file);
else
lisys_error_set (EINVAL, "cannot read `%s'", file);
return 0;
}
/* Get stream information. */
info = ov_info (&vorbis, -1);
freq = info->rate;
len = 2 * info->channels * ov_pcm_total (&vorbis, -1);
pos = 0;
/* Allocate the output buffer. */
buffer = lisys_malloc (len);
if (buffer == NULL)
{
ov_clear (&vorbis);
return 0;
}
/* Decode the stream. */
while (1)
{
num = ov_read (&vorbis, buffer + pos, len - pos, lisys_endian_big (), 2, 1, &bs);
if (num <= 0)
break;
pos += num;
}
/* Upload to OpenAL. */
if (info->channels == 1)
private_load_raw (self, AL_FORMAT_MONO16, buffer, len, freq);
else
private_load_raw (self, AL_FORMAT_STEREO16, buffer, len, freq);
ov_clear (&vorbis);
lisys_free (buffer);
return 1;
}
void SoundBuffer::InitOgg( const char * a_filename )
{
#ifdef USE_VORBIS
// http://www.gamedev.net/page/resources/_/technical/game-programming/introduction-to-ogg-vorbis-r2031
OggVorbis_File ogg_file;
// load ogg
const char * full_path = GetFullPath( a_filename );
int err_val = ov_fopen( full_path, &ogg_file );
//int err_val = ov_open_callbacks( nullptr, &ogg_file, (const char*)a_data_file.GetData(), a_data_file.GetNumBytes(), OV_CALLBACKS_STREAMONLY );
CHECK( err_val == 0, "OGG File load error %d", err_val );
vorbis_info * ogg_info = ov_info(&ogg_file, -1);
ASSERT( ogg_info );
// ogg format
ALenum al_format;
if ( ogg_info->channels == 1 )
al_format = AL_FORMAT_MONO16;
else if ( ogg_info->channels == 2 )
al_format = AL_FORMAT_STEREO16;
else
ERROR_MSG("OGG - Unrecognized num channels : %d", ogg_info->channels );
// num samples
ogg_int64_t total_num_pcm_samples = ov_pcm_total( &ogg_file, -1 );
ASSERT( total_num_pcm_samples > 0 );
// reserve space for the buffer
std::vector<char> buffer;
buffer.reserve( (size_t)(total_num_pcm_samples * 2 * ogg_info->channels) );
char buff_array[32768]; // Local fixed size array
int bit_stream = 0;
int num_bytes_read = 0;
// read all the data
do
{
num_bytes_read = ov_read(&ogg_file, buff_array, sizeof(buff_array), 0, 2, 1, &bit_stream);
buffer.insert(buffer.end(), buff_array, buff_array + num_bytes_read);
} while (num_bytes_read > 0);
// check size size
ASSERT( total_num_pcm_samples * 2 * ogg_info->channels == buffer.size() );
// output the data
ALsizei al_size = buffer.size();
ALsizei al_freq = ogg_info->rate;
ASSERT( alIsBuffer(m_id) );
alBufferData( m_id, al_format, &buffer[0], al_size, al_freq);
// close the file
ov_clear(&ogg_file);
#endif
}
Audio::Stream :: Stream(std::string fn):
m_Filename(fn)
{
auto l = Audio::lock();
if(Headless::enabled())
return;
// clear errors
clear_errors();
int r;
if((r = ov_fopen((char*)&fn[0], &m_Ogg)) < 0)
ERROR(READ, Filesystem::getFileName(fn));
if(check_errors())
ERROR(READ, Filesystem::getFileName(fn));
m_VorbisInfo = ov_info(&m_Ogg, -1);
m_VorbisComment = ov_comment(&m_Ogg, -1);
if(check_errors())
ERROR(READ, Filesystem::getFileName(fn));
if(m_VorbisInfo->channels == 1)
m_Format = AL_FORMAT_MONO16;
else
m_Format = AL_FORMAT_STEREO16;
alGenBuffers(2, m_Buffers);
if(check_errors())
ERROR(READ, Filesystem::getFileName(fn));
flags |= Source::F_LOOP;
//std::cout
// << "version " << m_VorbisInfo->version << "\n"
// << "channels " << m_VorbisInfo->channels << "\n"
// << "rate (hz) " << m_VorbisInfo->rate << "\n"
// << "bitrate upper " << m_VorbisInfo->bitrate_upper << "\n"
// << "bitrate nominal " << m_VorbisInfo->bitrate_nominal << "\n"
// << "bitrate lower " << m_VorbisInfo->bitrate_lower << "\n"
// << "bitrate window " << m_VorbisInfo->bitrate_window << "\n"
// << "\n"
// << "vendor " << m_VorbisComment->vendor << "\n";
//for(int i = 0; i < m_VorbisComment->comments; i++)
// std::cout << " " << m_VorbisComment->user_comments[i] << "\n";
//std::cout << std::endl;
m_bOpen = true;
}
void parse_metadata(const char *path, song_t *song) {
OggVorbis_File vf;
int rc = ov_fopen(path, &vf);
if (rc) {
fprintf(stderr, "Could not open '%s'\n", path);
return;
}
vorbis_comment *comment = ov_comment(&vf, -1);
if (comment == NULL) {
fprintf(stderr, "Could not read comments from '%s'\n", path);
return;
}
song->path = calloc(strlen(path)+1, sizeof(char));
strcpy(song->path, path);
char *buf;
for (int i=0; i < comment->comments; i++) {
buf = calloc(comment->comment_lengths[i]+1, sizeof(char));
strncpy(buf, comment->user_comments[i], comment->comment_lengths[i]);
buf[comment->comment_lengths[i]] = '\0';
int equals = 0;
for (; buf[equals] != '=' && equals < strlen(buf); equals++);
int len = 0;
if (equals < strlen(buf)) {
if (! strncmp(buf, ARTIST, strlen(ARTIST))) {
len = strlen(buf)-strlen(ARTIST)+1;
song->artist = calloc(len, sizeof(char));
strncpy(song->artist, buf+equals+1, len);
} else if (! strncmp(buf, ALBUM, strlen(ALBUM))) {
len = strlen(buf)-strlen(ALBUM)+1;
song->album = calloc(len, sizeof(char));
strncpy(song->album, buf+equals+1, len);
} else if (! strncmp(buf, TITLE, strlen(TITLE))) {
len = strlen(buf)-strlen(TITLE)+1;
song->title = calloc(len, sizeof(char));
strncpy(song->title, buf+equals+1, len);
} else if ( !strncmp(buf, TRACKNUMBER, strlen(TRACKNUMBER))) {
len = strlen(buf)-strlen(TRACKNUMBER);
song->track = atoi(buf+equals+1);
}
}
free(buf);
}
ov_clear(&vf);
}
int
VorbisDecoder_init(decoders_VorbisDecoder *self, PyObject *args, PyObject *kwds) {
char* filename;
vorbis_info* info;
self->open_ok = 0;
self->channel_count = 0;
self->rate = 0;
self->closed = 0;
self->audiotools_pcm = NULL;
if (!PyArg_ParseTuple(args, "s", &filename))
return -1;
/*open file using reference Ogg Vorbis decoder*/
switch (ov_fopen(filename, &(self->vorbisfile))) {
case 0:
default:
self->open_ok = 1;
break;
case OV_EREAD:
PyErr_SetString(PyExc_ValueError, "I/O error");
return -1;
case OV_ENOTVORBIS:
PyErr_SetString(PyExc_ValueError, "not a Vorbis file");
return -1;
case OV_EVERSION:
PyErr_SetString(PyExc_ValueError, "Vorbis version mismatch");
return -1;
case OV_EBADHEADER:
PyErr_SetString(PyExc_ValueError, "invalid Vorbis bitstream header");
return -1;
case OV_EFAULT:
PyErr_SetString(PyExc_ValueError, "internal logic fault");
return -1;
}
/*pull stream metadata from decoder*/
if ((info = ov_info(&(self->vorbisfile), -1)) != NULL) {
self->channel_count = info->channels;
self->rate = info->rate;
} else {
PyErr_SetString(PyExc_ValueError, "unable to get Vorbis info");
return -1;
}
/*open FrameList creator*/
if ((self->audiotools_pcm = open_audiotools_pcm()) == NULL)
return -1;
return 0;
}
static int
oggfile_open(struct oggfile *of, char *path)
{
assert(of != NULL);
assert(path != NULL);
if (ov_fopen((char *)path, &of->ovf) != 0)
return (1);
of->path = path;
return (0);
}
SoundBuffer::SoundBuffer(const FilePath& path) {
OggVorbis_File file;
CHECK(ov_fopen(path.getPath(), &file) == 0) << "Error opening audio file: " << path;
vorbis_info* info = ov_info(&file, -1);
ov_raw_seek(&file, 0);
vector<char> buffer = readSoundData(file);
OpenalId id;
AL(alGenBuffers(1, &id));
AL(alBufferData(id, (info->channels > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16, buffer.data(), buffer.size(),
info->rate));
bufferId = id;
ov_clear(&file);
}
bool OggStream::open(string path)
{
int error = ov_fopen((char*)path.c_str(), &mStream);
ostringstream oss;
oss << "AudioFile:" << path;
mStreamInfo = oss.str();
if(error) {
switch(error)
{
case OV_EREAD:
LOG4CXX_ERROR(narratorOsLog, "File " << path << ": A read from media returned an error");
break;
case OV_ENOTVORBIS:
LOG4CXX_ERROR(narratorOsLog, "File " << path << ": Bitstream is not Vorbis data");
break;
case OV_EVERSION:
LOG4CXX_ERROR(narratorOsLog, "File " << path << ": Vorbis version mismatch");
break;
case OV_EBADHEADER:
LOG4CXX_ERROR(narratorOsLog, "File " << path << ": Invalid Vorbis bitstream header");
break;
case OV_EFAULT:
LOG4CXX_ERROR(narratorOsLog, "File " << path << ": Internal logic fault");
break;
default:
LOG4CXX_ERROR(narratorOsLog, "File " << path << ": unknown error occurred");
break;
}
return false;
}
vorbis_info *vi = ov_info(&mStream,-1);
isOpen = true;
mChannels = vi->channels;
mRate = vi->rate;
/*
char **ptr = ov_comment(&mStream,-1)->user_comments;
while(*ptr){
LOG4CXX_DEBUG(narratorOsLog, "comment: " << *ptr);
++ptr;
}
size_t total_size = ov_pcm_total(&mStream, -1);
LOG4CXX_DEBUG(narratorOsLog, "total size: " << total_size);
*/
return true;
}
bool COGGPlayer::open()
{
// If Ogg detected, decode it into the stream psound->sound_buffer.
// It must fit into the Audio_cvt structure, so that it can be converted
mHasCommonFreqBase = true;
if(ov_fopen((char*)GetFullFileName(m_filename).c_str(), &m_oggStream) != 0)
return false;
mVorbisInfo = ov_info(&m_oggStream, -1);
ov_comment(&m_oggStream, -1);
m_AudioFileSpec.format = AUDIO_S16LSB; // Ogg Audio seems to always use this format
m_AudioFileSpec.channels = mVorbisInfo->channels;
m_AudioFileSpec.freq = mVorbisInfo->rate;
// Since I cannot convert with a proper quality from 44100 to 48000 Ogg wave output
// we set m_AudioFileSpec frequency to the same as the one of the SDL initialized AudioSpec
// scale just the buffer using readOGGStreamAndResample.
// This is base problem, but we have workarounds for that...
if( (m_AudioFileSpec.freq%m_AudioSpec.freq != 0) &&
(m_AudioSpec.freq%m_AudioFileSpec.freq != 0) )
{
m_AudioFileSpec.freq = m_AudioSpec.freq;
mHasCommonFreqBase = false;
}
m_pcm_size = ov_pcm_total(&m_oggStream,-1);
m_pcm_size *= (mVorbisInfo->channels*sizeof(Sint16));
m_music_pos = 0;
g_pLogFile->ftextOut("OGG-Player: File \"%s\" was opened successfully!<br>", m_filename.c_str());
int ret = SDL_BuildAudioCVT(&m_Audio_cvt,
m_AudioFileSpec.format, m_AudioFileSpec.channels, m_AudioFileSpec.freq,
m_AudioSpec.format, m_AudioSpec.channels, m_AudioSpec.freq);
if(ret == -1)
return false;
const size_t length = m_AudioSpec.size;
//m_Audio_cvt.len = (length*m_Audio_cvt.len_mult)/m_Audio_cvt.len_ratio;
m_Audio_cvt.len = (length)/m_Audio_cvt.len_ratio;
m_Audio_cvt.len = (m_Audio_cvt.len>>2)<<2;
m_Audio_cvt.buf = new Uint8[m_Audio_cvt.len*m_Audio_cvt.len_mult];
return true;
}
static DWORD ovGetPcmSize(const char* filename)
{
OggVorbis_File ovf;
int error;
DWORD dwPCMBytes;
error = ov_fopen(filename, &ovf);
if(error != OV_SUCCESSFUL)
{
return 0;
}
dwPCMBytes = ovGetPcmSize(&ovf);
ov_clear(&ovf);
return dwPCMBytes;
}
SoundBuffer *load_ogg_from_file(const std::string &path)
{
OggVorbis_File oggFile;
// Try opening the given file.
// This requires libvorbis >= 1.3.2, as
// previous versions expect a non-const char *
if (ov_fopen(path.c_str(), &oggFile) != 0) {
infostream << "Audio: Error opening " << path
<< " for decoding" << std::endl;
return NULL;
}
return load_opened_ogg_file(&oggFile, path);
}
void
AudioManager::Player::Play(const Ogre::String &file)
{
boost::recursive_mutex::scoped_lock lock(*m_UpdateMutex);
// open vorbis file
if(ov_fopen(const_cast<char*>(file.c_str()), &m_VorbisFile))
{
LOG_ERROR("Can't play file \"" + file + "\".");
return;
}
// get file info
m_VorbisInfo = ov_info(&m_VorbisFile, -1.0f);
// create sound source
alGenSources(1, &m_Source);
// create buffers
ALuint buffers[m_ChannelBufferNumber];
alGenBuffers(m_ChannelBufferNumber, buffers);
// set source parameters
alSourcei(m_Source, AL_LOOPING, AL_FALSE);
// fill buffers
for(int i = 0; i < m_ChannelBufferNumber; ++i)
{
ALsizei buffer_size = FillBuffer();
if(buffer_size)
{
alBufferData(buffers[i], m_VorbisInfo->channels ==
1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16,
(const ALvoid*)AudioManager::getSingleton().m_Buffer,
(ALsizei)buffer_size, (ALsizei)m_VorbisInfo->rate);
alSourceQueueBuffers(m_Source, 1, &buffers[i]);
}
else
{
m_StreamFinished = true;
alDeleteBuffers(1, &buffers[i]);
}
}
// start playback
alSourcePlay(m_Source);
}
bool AudioDecoderOgg::open(const char* path)
{
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(path);
if (0 == ov_fopen(FileUtils::getInstance()->getSuitableFOpen(fullPath).c_str(), &_vf))
{
// header
vorbis_info* vi = ov_info(&_vf, -1);
_sampleRate = static_cast<uint32_t>(vi->rate);
_channelCount = vi->channels;
_bytesPerFrame = vi->channels * sizeof(short);
_totalFrames = static_cast<uint32_t>(ov_pcm_total(&_vf, -1));
_isOpened = true;
return true;
}
return false;
}
bool FileFormatVorbis::Open(QString& filename)
{
int result = ov_fopen(filename.toStdString().c_str(), _oggVorbisFile);
if( result < 0)
{
//fclose(_musicFile);
#ifdef WIN32
MessageBox( QMessageBox::Critical, QString::Format("Could not open ogg file '%s': %s", filename, VorbisErrorString(result)), "Error", QMessageBox::Ok );
#endif
return false;
}
_vorbisInfo = ov_info(_oggVorbisFile, -1);
_vorbisComment = ov_comment(_oggVorbisFile, -1);
return true;
}
int
getlen(char *path, double *len)
{
OggVorbis_File vf;
assert(path != NULL);
if (ov_fopen(path, &vf) != 0) {
warn("ov_fopen(\"%s\", ...)", path);
return (-1);
}
if ((*len = ov_time_total(&vf, -1)) == OV_EINVAL) {
errx(EX_SOFTWARE, "ov_time_total");
}
if (ov_clear(&vf) != 0)
errx(EX_SOFTWARE, "ov_clear");
return (0);
}
int vorbis_source_init(audio_source *src, const char* file) {
vorbis_source *local;
int ret;
// Init local struct
local = malloc(sizeof(vorbis_source));
// Try to open up the audio file
ret = ov_fopen(file, &local->src_file);
if(ret != 0) {
PERROR("Vorbis Source: File '%s' could not be opened: ", file, vorbis_text_error(ret));
goto error_1;
}
// Get file information
vorbis_info *vi = ov_info(&local->src_file, -1);
char **comment_ptr = ov_comment(&local->src_file, -1)->user_comments;
// Audio information
source_set_frequency(src, vi->rate);
source_set_bytes(src, 2);
source_set_channels(src, vi->channels);
// Set callbacks
source_set_userdata(src, local);
source_set_update_cb(src, vorbis_source_update);
source_set_close_cb(src, vorbis_source_close);
// Some debug info
DEBUG("Vorbis Source: Loaded file '%s' succesfully (%d Hz, %d ch).",
file, vi->rate, vi->channels);
while(*comment_ptr) {
DEBUG(" * Comment: %s", *comment_ptr);
++comment_ptr;
}
// All done
return 0;
error_1:
free(local);
return 1;
}
void AudioFile::open(const std::string& path)
{
if(mFile)
{
ov_clear(mFile);
delete mFile;
}
mFile = new OggVorbis_File;
if(ov_fopen(path.c_str(), mFile))
{
throw AudioFileNotFoundException("Error when trying to load audio file '" + path + "!");
}
vorbis_info* info = ov_info(mFile, -1);
mChannelCount = info->channels;
mSampleRate = info->rate;
mSampleAmount = 2 * (size_t)ov_pcm_total(mFile, -1);
}
static int
fill_comments(struct ogg_context *ctx, struct ogg_oggfile *ogg)
{
OggVorbis_File ovf;
vorbis_comment *ovc;
char *key, *value;
int i;
assert(ctx != NULL);
assert(ogg != NULL);
if (ov_fopen(ogg->filename, &ovf) != 0) {
warnx("could not open file: %s", ogg->filename);
return (1);
}
if ((ovc = ov_comment(&ovf, -1)) == NULL) {
warnx("could not read comments for file: %s", ogg->filename);
return (1);
}
for (i = 0; i < ovc->comments; i++) {
value = ovc->user_comments[i];
key = strsep(&value, "=");
if (strcasecmp(key, "artist") == 0)
do_iconv(ctx, value, ogg->artist, sizeof(ogg->artist));
else if (strcasecmp(key, "album") == 0)
do_iconv(ctx, value, ogg->album, sizeof(ogg->album));
else if (strcasecmp(key, "title") == 0)
do_iconv(ctx, value, ogg->title, sizeof(ogg->title));
if (ogg->artist == NULL || ogg->album == NULL || ogg->title == NULL) {
warnx("insufficient comments for file: %s", ogg->filename);
return (1);
}
}
if (ov_clear(&ovf) != 0)
warnx("could not close file: %s", ogg->filename);
return (0);
}
Sound_Stream_AL::Sound_Stream_AL(const String &path, const bool &looping_, const float &time_)
: buffers_used(0),
looping(looping_)
{
if(!dynamic_cast<Sound_Renderer_AL *>(&get_Sound().get_Renderer()))
throw Sound_Stream_Init_Failure();
const int result = ov_fopen((path + ".ogg").c_str(), &oggStream);
if(result < 0)
throw Sound_Stream_Ogg_Read_Failure();
vorbisInfo = ov_info(&oggStream, -1);
vorbisComment = ov_comment(&oggStream, -1);
if(vorbisInfo->channels == 1)
format = AL_FORMAT_MONO16;
else
format = AL_FORMAT_STEREO16;
ov_time_seek(&oggStream, time_);
Sound_Renderer_AL::alGenBuffers()(NUM_BUFFERS, buffers);
Sound_Renderer_AL::alGenSources()(1, &source);
ALfloat pos[3] = {0.0f, 0.0f, 0.0f};
Sound_Renderer_AL::alSourcefv()(source, AL_POSITION, pos );
Sound_Renderer_AL::alSourcefv()(source, AL_VELOCITY, pos );
Sound_Renderer_AL::alSourcefv()(source, AL_DIRECTION, pos );
Sound_Renderer_AL::alSourcef() (source, AL_ROLLOFF_FACTOR, 0.0 );
Sound_Renderer_AL::alSourcei() (source, AL_SOURCE_RELATIVE, AL_TRUE);
const ALenum error = Sound_Renderer_AL::alGetError()();
if(error != AL_NO_ERROR) {
destroy();
std::cerr << "OpenAL error: " << Sound_Renderer_AL::errorString(error) << std::endl;
throw Sound_Stream_Init_Failure();
}
}
Result SoundSourceOggVorbis::tryOpen(const AudioSourceConfig& /*audioSrcCfg*/) {
const QByteArray qbaFilename(getLocalFileNameBytes());
if (0 != ov_fopen(qbaFilename.constData(), &m_vf)) {
qWarning() << "Failed to open OggVorbis file:" << getUrlString();
return ERR;
}
if (!ov_seekable(&m_vf)) {
qWarning() << "OggVorbis file is not seekable:" << getUrlString();
return ERR;
}
// lookup the ogg's channels and sample rate
const vorbis_info* vi = ov_info(&m_vf, kCurrentBitstreamLink);
if (!vi) {
qWarning() << "Failed to read OggVorbis file:" << getUrlString();
return ERR;
}
setChannelCount(vi->channels);
setFrameRate(vi->rate);
if (0 < vi->bitrate_nominal) {
setBitrate(vi->bitrate_nominal / 1000);
} else {
if ((0 < vi->bitrate_lower) && (vi->bitrate_lower == vi->bitrate_upper)) {
setBitrate(vi->bitrate_lower / 1000);
}
}
ogg_int64_t pcmTotal = ov_pcm_total(&m_vf, kEntireBitstreamLink);
if (0 <= pcmTotal) {
setFrameCount(pcmTotal);
} else {
qWarning() << "Failed to read total length of OggVorbis file:" << getUrlString();
return ERR;
}
return OK;
}
//--------------------------------------------------------------------------------------------
// ogg形式をPCM形式へデコードし、DSのバッファに書き込みます
//--------------------------------------------------------------------------------------------
static int ovCreateBuffer(OggVorbis_File* ovf_ptr, int bufNumber, const char* filename, DWORD dwSize)
{
int errorNo;
// ファイルを開き、oggでなければエラー番号を返す
ovInitOggEnv(ovf_ptr);
errorNo = ov_fopen(filename, ovf_ptr);
if(errorNo != OV_SUCCESSFUL) return errorNo;
// PCMの形式をある程度調べる
// サンプリングレートとチャンネル数のみ？
vorbis_info *info = ov_info( ovf_ptr, -1 );
ogg_int64_t t = ov_pcm_total(ovf_ptr, -1);
// DirectSoundBuffer設定
WAVEFORMATEX wf;
//さて、デコードしたPCMのビットレート16を自動的に求めるには…
dsSetWaveFormat(&wf, info->rate, info->channels, OV_PCM_BITRATE);
dwSize = dwSize == 0 ? ovGetPcmSize(ovf_ptr): dwSize;
dsCreateSoundBuffer(bufNumber, &wf, dwSize);
return OV_SUCCESSFUL;
}
//This function will open up a specified .ogg file
bool DIZ_OGGSTREAM::loadFile(char fname[]) {
//Declare an error-checking variable
int result;
//Attempt to open the specified file and check for an error
result = ov_fopen(fname, &oggFile);
if (result < 0) {
return false;
}
//Retrieve some info about our file
vorbisInfo = ov_info(&oggFile, -1);
//Check our channels info and manually set our format accordingly
if (vorbisInfo->channels == 1) {
format = AL_FORMAT_MONO16;
}else {
format = AL_FORMAT_STEREO16;
}
//And return true for A-OK
return true;
}
bool AudioSourceOGG::Open(const char* Filename)
{
#if !(defined WIN32) || (defined MINGW)
int32 retv = ov_fopen(Filename, &mOggFile);
#else
FILE* fp = _wfopen(Utility::Widen(Filename).c_str(), L"rb");
int retv = -1;
if (fp)
retv = ov_open_callbacks(static_cast<void*>(fp), &mOggFile, nullptr, 0, fileInterfaceOgg);
#endif
#ifndef NDEBUG
dFILENAME = Filename;
#endif
#if !(defined WIN32) || (defined MINGW)
if (retv == 0)
#else
if (retv == 0 && fp)
#endif
{
info = ov_info(&mOggFile, -1);
comment = ov_comment(&mOggFile, -1);
mIsValid = true;
mIsDataLeft = true;
}
else
{
mIsValid = false;
Log::Printf("Failure loading ogg file: %s (%d)\n", Filename, retv);
}
return mIsValid;
}
std::string GetOggTitle(std::string file)
{
OggVorbis_File f;
std::string result = "";
if (ov_fopen(file.c_str(), &f) == 0)
{
vorbis_comment *comment = ov_comment(&f, -1);
for (int i = 0; i < comment->comments; i++)
{
std::string user_comment = comment->user_comments[i];
auto splitvec = Utility::TokenSplit(user_comment, "=");
if (splitvec[0] == "TITLE")
{
result = splitvec[1];
break;
}
}
ov_clear(&f);
}
return result;
}
