C++ ov_time_seek函数代码示例

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, &sect);

        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, &section);
           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;
    }