static void plugin_seek(struct playerHandles *ph, int modtime){
int newtime;
int seconds;
struct vorbisHandles *h;
if(ph->dechandle==NULL)
return;
h=(struct vorbisHandles *)ph->dechandle;
if(modtime==0){
ov_time_seek(h->vf,0);
*h->total=0;
snd_clear(ph);
return;
}
seconds=(*h->total)/((h->rate)*(h->sizemod));
seconds+=modtime;
if(ov_time_seek(h->vf,seconds)!=0)
return;
newtime=seconds*((h->rate)*(h->sizemod));
if(newtime<0)
newtime=0;
*h->total=newtime;
snd_clear(ph);
}
void alogg_seek_abs_secs_ogg(ALOGG_OGG *ogg, int sec) {
#ifdef USE_TREMOR
ov_time_seek(&(ogg->vf), sec * 1000);
#else
ov_time_seek(&(ogg->vf), sec);
#endif
}
int COggVorbisFileHelper::ov_time_seek_func( OggVorbis_File *vf,double pos )
{
#ifdef _USELIBTREMOR
ogg_int64_t ipos = 0;
ipos = ((ogg_int64_t)pos) * 1000;
return ov_time_seek(vf,ipos)/1000;
#else
return ov_time_seek(vf,pos);
#endif
}
void alogg_seek_abs_msecs_ogg(ALOGG_OGG *ogg, int msec) {
#ifdef USE_TREMOR
ov_time_seek(&(ogg->vf), msec);
#else
/* convert msec to pcm sample position */
double s = msec;
s /= 1000;
ov_time_seek(&(ogg->vf), s);
#endif
}
void alogg_seek_rel_secs_ogg(ALOGG_OGG *ogg, int sec) {
#ifdef USE_TREMOR
ogg_int64_t _msec = sec * 1000;
_msec += ov_time_tell(&(ogg->vf));
ov_time_seek(&(ogg->vf), _msec);
#else
double s = sec;
s += ov_time_tell(&(ogg->vf));
ov_time_seek(&(ogg->vf), s);
#endif
}
uint32_t AudioSourceOGG::Read(short* buffer, size_t count)
{
size_t size;
size_t read = 0;
int sect;
if (!mIsValid)
return 0;
size = count*sizeof(short);
if (mSeekTime >= 0)
{
mIsDataLeft = true;
ov_time_seek(&mOggFile, mSeekTime);
mSeekTime = -1;
}
/* read from ogg vorbis file */
size_t res = 1;
while (read < size)
{
res = ov_read(&mOggFile, (char*)buffer + read, size - read, 0, 2, 1, §);
if (res > 0)
read += res;
else if (res == 0)
{
if (mSourceLoop)
{
ov_time_seek(&mOggFile, 0);
}
else
{
mIsDataLeft = false;
return 0;
}
}
else
{
Log::Printf("AudioSourceOGG: Error while reading OGG source (%d)\n", res);
mIsDataLeft = false;
return 0;
}
}
return read / sizeof(short);
}
bool AudioStream_Ogg::stream( ALuint buffer ) {
if (openal_is_shutdown) return false;
if (mSuspend) return true;
//LOG_SOUND("STREAM\n");
char pcm[STREAM_BUFFER_SIZE];
int size = 0;
int section;
int result;
while (size < STREAM_BUFFER_SIZE) {
result = ov_read(oggStream, pcm + size, STREAM_BUFFER_SIZE - size, 0, 2, 1, §ion);
if(result > 0)
size += result;
else
if(result < 0) {
if ( mLoops > 0 ) {
mLoops --;
ov_time_seek(oggStream, 0);
}else{
break;
}
//LOG_SOUND ("Result is less than 0");
//throw errorString(result);
}
else
break;
}
if(size <= 0) {
if ( mLoops > 0 ) {
mLoops --;
ov_time_seek(oggStream, 0);
return stream( buffer );
}else{
alSourceStop(source);
return false;
}
}
alBufferData(buffer, format, pcm, size, vorbisInfo->rate);
check();
return true;
} //stream
void oggStreamCallback(void* userData, u32 requestedChunkSize, u8* chunkData)
{
LOCK();
s32 totalSize = 0;
while (totalSize < (s32)requestedChunkSize)
{
s32 bitStream = 0;
s32 soundSize = ov_read(&s_oggFile, (char*)&chunkData[totalSize], requestedChunkSize-totalSize, 0, 2, 1, &bitStream);
//theoretically the sampling rate can change throughout the song...
//however this is not supported by the XL Engine currently (it would require more work in the sound layer).
//we've finished the loop, start the song all over again.
if (soundSize == 0)
{
ov_time_seek(&s_oggFile, 0.0);
soundSize = ov_read(&s_oggFile, (char*)&chunkData[totalSize], requestedChunkSize-totalSize, 0, 2, 1, &bitStream);
}
else if (soundSize < 0) //error in the bit stream.
{
LOG( LOG_ERROR, "ogg streaming error: %d", soundSize );
soundSize = 0;
break;
}
totalSize += soundSize;
};
UNLOCK();
}
/*/////////////////////////////////////////////////////////////////*/
void OgreOggStreamSound::_updatePlayPosition()
{
if ( mSource==AL_NONE || !mSeekable )
return;
bool paused = isPaused();
bool playing = isPlaying();
// Seek...
pause();
ov_time_seek(&mOggStream, mPlayPos);
// Unqueue all buffers
_dequeue();
// Fill buffers
_prebuffer();
// Reset state..
if ( playing ) play();
else if ( paused ) pause();
// Set flag
mStreamEOF=false;
mPlayPosChanged = false;
mLastOffset = mPlayPos;
}
seal_err_t
_seal_rewind_ov_stream(seal_stream_t* stream)
{
if (ov_time_seek(stream->id, 0) != 0)
return SEAL_CANNOT_REWIND_OV;
return SEAL_OK;
}
void alogg_seek_abs_msecs_ogg(ALOGG_OGG *ogg, int msec) {
/* convert msec to pcm sample position */
double s = msec;
s /= 1000;
ov_time_seek(&(ogg->vf), s);
}
void FVorbisAudioInfo::SeekToTime( const float SeekTime )
{
FScopeLock ScopeLock(&VorbisCriticalSection);
const float TargetTime = FMath::Min(SeekTime, ( float )ov_time_total( &VFWrapper->vf, -1 ));
ov_time_seek( &VFWrapper->vf, TargetTime );
}
void alogg_seek_rel_msecs_ogg(ALOGG_OGG *ogg, int msec) {
double s = msec;
s /= 1000;
s += ov_time_tell(&(ogg->vf));
ov_time_seek(&(ogg->vf), s);
}
//=================================================================================================
void SoundFileOgg::seek( double time )
{
if (!file)
return;
ov_time_seek( &vf, time );
}
bool cOggDecoder::seek(float seconds, bool relative)
{
if(Valid)
{
if(ov_seekable(&oggStream))
{
if(relative)
{
float curtime = ov_time_tell(&oggStream);
return (ov_time_seek(&oggStream,curtime+seconds)==0);
}
else
return (ov_time_seek(&oggStream,seconds)==0);
}
}
return false;
}
static int S_VORBIS_CodecRewindStream (snd_stream_t *stream)
{
/* for libvorbisfile, the ov_time_seek() position argument
* is seconds as doubles, whereas for Tremor libvorbisidec
* it is milliseconds as 64 bit integers.
*/
return ov_time_seek ((OggVorbis_File *)stream->priv, 0);
}
static int OGG_seek(Sound_Sample *sample, uint32_t ms)
{
Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
OggVorbis_File *vf = (OggVorbis_File *) internal->decoder_private;
/* Unlike Vorbis, Tremor uses integer milliseconds instead of double seconds. */
BAIL_IF_MACRO(ov_time_seek(vf, (ogg_int64_t)ms) < 0, ERR_IO_ERROR, 0);
return(1);
} /* OGG_seek */
/*/////////////////////////////////////////////////////////////////*/
bool OgreOggStreamSound::_stream(ALuint buffer)
{
std::vector<char> audioData;
char* data;
int section = 0;
int result = 0;
// Create buffer
data = OGRE_ALLOC_T(char, mBufferSize, Ogre::MEMCATEGORY_GENERAL);
memset(data, 0, mBufferSize);
// Read only what was asked for
while( !mStreamEOF && (static_cast<int>(audioData.size()) < mBufferSize) )
{
int bytes = 0;
// Read up to a buffer's worth of data
bytes = ov_read(&mOggStream, data, static_cast<int>(mBufferSize), 0, 2, 1, §ion);
// EOF check
if (bytes == 0)
{
// If set to loop wrap to start of stream
if ( mLoop && mSeekable )
{
if ( ov_time_seek(&mOggStream, 0 + mLoopOffset)!= 0 )
{
Ogre::LogManager::getSingleton().logMessage("***--- OgreOggStream::_stream() - ERROR looping stream, ogg file NOT seekable!");
break;
}
}
else
{
mStreamEOF=true;
// Don't loop - finish.
break;
}
}
// Append to end of buffer
audioData.insert(audioData.end(), data, data + bytes);
// Keep track of read data
result+=bytes;
}
// EOF
if(result == 0)
{
OGRE_FREE(data, Ogre::MEMCATEGORY_GENERAL);
return false;
}
alGetError();
// Copy buffer data
alBufferData(buffer, mFormat, &audioData[0], static_cast<ALsizei>(audioData.size()), mVorbisInfo->rate);
// Cleanup
OGRE_FREE(data, Ogre::MEMCATEGORY_GENERAL);
return true;
}
int AudioStreamPlaybackOGGVorbis::mix(int16_t* p_bufer,int p_frames) {
if (!playing)
return 0;
int total=p_frames;
while (true) {
int todo = p_frames;
if (todo==0 || todo<MIN_MIX) {
break;
}
//printf("to mix %i - mix me %i bytes\n",to_mix,to_mix*stream_channels*sizeof(int16_t));
#ifdef BIG_ENDIAN_ENABLED
long ret=ov_read(&vf,(char*)p_bufer,todo*stream_channels*sizeof(int16_t), 1, 2, 1, ¤t_section);
#else
long ret=ov_read(&vf,(char*)p_bufer,todo*stream_channels*sizeof(int16_t), 0, 2, 1, ¤t_section);
#endif
if (ret<0) {
playing = false;
ERR_EXPLAIN("Error reading OGG Vorbis File: "+file);
ERR_BREAK(ret<0);
} else if (ret==0) { // end of song, reload?
ov_clear(&vf);
_close_file();
if (!has_loop()) {
playing=false;
repeats=1;
break;
}
f=FileAccess::open(file,FileAccess::READ);
int errv = ov_open_callbacks(f,&vf,NULL,0,_ov_callbacks);
if (errv!=0) {
playing=false;
break;; // :(
}
if (loop_restart_time) {
bool ok = ov_time_seek(&vf,loop_restart_time)==0;
if (!ok) {
playing=false;
//ERR_EXPLAIN("loop restart time rejected");
ERR_PRINT("loop restart time rejected")
}
frames_mixed=stream_srate*loop_restart_time;
} else {
//-----------------------------------------------------------------------------
void MusicOggStream::update()
{
if (m_pausedMusic || m_soundSource == ALuint(-1))
{
// nothing todo
return;
}
int processed= 0;
bool active= true;
alGetSourcei(m_soundSource, AL_BUFFERS_PROCESSED, &processed);
while(processed--)
{
ALuint buffer;
alSourceUnqueueBuffers(m_soundSource, 1, &buffer);
if(!check("alSourceUnqueueBuffers")) return;
active = streamIntoBuffer(buffer);
if(!active)
{
// no more data. Seek to beginning (causes the sound to loop)
ov_time_seek(&m_oggStream, 0);
active = streamIntoBuffer(buffer);//now there really should be data
}
alSourceQueueBuffers(m_soundSource, 1, &buffer);
if (!check("alSourceQueueBuffers")) return;
}
if (active)
{
// For debugging
SFXManager::checkError("before source state");
// we have data, so we should be playing...
ALenum state;
alGetSourcei(m_soundSource, AL_SOURCE_STATE, &state);
if (state != AL_PLAYING)
{
// Prevent flooding
static int count = 0;
count++;
if (count<10)
Log::warn("MusicOgg", "Music not playing when it should be. "
"Source state: %d", state);
alGetSourcei(m_soundSource, AL_BUFFERS_PROCESSED, &processed);
alSourcePlay(m_soundSource);
}
}
else
{
Log::warn("MusicOgg", "Attempt to stream music into buffer failed "
"twice in a row.");
}
} // update
void alogg_seek_abs_msecs_ogg_ul(ALOGG_OGG *ogg, unsigned long msec) {
/* convert msec to pcm sample position */
double s = msec;
s /= 1000;
ov_time_seek(&(ogg->vf), s);
if (ogg->time_stretch)
rubberband_reset(ogg->time_stretch_state);
}
/* seek in file */
static void oggread_seek(t_oggread *x, t_floatarg f)
{
if(x->x_fd > 0)
if(ov_time_seek(&x->x_ov, f) < 0)
{
post("oggread~: could not set playing position to %g seconds", f);
}
else post("oggread~: playing position set to %g seconds", f);
}
double AudioStream_Ogg::setPosition(const float &inFloat)
{
if (!mSuspend)
{
double seek = inFloat * 0.001;
ov_time_seek(oggStream, seek);
}
return inFloat;
}
void SeekVorbisStream(MFAudioStream *pStream, float seconds)
{
MFVorbisStream *pVS = (MFVorbisStream*)pStream->pStreamData;
#if defined(VORBIS_TREMOR)
ov_pcm_seek(&pVS->vorbisFile, (ogg_int64_t)(seconds*(float)pVS->pInfo->rate));
#else
ov_time_seek(&pVS->vorbisFile, seconds);
#endif
}
int64_t Seek(void* context, int64_t time)
{
VorbisContext* ctx = (VorbisContext*)context;
if (ov_time_seek(&ctx->vorbisfile, ctx->timeoffset+(double)(time/1000.0f))!=0)
return 0;
return time;
}
ALsizei
AudioManager::Player::FillBuffer()
{
ALsizei read = 0;
if(m_StreamFinished)
{
return read;
}
char *&buffer = AudioManager::getSingleton().m_Buffer;
bool finished = false;
do
{
long result = ov_read(&m_VorbisFile, buffer + read,
m_ChannelBufferSize - read, 0, 2, 1,
&m_VorbisSection);
switch(result)
{
// error
case OV_HOLE:
case OV_EBADLINK:
case OV_EINVAL:
{
finished = true;
}
break;
// end of stream
case 0:
{
// if there isn't loop point or can't seek
if(m_Loop < 0.0f || ov_time_seek(&m_VorbisFile, m_Loop))
{
finished = true;
}
}
break;
// readed "result" bytes
default:
{
read += result;
if(read == m_ChannelBufferSize)
{
finished = true;
}
}
}
}
while(finished == false);
return read;
}
JNIEXPORT jint JNICALL Java_com_badlogic_gdx_audio_io_VorbisDecoder_timeSeek(JNIEnv* env, jclass clazz, jlong handle, jfloat time) {
//@line:225
OggFile* file = (OggFile*)handle;
return ov_time_seek (file->ogg, (ogg_int64_t)(time * 1000.f));
}
void QOggSimplePlayer::internalStop()
{
needPlay=false;
if(output==NULL)
return;
output->stop();
buffer.clearData();
current_section=0;
ov_time_seek(&vf,0);
}
static bool ogg_stream_seek(ALLEGRO_AUDIO_STREAM *stream, double time)
{
AL_OV_DATA *extra = (AL_OV_DATA *) stream->extra;
if (time >= extra->loop_end)
return false;
#if !defined(ALLEGRO_GP2XWIZ) && !defined(ALLEGRO_IPHONE)
return (ov_time_seek_lap(extra->vf, time) != -1);
#else
return ov_time_seek(extra->vf, time*1000) != -1;
#endif
}
int OggDecoder::Rewind()
{
if(!file_fd)
return -1;
int ret = ov_time_seek(&ogg_file, 0);
CurPos = 0;
EndOfFile = false;
return ret;
}
