OggSoundFile::OggSoundFile(PHYSFS_file* file_, double loop_begin_, double loop_at_) : file(), vorbis_file(), loop_begin(), loop_at(), normal_buffer_loop() { this->file = file_; ov_callbacks callbacks = { cb_read, cb_seek, cb_close, cb_tell }; ov_open_callbacks(file, &vorbis_file, 0, 0, callbacks); vorbis_info* vi = ov_info(&vorbis_file, -1); channels = vi->channels; rate = vi->rate; bits_per_sample = 16; size = static_cast<size_t> (ov_pcm_total(&vorbis_file, -1) * 2); double samples_begin = loop_begin_ * rate; double sample_loop = loop_at_ * rate; this->loop_begin = (ogg_int64_t) samples_begin; if(loop_begin_ < 0) { this->loop_at = (ogg_int64_t) -1; } else { this->loop_at = (ogg_int64_t) sample_loop; } }
//----------------------------------------------------------------------------// OggStream::OggStream(const Ogre::String& name, SoundSource* source, int bufferCount) : StreamingBuffer(name, source, bufferCount) { ov_callbacks vorbisCallbacks; // read file to memory mStream = Ogre::ResourceGroupManager::getSingleton().openResource(name); // open ogg stream vorbisCallbacks.read_func = OggBuffer::vorbisRead; vorbisCallbacks.close_func = OggBuffer::vorbisClose; vorbisCallbacks.seek_func = OggBuffer::vorbisSeek; vorbisCallbacks.tell_func = OggBuffer::vorbisTell; if (ov_open_callbacks(&mStream, &mOggStream, nullptr, 0, vorbisCallbacks) < 0) { throw Ogre::Exception(1, "Could not open Ogg stream.",__FUNCTION__); } mVorbisInfo = ov_info(&mOggStream, -1); mVorbisComment = ov_comment(&mOggStream, -1); mChannels = mVorbisInfo->channels; mFrequency = mVorbisInfo->rate; mDuration = float(ov_time_total(&mOggStream, -1)); mBits = 16; if(mChannels == 1) mFormat = AL_FORMAT_MONO16; else mFormat = AL_FORMAT_STEREO16; mSize = mDuration * float(mBits * mFrequency * mChannels) / 8.0f; }
RageSoundReader_FileReader::OpenResult RageSoundReader_Vorbisfile::Open( RageFileBasic *pFile ) { m_pFile = pFile; vf = new OggVorbis_File; memset( vf, 0, sizeof(*vf) ); ov_callbacks callbacks; callbacks.read_func = OggRageFile_read_func; callbacks.seek_func = OggRageFile_seek_func; callbacks.close_func = OggRageFile_close_func; callbacks.tell_func = OggRageFile_tell_func; int ret = ov_open_callbacks( pFile, vf, NULL, 0, callbacks ); if( ret < 0 ) { SetError( ov_ssprintf(ret, "ov_open failed") ); delete vf; vf = NULL; switch( ret ) { case OV_ENOTVORBIS: return OPEN_UNKNOWN_FILE_FORMAT; default: return OPEN_FATAL_ERROR; } } eof = false; read_offset = (int) ov_pcm_tell(vf); vorbis_info *vi = ov_info( vf, -1 ); channels = vi->channels; return OPEN_OK; }
OggStream::OggStream(const std::string &fname) { _file = fopen(fname.c_str(), "rb"); if (_file == NULL) { perror("fopen"); throw std::runtime_error("cannot open file"); } ov_callbacks ov_cb; memset(&ov_cb, 0, sizeof(ov_cb)); ov_cb.read_func = stream_read_func; ov_cb.seek_func = stream_seek_func; ov_cb.tell_func = stream_tell_func; ov_cb.close_func = stream_close_func; int r = ov_open_callbacks(_file, &_ogg_stream, NULL, 0, ov_cb); if (r < 0) { throw std::runtime_error("ov_open_callbacks failed"); } _vorbis_info = ov_info(&_ogg_stream, -1); sample_rate = _vorbis_info->rate; //LOG_DEBUG(("open(%s) : %d", fname.c_str(), sample_rate)); format = AUDIO_S16LSB; channels = _vorbis_info->channels; //_vorbis_comment = ov_comment(&_ogg_stream, -1); assert(_vorbis_info != NULL); }
/*! * \brief Create a new OGG/Vorbis filestream and set it up for reading. * \param s File that points to on disk storage of the OGG/Vorbis data. * \return The new filestream. */ static int ogg_vorbis_open(struct ast_filestream *s) { int result; struct ogg_vorbis_desc *desc = (struct ogg_vorbis_desc *) s->_private; /* initialize private description block */ memset(desc, 0, sizeof(struct ogg_vorbis_desc)); desc->writing = 0; /* actually open file */ result = ov_open_callbacks(s->f, &desc->ov_f, NULL, 0, OV_CALLBACKS_NOCLOSE); if (result != 0) { ast_log(LOG_ERROR, "Error opening Ogg/Vorbis file stream.\n"); return -1; } /* check stream(s) type */ if (desc->ov_f.vi->channels != 1) { ast_log(LOG_ERROR, "Only monophonic OGG/Vorbis files are currently supported!\n"); ov_clear(&desc->ov_f); return -1; } if (desc->ov_f.vi->rate != DEFAULT_SAMPLE_RATE) { ast_log(LOG_ERROR, "Only 8000Hz OGG/Vorbis files are currently supported!\n"); ov_clear(&desc->ov_f); return -1; } return 0; }
VorbisDecoder::VorbisDecoder(Data * data, const std::string & ext, int bufferSize) : Decoder(data, ext, bufferSize) { // Initialize callbacks vorbisCallbacks.close_func = vorbisClose; vorbisCallbacks.seek_func = vorbisSeek; vorbisCallbacks.read_func = vorbisRead; vorbisCallbacks.tell_func = vorbisTell; // Check endianness #ifdef LOVE_BIG_ENDIAN endian = 1; #else endian = 0; #endif // Initialize OGG file oggFile.dataPtr = (char *) data->getData(); oggFile.dataSize = data->getSize(); oggFile.dataRead = 0; // Open Vorbis handle if(ov_open_callbacks(&oggFile, &handle, NULL, 0, vorbisCallbacks) < 0) throw love::Exception("Could not read Ogg bitstream"); // Get info and comments vorbisInfo = ov_info(&handle, -1); vorbisComment = ov_comment(&handle, -1); }
unsigned int OggResourceLoader::VGetLoadedResourceSize(char *rawBuffer, unsigned int rawSize){ OggVorbis_File vf; ov_callbacks oggCallbacks; OggMemoryFile *vorbisMemoryFile = new OggMemoryFile; vorbisMemoryFile->dataRead = 0; vorbisMemoryFile->dataSize = rawSize; vorbisMemoryFile->dataPtr = (unsigned char *)rawBuffer; oggCallbacks.read_func = VorbisRead; oggCallbacks.close_func = VorbisClose; oggCallbacks.seek_func = VorbisSeek; oggCallbacks.tell_func = VorbisTell; int ov_ret = ov_open_callbacks(vorbisMemoryFile, &vf, NULL, 0, oggCallbacks); //DEBUG_LOG(ov_ret >= 0); //read in vorbis vorbis_info *vi = ov_info(&vf, -1); DWORD size = 4096 * 16; DWORD pos = 0; int sec = 0; int ret = 1; DWORD bytes = (DWORD)ov_pcm_total(&vf, -1); bytes *= 2 * vi->channels; ov_clear(&vf); SafeDelete(vorbisMemoryFile); return bytes; }
static int logg_open_file_for_streaming(LOGG_Stream* s) { FILE* file; vorbis_info* vi; file = fopen(s->filename, "rb"); if (!file) { uszprintf(allegro_error, ALLEGRO_ERROR_SIZE, "Unable to open file: %s", s->filename); return 1; } if (ov_open_callbacks(file, &s->ovf, 0, 0, OV_CALLBACKS_DEFAULT) != 0) { strncpy(allegro_error, "ov_open_callbacks failed.", ALLEGRO_ERROR_SIZE); fclose(file); return 1; } vi = ov_info(&s->ovf, -1); s->bits = 16; s->stereo = vi->channels > 1 ? 1 : 0; s->freq = vi->rate; s->len = ov_pcm_total(&s->ovf, -1); return 0; }
void SourceFileImplOggVorbis::init() { CI_ASSERT( mDataSource ); 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 { 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_ASSERT( status == 0 ); } vorbis_info *info = ov_info( &mOggVorbisFile, -1 ); mSampleRate = mNativeSampleRate = info->rate; mNumChannels = mNativeNumChannels = info->channels; ogg_int64_t totalFrames = ov_pcm_total( &mOggVorbisFile, -1 ); mNumFrames = mFileNumFrames = static_cast<uint32_t>( totalFrames ); }
OggAudio* OggAudio::CreateFromMemory(const FileIdRef& fileId, MemoryData data) { ov_callbacks callbacks; callbacks.read_func = ogg_read_func; callbacks.seek_func = ogg_seek_func; callbacks.close_func = ogg_close_func; callbacks.tell_func = ogg_tell_func; OggVorbis_File vf; MemoryStream oggStream = MemoryStream::OpenRead(data); if (ov_open_callbacks(&oggStream, &vf, nullptr, 0, callbacks)) { Log::FormatError("{} does not appear to be an Ogg bitstream.", fileId.Name); return nullptr; } vorbis_info* vi = ov_info(&vf, -1); uintp sampleCount = (uintp)ov_pcm_total(&vf, -1); bool seekable = ov_seekable(&vf)!=0; uint bigEndian = !BitConverter::IsLittle(); int currentSection = 0; uintp pcmSize = sampleCount*vi->channels*sizeof(short); MemoryStream pcmSteam(pcmSize); while (true) { long readSize = ov_read(&vf, (char*)pcmSteam.MutablePtr(), (int)pcmSteam.LeftLength(), bigEndian, 2, 1, ¤tSection); if (readSize == 0) { //end of file break; } else if (readSize > 0) { pcmSteam.Seek(readSize, SeekOrigin::Current); } else { if (readSize == OV_EBADLINK) { Log::FormatError("{} Corrupt bitstream section!", fileId.Name); return nullptr; } } } auto audioData = pcmSteam.CurrentBuffer(); OggAudio* audio = new OggAudio(audioData, fileId); audio->SetSampleCount(sampleCount); audio->SetChannelCount(vi->channels); audio->SetSampleRate(vi->rate); audio->SetBitsPerSample(16); audio->SetSeekable(seekable); return audio; }
VorbisStream::VorbisStream(Common::SeekableReadStream *inStream, DisposeAfterUse::Flag dispose) : _inStream(inStream), _disposeAfterUse(dispose), _length(0, 1000), _bufferEnd(_buffer + ARRAYSIZE(_buffer)) { int res = ov_open_callbacks(inStream, &_ovFile, NULL, 0, g_stream_wrap); if (res < 0) { warning("Could not create Vorbis stream (%d)", res); _pos = _bufferEnd; return; } // Read in initial data if (!refill()) return; // Setup some header information _isStereo = ov_info(&_ovFile, -1)->channels >= 2; _rate = ov_info(&_ovFile, -1)->rate; #ifdef USE_TREMOR _length = Timestamp(ov_time_total(&_ovFile, -1), getRate()); #else _length = Timestamp(uint32(ov_time_total(&_ovFile, -1) * 1000.0), getRate()); #endif }
void OggWrapper::LoadFromMemory(char * data, int dataSize, SoundInfo * soundinfo) { oggFile_.curPtr = oggFile_.filePtr = data; oggFile_.fileSize = dataSize; ovFile_ = new OggVorbis_File; memset(ovFile_, 0, sizeof OggVorbis_File); ov_open_callbacks((void*)&oggFile_, ovFile_, nullptr, -1, callbacks_ogg); vorbis_info * vorbisinfo = ov_info(ovFile_, -1); memset(soundinfo, 0, sizeof SoundInfo); soundinfo->channels = vorbisinfo->channels; soundinfo->bitrateLower = vorbisinfo->bitrate_lower; soundinfo->bitrateUpper = vorbisinfo->bitrate_upper; soundinfo->bitrateNominal = vorbisinfo->bitrate_nominal; soundinfo->bitrateWindow = vorbisinfo->bitrate_window; soundinfo->frequency = vorbisinfo->rate; soundinfo->bpc = 16; if (ov_seekable(ovFile_) == 0) { soundinfo->seekable = false; seekable_ = false; } else { soundinfo->seekable = true; seekable_ = true; } }
void OggWrapper::LoadFromFile(FILE * file, SoundInfo * soundinfo) { ovFile_ = new OggVorbis_File; memset(ovFile_, 0, sizeof OggVorbis_File); ov_open_callbacks(file, ovFile_, nullptr, -1, OV_CALLBACKS_DEFAULT); vorbis_info * vorbisinfo = ov_info(ovFile_, -1); memset(soundinfo, 0, sizeof SoundInfo); soundinfo->channels = vorbisinfo->channels; soundinfo->bitrateLower = vorbisinfo->bitrate_lower; soundinfo->bitrateUpper = vorbisinfo->bitrate_upper; soundinfo->bitrateNominal = vorbisinfo->bitrate_nominal; soundinfo->bitrateWindow = vorbisinfo->bitrate_window; soundinfo->frequency = vorbisinfo->rate; soundinfo->bpc = 16; if (ov_seekable(ovFile_) == 0) { soundinfo->seekable = false; seekable_ = false; } else { soundinfo->seekable = true; seekable_ = true; } }
int vorbis_stream_decoder_open(decoder_t * dec, http_session_t * session) { vorbis_pdata_t * pd = (vorbis_pdata_t *)dec->pdata; file_decoder_t * fdec = dec->fdec; ov_callbacks ov_cb; ov_cb.read_func = read_vorbis_stream; ov_cb.seek_func = seek_vorbis_stream; ov_cb.close_func = close_vorbis_stream; ov_cb.tell_func = tell_vorbis_stream; if (ov_open_callbacks((void *)session, &(pd->vf), NULL, 0, ov_cb) != 0) { /* not an Ogg Vorbis stream */ return DECODER_OPEN_BADLIB; } fdec->is_stream = 1; pd->session = session; dec->pause = pause_vorbis_stream; dec->resume = resume_vorbis_stream; return vorbis_decoder_finish_open(dec); }
PCMAudio * VorbisAudioIO_loadOggVorbisData(const void * data, size_t length) { struct memreadContext readContext; ov_callbacks callbacks; OggVorbis_File file; int status; vorbis_info * info; unsigned int channelCount; unsigned int sampleRate; unsigned int sampleCount; long readResult; struct memwriteContext writeContext; char buffer[BUFFER_SIZE]; int currentSection; PCMAudio * audio; readContext = memreadContextInit(data, length); callbacks.read_func = VorbisAudioIO_memreadFunc; callbacks.seek_func = VorbisAudioIO_memseekFunc; callbacks.close_func = NULL; callbacks.tell_func = VorbisAudioIO_memtellFunc; status = ov_open_callbacks(&readContext, &file, NULL, 0, callbacks); if (status != 0) { fprintf(stderr, "Error: ov_open_callbacks returned %d\n", status); return NULL; } info = ov_info(&file, -1); if (info == NULL) { fprintf(stderr, "Error: ov_info returned NULL\n"); return NULL; } channelCount = info->channels; sampleRate = info->rate; sampleCount = ov_pcm_total(&file, -1); writeContext = memwriteContextInit(malloc(1), 0, 1, true); for (;;) { readResult = ov_read(&file, buffer, BUFFER_SIZE, OV_READ_ENDIANNESS, 2, 1, ¤tSection); if (readResult == 0) { break; } if (readResult < 0) { fprintf(stderr, "Error: ov_read returned %ld\n", readResult); break; } memwrite(&writeContext, readResult, buffer); } ov_clear(&file); if (readResult < 0) { free(writeContext.data); return NULL; } audio = PCMAudio_create(2, channelCount, sampleRate, sampleCount, writeContext.data, true); free(writeContext.data); return audio; }
void AudioSourceOJM::parseM30() { M30Header Head; size_t sizeLeft; ifile->read(reinterpret_cast<char*>(&Head), sizeof(M30Header)); std::vector<char> Buffer(Head.payload_size); sizeLeft = Head.payload_size; for (int i = 0; i < Head.sample_count; i++) { if (sizeLeft < 52) break; // wrong number of samples M30Entry Entry; ifile->read(reinterpret_cast<char*>(&Entry), sizeof(M30Entry)); sizeLeft -= sizeof(M30Entry); sizeLeft -= Entry.sample_size; int OJMIndex = Entry.ref; if (Entry.codec_code == 0) OJMIndex += 1000; else if (Entry.codec_code != 5) continue; // Unknown sample id type. std::vector<char> SampleData(Entry.sample_size); ifile->read(&SampleData[0], Entry.sample_size); if (Head.encryption_flag & 16) NamiXOR(&SampleData[0], Entry.sample_size); else if (Head.encryption_flag & 32) F412XOR(&SampleData[0], Entry.sample_size); // Sample data is done. Now the bits that are specific to raindrop.. auto NewSample = std::make_shared<SoundSample>(); SFM30 ToLoad; ToLoad.Buffer = std::move(SampleData); ToLoad.DataLength = Entry.sample_size; OggVorbis_File vf; ov_open_callbacks(&ToLoad, &vf, nullptr, 0, M30InterfaceOgg); TemporaryState.File = &vf; TemporaryState.Info = vf.vi; if (vf.vi) { TemporaryState.Enabled = OJM_OGG; NewSample->SetPitch(Speed); NewSample->Open(this); TemporaryState.Enabled = 0; } ov_clear(&vf); Arr[OJMIndex] = NewSample; } }
/* ================= S_OpenBackgroundTrack ================= */ static qboolean S_OpenBackgroundTrack (char *name, bgTrack_t *track) { OggVorbis_File *vorbisFile; vorbis_info *vorbisInfo; ov_callbacks vorbisCallbacks = {ovc_read, ovc_seek, ovc_close, ovc_tell}; #ifdef OGG_DIRECT_FILE char filename[1024]; char *path = NULL; #endif // Com_Printf("Opening background track: %s\n", name); #ifdef OGG_DIRECT_FILE do { path = FS_NextPath( path ); Com_sprintf( filename, sizeof(filename), "%s/%s", path, name ); if ( (track->file = fopen(filename, "rb")) != 0) break; } while ( path ); #else FS_FOpenFile(name, &track->file); #endif if (!track->file) { Com_Printf("S_OpenBackgroundTrack: couldn't find %s\n", name); return false; } track->vorbisFile = vorbisFile = Z_Malloc(sizeof(OggVorbis_File)); // Com_Printf("Opening callbacks for background track\n"); // bombs out here- ovc_read, FS_Read 0 bytes error if (ov_open_callbacks(track, vorbisFile, NULL, 0, vorbisCallbacks) < 0) { Com_Printf("S_OpenBackgroundTrack: couldn't open OGG stream (%s)\n", name); return false; } // Com_Printf("Getting info for background track\n"); vorbisInfo = ov_info(vorbisFile, -1); if (vorbisInfo->channels != 1 && vorbisInfo->channels != 2) { Com_Printf("S_OpenBackgroundTrack: only mono and stereo OGG files supported (%s)\n", name); return false; } track->start = ov_raw_tell(vorbisFile); track->rate = vorbisInfo->rate; track->width = 2; track->channels = vorbisInfo->channels; // Knightmare added track->format = (vorbisInfo->channels == 2) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; // Com_Printf("Vorbis info: frequency: %i channels: %i bitrate: %i\n", // vorbisInfo->rate, vorbisInfo->channels, vorbisInfo->bitrate_nominal); return true; }
int main(){ OggVorbis_File vf; int eof=0; int current_section; #ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */ /* Beware the evil ifdef. We avoid these where we can, but this one we cannot. Don't add any more, you'll probably go to hell if you do. */ _setmode( _fileno( stdin ), _O_BINARY ); _setmode( _fileno( stdout ), _O_BINARY ); #endif if(ov_open_callbacks(stdin, &vf, NULL, 0, OV_CALLBACKS_NOCLOSE) < 0) { fprintf(stderr,"Input does not appear to be an Ogg bitstream.\n"); exit(1); } /* Throw the comments plus a few lines about the bitstream we're decoding */ { char **ptr=ov_comment(&vf,-1)->user_comments; vorbis_info *vi=ov_info(&vf,-1); while(*ptr){ fprintf(stderr,"%s\n",*ptr); ++ptr; } fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate); fprintf(stderr,"\nDecoded length: %ld samples\n", (long)ov_pcm_total(&vf,-1)); fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor); } while(!eof){ long ret=ov_read(&vf,pcmout,sizeof(pcmout),0,2,1,¤t_section); if (ret == 0) { /* EOF */ eof=1; } else if (ret < 0) { if(ret==OV_EBADLINK){ fprintf(stderr,"Corrupt bitstream section! Exiting.\n"); exit(1); } /* some other error in the stream. Not a problem, just reporting it in case we (the app) cares. In this case, we don't. */ } else { /* we don't bother dealing with sample rate changes, etc, but you'll have to*/ fwrite(pcmout,1,ret,stdout); } } /* cleanup */ ov_clear(&vf); fprintf(stderr,"Done.\n"); return(0); }
static qboolean S_VORBIS_CodecOpenStream (snd_stream_t *stream) { OggVorbis_File *ovFile; vorbis_info *ovf_info; long numstreams; int res; ovFile = (OggVorbis_File *) Z_Malloc(sizeof(OggVorbis_File), Z_MAINZONE); stream->priv = ovFile; res = ov_open_callbacks(&stream->fh, ovFile, NULL, 0, ovc_qfs); if (res != 0) { Con_Printf("%s is not a valid Ogg Vorbis file (error %i).\n", stream->name, res); goto _fail; } if (!ov_seekable(ovFile)) { Con_Printf("Stream %s not seekable.\n", stream->name); goto _fail; } ovf_info = ov_info(ovFile, 0); if (!ovf_info) { Con_Printf("Unable to get stream info for %s.\n", stream->name); goto _fail; } /* FIXME: handle section changes */ numstreams = ov_streams(ovFile); if (numstreams != 1) { Con_Printf("More than one (%ld) stream in %s.\n", numstreams, stream->name); goto _fail; } if (ovf_info->channels != 1 && ovf_info->channels != 2) { Con_Printf("Unsupported number of channels %d in %s\n", ovf_info->channels, stream->name); goto _fail; } stream->info.rate = ovf_info->rate; stream->info.channels = ovf_info->channels; stream->info.bits = VORBIS_SAMPLEBITS; stream->info.width = VORBIS_SAMPLEWIDTH; return true; _fail: if (res == 0) ov_clear(ovFile); Z_Free(ovFile); return false; }
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 {
bool OggStream::open(const MessageAudio &ma) { mCallbacks.read_func = MessageAudio_read; mCallbacks.close_func = MessageAudio_close; mCallbacks.seek_func = MessageAudio_seek; mCallbacks.tell_func = MessageAudio_tell; currentAudio = ma; int audioid = ma.getAudioid(); int error = ov_open_callbacks(¤tAudio, &mStream, NULL, 0, mCallbacks); ostringstream oss; oss << "MessageAudio:" << audioid; mStreamInfo = oss.str(); if(error) { switch(error) { case OV_EREAD: LOG4CXX_ERROR(narratorOsLog, "MessageAudio id: " << audioid << " A read from media returned an error"); break; case OV_ENOTVORBIS: LOG4CXX_ERROR(narratorOsLog, "MessageAudio id: " << audioid << " Bitstream is not Vorbis data"); break; case OV_EVERSION: LOG4CXX_ERROR(narratorOsLog, "MessageAudio id: " << audioid << " Vorbis version mismatch"); break; case OV_EBADHEADER: LOG4CXX_ERROR(narratorOsLog, "MessageAudio id: " << audioid << " Invalid Vorbis bitstream header"); break; case OV_EFAULT: LOG4CXX_ERROR(narratorOsLog, "MessageAudio id: " << audioid<< " Internal logic fault"); break; default: LOG4CXX_ERROR(narratorOsLog, "MessageAudio id: " << audioid << " 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; }
CAudioDecoderVorbis::CAudioDecoderVorbis(NLMISC::IStream *stream, bool loop) : _Stream(stream), _Loop(loop), _IsMusicEnded(false), _StreamSize(0) { _StreamOffset = stream->getPos(); stream->seek(0, NLMISC::IStream::end); _StreamSize = stream->getPos(); stream->seek(_StreamOffset, NLMISC::IStream::begin); ov_open_callbacks(this, &_OggVorbisFile, NULL, 0, OV_CALLBACKS_NLMISC_STREAM); }
/** * \brief OGG read Callback. * \param[in] name File name to open. * \param[in/out] Music track data structure. * \return False on error, otherwise true. * \note */ PRIVATE _boolean Sound_OpenBGTrack( const char *name, musicTrack_t *track ) { OggVorbis_File *vorbisFile; vorbis_info *vorbisInfo; ov_callbacks vorbisCallbacks = {ovc_read, ovc_seek, ovc_close, ovc_tell}; int ret; track->hFile = FS_OpenFile( name, 0 ); if( ! track->hFile ) { return false; } track->vorbisFile = vorbisFile = Z_Malloc( sizeof( OggVorbis_File ) ); if( (ret = ov_open_callbacks( track, vorbisFile, NULL, 0, vorbisCallbacks )) < 0 ) { switch( ret ) { case OV_EREAD: Com_DPrintf( "A read from media returned an error.(%s)\n", name ); break; case OV_ENOTVORBIS: Com_DPrintf( "Bitstream is not Vorbis data.(%s)\n", name ); break; case OV_EVERSION: Com_DPrintf( "Vorbis version mismatch.(%s)\n", name ); break; case OV_EBADHEADER: Com_DPrintf( "Invalid Vorbis bitstream header.(%s)\n", name ); break; case OV_EFAULT: Com_DPrintf( "Internal logic fault; indicates a bug or heap/stack corruption.(%s)\n", name ); break; } Com_DPrintf( "Could not open OGG stream (%s)\n", name ); return false; } vorbisInfo = ov_info( vorbisFile, -1 ); if( vorbisInfo->channels != 1 && vorbisInfo->channels != 2 ) { Com_DPrintf( "Only mono and stereo OGG files supported (%s)\n", name ); return false; } track->start = ov_raw_tell( vorbisFile ); track->rate = vorbisInfo->rate; track->format = (vorbisInfo->channels == 2) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; return true; }
static void *decompress_vorbis(const BYTE *data, const DWORD size, ALsizei *decompressed_size, ALenum *fmt, ALsizei *freq) { #ifdef __POWERPC__ const int bigendian = 1; #else const int bigendian = 0; #endif oggcbdata cbdata = { data, size, 0 }; OggVorbis_File vf; memset(&vf, '\0', sizeof (vf)); if (ov_open_callbacks(&cbdata, &vf, NULL, 0, oggcb) == 0) { int bitstream = 0; vorbis_info *info = ov_info(&vf, -1); *decompressed_size = 0; *fmt = (info->channels == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16; *freq = info->rate; if ((info->channels != 1) && (info->channels != 2)) { ov_clear(&vf); return NULL; } char buf[1024 * 16]; long rc = 0; size_t allocated = 64 * 1024; BYTE *retval = (ALubyte *) malloc(allocated); while ( (rc = ov_read(&vf, buf, sizeof (buf), bigendian, 2, 1, &bitstream)) != 0 ) { if (rc > 0) { *decompressed_size += rc; if (*decompressed_size >= allocated) { allocated *= 2; ALubyte *tmp = (ALubyte *) realloc(retval, allocated); if (tmp == NULL) { free(retval); retval = NULL; break; } retval = tmp; } memcpy(retval + (*decompressed_size - rc), buf, rc); } } ov_clear(&vf); return retval; } return NULL; }
void CSoundRender_Target::attach() { VERIFY (0==wave); VERIFY (pEmitter); ov_callbacks ovc= {ov_read_func,ov_seek_func,ov_close_func,ov_tell_func}; wave = FS.r_open (pEmitter->source->pname.c_str()); R_ASSERT3 (wave&&wave->length(),"Can't open wave file:",pEmitter->source->pname.c_str()); ov_open_callbacks(wave,&ovf,NULL,0,ovc); VERIFY (0!=wave); }
int Cogg_file::get_c_channels() { OggVorbis_File vf; seek(0); if (ov_open_callbacks(this, &vf, NULL, 0, cbs) < 0) return 0; int r = ov_info(&vf, -1)->channels; ov_clear(&vf); return r; }
int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){ ov_callbacks callbacks = { (size_t (*)(void *, size_t, size_t, void *)) fread, (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap, (int (*)(void *)) fclose, (long (*)(void *)) ftell }; return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks); }
int Cogg_file::get_c_samples() { OggVorbis_File vf; seek(0); if (ov_open_callbacks(this, &vf, NULL, 0, cbs) < 0) return 0; int r = ov_pcm_total(&vf, -1); ov_clear(&vf); return r; }
int Cogg_file::get_samplerate() { OggVorbis_File vf; seek(0); if (ov_open_callbacks(this, &vf, NULL, 0, cbs) < 0) return 0; int r = ov_info(&vf, -1)->rate; ov_clear(&vf); return r; }