void UOpenALAudioSubsystem::RegisterMusic( UMusic* Music )
{
guard(UOpenALAudioSubsystem::RegisterMusic);
checkSlow(Music);
if( !Music->Handle )
{
// Set the handle to avoid reentrance.
Music->Handle = (void*)-1;
// Load the data.
Music->Data.Load();
debugf( NAME_DevMusic, TEXT("Register music: %s (%i)"), Music->GetPathName(), Music->Data.Num() );
check(Music->Data.Num()>0);
// Load the module.
MREADER* Reader = BuildMikModMemoryReader( &Music->Data(0), Music->Data.Num() );
MODULE* Module = Player_LoadGeneric( Reader, 64, 0 );
DestroyMikModMemoryReader( Reader );
if( Module == NULL )
appErrorf(
TEXT("Couldn't load music '%s': %s"),
Music->GetPathName(), MikMod_strerror( MikMod_errno )
);
Music->Handle = Module;
// Enable looping and wrapping.
Module->loop = Module->wrap = 1;
// Unload the data.
Music->Data.Unload();
}
unguard;
}
static void
gst_mikmod_loop (GstElement * element)
{
GstMikMod *mikmod;
GstBuffer *buffer_in;
g_return_if_fail (element != NULL);
g_return_if_fail (GST_IS_MIKMOD (element));
mikmod = GST_MIKMOD (element);
srcpad = mikmod->srcpad;
mikmod->Buffer = NULL;
if (!mikmod->initialized) {
while ((buffer_in = GST_BUFFER (gst_pad_pull (mikmod->sinkpad)))) {
if (GST_IS_EVENT (buffer_in)) {
GstEvent *event = GST_EVENT (buffer_in);
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS)
break;
} else {
if (mikmod->Buffer) {
mikmod->Buffer = gst_buffer_append (mikmod->Buffer, buffer_in);
} else {
mikmod->Buffer = buffer_in;
}
}
}
if (!GST_PAD_CAPS (mikmod->srcpad)) {
if (GST_PAD_LINK_SUCCESSFUL (gst_pad_renegotiate (mikmod->srcpad))) {
GST_ELEMENT_ERROR (mikmod, CORE, NEGOTIATION, (NULL), (NULL));
return;
}
}
MikMod_RegisterDriver (&drv_gst);
MikMod_RegisterAllLoaders ();
MikMod_Init ("");
reader = GST_READER_new (mikmod);
module = Player_LoadGeneric (reader, 64, 0);
gst_buffer_unref (mikmod->Buffer);
if (!Player_Active ())
Player_Start (module);
mikmod->initialized = TRUE;
}
if (Player_Active ()) {
timestamp = (module->sngtime / 1024.0) * GST_SECOND;
drv_gst.Update ();
} else {
gst_element_set_eos (GST_ELEMENT (mikmod));
gst_pad_push (mikmod->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
}
}
/* Loads a module given a file pointer.
File is loaded from the current file seek position. */
MIKMODAPI MODULE* Player_LoadFP(FILE* fp,int maxchan,BOOL curious)
{
MODULE* result=NULL;
struct MREADER* reader=_mm_new_file_reader (fp);
if (reader) {
result=Player_LoadGeneric(reader,maxchan,curious);
_mm_delete_file_reader(reader);
}
return result;
}
MIKMODAPI MODULE* Player_LoadMem(const char *buffer,int len,int maxchan,BOOL curious)
{
MODULE* result=NULL;
MREADER* reader;
if ((reader=_mm_new_mem_reader(buffer, len))) {
result=Player_LoadGeneric(reader,maxchan,curious);
_mm_delete_mem_reader(reader);
}
return result;
}
/* Open a module via an SDL_rwop. The loader will initialize the specified
song-player 'player'. */
MODULE* Player_LoadRW(SDL_RWops *rw,int maxchan,BOOL curious)
{
MODULE* result=NULL;
struct MREADER* reader=_mm_new_rwops_reader (rw);
if (reader) {
result=Player_LoadGeneric(reader,maxchan,curious);
_mm_delete_rwops_reader(reader);
}
return result;
}
static MODULE *MikMod_LoadSongRW(SDL_RWops *rw, int maxchan)
{
struct LMM_MREADER lmmmr={
{ LMM_Seek, LMM_Tell, LMM_Read, LMM_Get, LMM_Eof },
0, 0, rw
};
lmmmr.offset = SDL_RWtell(rw);
SDL_RWseek(rw, 0, SEEK_END);
lmmmr.eof = SDL_RWtell(rw);
SDL_RWseek(rw, lmmmr.offset, SEEK_SET);
return Player_LoadGeneric((MREADER *)&lmmmr, maxchan, 0);
}
static bool
moda_Open (THIS_PTR, uio_DirHandle *dir, const char *filename)
{
TFB_ModSoundDecoder* moda = (TFB_ModSoundDecoder*) This;
uio_Stream *fp;
MREADER* reader;
MODULE* mod;
fp = uio_fopen (dir, filename, "rb");
if (!fp)
{
moda->last_error = errno;
return false;
}
reader = moda_new_uioReader (fp);
if (!reader)
{
moda->last_error = -1;
uio_fclose (fp);
return false;
}
mod = Player_LoadGeneric (reader, 8, 0);
// can already dispose of reader and fileh
moda_delete_uioReader (reader);
uio_fclose (fp);
if (!mod)
{
log_add (log_Warning, "moda_Open(): could not load %s", filename);
return false;
}
moda->module = mod;
mod->extspd = 1;
mod->panflag = 1;
mod->wrap = 0;
mod->loop = 1;
This->format = moda_formats->stereo16;
This->frequency = md_mixfreq;
This->length = 0; // FIXME way to obtain this from mikmod?
moda->last_error = 0;
return true;
}
MIKMODAPI extern MODULE* Player_LoadMemory(const void* buffer, size_t size, int maxchan, BOOL curious)
{
MODULE* module = 0;
MMEMORYREADER* reader=(MMEMORYREADER*)malloc(sizeof(MMEMORYREADER));
if (reader) {
reader->core.Eof = &MemoryReader_Eof;
reader->core.Read = &MemoryReader_Read;
reader->core.Get = &MemoryReader_Get;
reader->core.Seek = &MemoryReader_Seek;
reader->core.Tell = &MemoryReader_Tell;
reader->buffer = (const UBYTE*)buffer;
reader->size = size;
module = Player_LoadGeneric((MREADER*)reader, maxchan, curious);
free(reader);
}
return module;
}
/* SDL_RWops compatibility */
Mix_Music *Mix_LoadMUS_RW(SDL_RWops *rw)
{
//Sanity check: only MOD!
if (detect_music_type(rw) != MUS_MOD){
printf("Error: format not supported.\n");
return NULL;
}
MODULE *module;
struct MREADER* reader = _mm_new_rwops_reader (rw);
if (reader) {
module = Player_LoadGeneric(reader,64,0);
if(reader) free(reader);
return (Mix_Music *) module;
}
else
{
printf("Could not load module, reason: %s\n", MikMod_strerror(MikMod_errno));
}
return NULL;
}
static qboolean S_MIKMOD_CodecOpenStream (snd_stream_t *stream)
{
mik_priv_t *priv;
stream->priv = Z_Malloc(sizeof(mik_priv_t));
priv = (mik_priv_t *) stream->priv;
priv->reader.Seek = MIK_Seek;
priv->reader.Tell = MIK_Tell;
priv->reader.Read = MIK_Read;
priv->reader.Get = MIK_Get;
priv->reader.Eof = MIK_Eof;
priv->fh = &stream->fh;
priv->module = Player_LoadGeneric((MREADER *)stream->priv, 64, 0);
if (!priv->module)
{
Con_DPrintf("Could not load module: %s\n", MikMod_strerror(MikMod_errno));
Z_Free(stream->priv);
return false;
}
/* keep default values of fadeout (0: don't fade out volume during when last
* position of the module is being played), extspd (1: do process Protracker
* extended speed effect), panflag (1: do process panning effects), wrap (0:
* don't wrap to restart position when module is finished) are OK with us as
* set internally by libmikmod::Player_Init(). */
/* just change the loop setting to 0, i.e. don't process in-module loops: */
priv->module->loop = 0;
Player_Start(priv->module);
stream->info.rate = md_mixfreq;
stream->info.bits = (md_mode & DMODE_16BITS)? 16: 8;
stream->info.width = stream->info.bits / 8;
stream->info.channels = (md_mode & DMODE_STEREO)? 2 : 1;
/* Con_DPrintf("Playing %s (%d chn)\n", priv->module->songname, priv->module->numchn);*/
return true;
}
MOD_MUSIC_MODULE *MusicMod_LoadSongRW(SDL_RWops *rw, int maxchan)
{
LMM_MF_READER lmmmr =
{
LMM_Seek,
LMM_Tell,
LMM_Read,
LMM_Get,
LMM_Eof,
0,
0,
0/*rw*/
};
lmmmr.offset = SDL_RWtell(rw);
SDL_RWseek(rw, 0, SEEK_END);
lmmmr.eof = SDL_RWtell(rw);
SDL_RWseek(rw, lmmmr.offset, SEEK_SET);
lmmmr.rw = rw;
//
MOD_MUSIC_MODULE *m;
m = Player_LoadGeneric((MF_READER*)&lmmmr, maxchan, 0);
return (m);
}
/**
** Load MikMod.
**
** @param name Filename of the module.
** @param flags Unused.
**
** @return Returns the loaded sample.
*/
CSample *LoadMikMod(const char *name, int flags)
{
CSample *sample;
MikModData *data;
MODULE *module;
CFile *f;
char s[256];
static int registered = 0;
md_mode |= DMODE_STEREO | DMODE_INTERP | DMODE_SURROUND | DMODE_HQMIXER;
MikMod_RegisterDriver(&drv_nos);
if (!registered) {
MikMod_RegisterAllLoaders();
registered = 1;
}
strcpy_s(s, sizeof(s), name);
f = new CFile;
if (f->open(name, CL_OPEN_READ) == -1) {
delete f;
return NULL;
}
CurrentFile = f;
MikMod_Init("");
module = Player_LoadGeneric(&MReader, 64, 0);
if (!module) {
MikMod_Exit();
f->close();
delete f;
return NULL;
}
if (flags & PlayAudioStream) {
sample = new CSampleMikModStream;
data = &((CSampleMikModStream *)sample)->Data;
} else {
sample = new CSampleMikMod;
data = &((CSampleMikMod *)sample)->Data;
}
data->MikModFile = f;
data->MikModModule = module;
sample->Channels = 2;
sample->SampleSize = 16;
sample->Frequency = 44100;
sample->Pos = 0;
if (flags & PlayAudioStream) {
sample->Len = 0;
sample->Buffer = new unsigned char[SOUND_BUFFER_SIZE];
Player_Start(data->MikModModule);
} else {
int read;
int pos;
// FIXME: need to find the correct length
sample->Len = 55000000;
sample->Buffer = new unsigned char[sample->Len];
pos = 0;
Player_Start(data->MikModModule);
while (Player_Active()) {
read = VC_WriteBytes((SBYTE *)sample->Buffer + pos,
sample->Len - pos);
pos += read;
}
Player_Stop();
Player_Free(data->MikModModule);
MikMod_Exit();
data->MikModFile->close();
delete data->MikModFile;
}
return sample;
}
