forked from 0ad/0ad
266 lines
4.5 KiB
C++
Executable File
266 lines
4.5 KiB
C++
Executable File
#include "precompiled.h"
|
|
|
|
#include "CMusicPlayer.h"
|
|
#include <CLogger.h>
|
|
|
|
#include <sstream>
|
|
#include <list>
|
|
|
|
#define LOG_CATEGORY "audio"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//Class implementation
|
|
CMusicPlayer::CMusicPlayer(void)
|
|
{
|
|
/*
|
|
oal_Init();
|
|
|
|
if(!alIsExtensionPresent((ALubyte*)"AL_EXT_vorbis"))
|
|
debug_warn("no OpenAL ogg extension");
|
|
*/
|
|
is_open = false;
|
|
}
|
|
|
|
CMusicPlayer::~CMusicPlayer(void)
|
|
{
|
|
release();
|
|
}
|
|
|
|
void CMusicPlayer::open(char *filename)
|
|
{
|
|
// If a new file is opened while another is already in memory,
|
|
// close the old one first.
|
|
if (is_open)
|
|
release();
|
|
|
|
/*/*
|
|
void* p;
|
|
size_t sizeOfFile;
|
|
if(vfs_load(filename, p, sizeOfFile) <= 0)
|
|
{
|
|
LOG(ERROR, LOG_CATEGORY, "CMusicPlayer::open(): vfs_load for %s failed!\n", filename);
|
|
return;
|
|
}
|
|
else
|
|
LOG(NORMAL, LOG_CATEGORY, "CMusicPlayer::open(): file %s loaded successfully\n", filename);
|
|
memFile.dataPtr = (char*)p;
|
|
memFile.dataRead = 0;
|
|
memFile.dataSize = sizeOfFile;
|
|
*/
|
|
/*
|
|
hf = vfs_open(filename);
|
|
|
|
for(int i = 0; i < NUM_BUFS; i++)
|
|
{
|
|
alGenBuffers(1, &bufs[i].al_buffer);
|
|
bufs[i].raw_buf = mem_alloc(RAW_BUF_SIZE, 4096);
|
|
}
|
|
|
|
alGenSources(1, &source);
|
|
check();
|
|
|
|
alSource3f(source,AL_POSITION,0.0,0.0,0.0);
|
|
alSource3f(source,AL_VELOCITY,0.0,0.0,0.0);
|
|
alSource3f(source,AL_DIRECTION,0.0,0.0,0.0);
|
|
alSourcef(source,AL_ROLLOFF_FACTOR,0.0);
|
|
alSourcei(source,AL_SOURCE_RELATIVE,AL_TRUE);
|
|
check();
|
|
*/
|
|
is_open = true;
|
|
}
|
|
|
|
|
|
void CMusicPlayer::release()
|
|
{
|
|
/*
|
|
if(!is_open)
|
|
return;
|
|
is_open = false;
|
|
|
|
alSourceStop(source);
|
|
empty();
|
|
|
|
alDeleteSources(1,&source);
|
|
source = 0;
|
|
|
|
|
|
for(int i = 0; i < NUM_BUFS; i++)
|
|
{
|
|
alDeleteBuffers(1, &bufs[i].al_buffer);
|
|
bufs[i].al_buffer = 0;
|
|
mem_free(bufs[i].raw_buf);
|
|
}
|
|
|
|
check();
|
|
|
|
mem_free(memFile.dataPtr);
|
|
*/
|
|
}
|
|
|
|
|
|
bool CMusicPlayer::isPlaying()
|
|
{
|
|
return false;
|
|
}
|
|
/*
|
|
// guard against OpenAL using source when it's not initialized
|
|
if(!is_open)
|
|
return false;
|
|
|
|
ALenum state = 0;
|
|
alGetSourcei(source,AL_SOURCE_STATE,&state);
|
|
check();
|
|
return (state == AL_PLAYING);
|
|
}
|
|
/*
|
|
|
|
bool CMusicPlayer::issue(int slot_idx)
|
|
{
|
|
Buf* buf = &bufs[slot_idx];
|
|
|
|
ssize_t left = (ssize_t)memFile.dataSize - (ssize_t)memFile.dataRead;
|
|
ssize_t size = MIN(64*KB, left);
|
|
assert(size >= 0);
|
|
void* data = memFile.dataPtr;
|
|
data = (char*)data + memFile.dataRead;
|
|
memFile.dataRead += size;
|
|
|
|
alBufferData(buf->al_buffer, AL_FORMAT_VORBIS_EXT, data, (ALsizei)size, 1);
|
|
alSourceQueueBuffers(source, 1, buf->al_buffer);
|
|
|
|
check();
|
|
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
bool CMusicPlayer::play()
|
|
{
|
|
check();
|
|
|
|
if(isPlaying())
|
|
return true;
|
|
|
|
if(!is_open)
|
|
debug_warn("play() called before open()");
|
|
/*
|
|
if(!stream(0))
|
|
return false;
|
|
if(!stream(1))
|
|
return false;
|
|
*/
|
|
//bind the 2 buffers to the source
|
|
|
|
// alSourcePlay(source);
|
|
// check();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CMusicPlayer::update()
|
|
{
|
|
if(!isPlaying())
|
|
return false;
|
|
/*
|
|
//check which buffers have already been played
|
|
int processed;
|
|
alGetSourcei(source,AL_BUFFERS_PROCESSED, &processed);
|
|
check();
|
|
|
|
// start transfers on any buffers that have completed playing
|
|
// any transfers that have completed: add the corresponding buffer
|
|
|
|
bool active = true;
|
|
|
|
while(processed-- && processed >= 0)
|
|
{
|
|
ALuint buffer;
|
|
|
|
//remove buffer from queue
|
|
alSourceUnqueueBuffers(source,1,&buffer);
|
|
check();
|
|
|
|
// to which Buf does the al_buffer belong?
|
|
int i;
|
|
for(i = 0; i < NUM_BUFS; i++)
|
|
if(bufs[i].al_buffer == buffer)
|
|
goto found;
|
|
debug_warn("al_buffer not found!");
|
|
found:
|
|
|
|
//fill buffer with new data if false is returned the there is no more data
|
|
active = stream(buffer);
|
|
|
|
//attach buffer to end of queue
|
|
alSourceQueueBuffers(source,1,&buffer);
|
|
check();
|
|
}
|
|
|
|
return active;
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
|
|
void CMusicPlayer::check()
|
|
{
|
|
/*
|
|
int error = alGetError();
|
|
|
|
if(error != AL_NO_ERROR)
|
|
{
|
|
std::string str = errorString(error);
|
|
LOG(ERROR, LOG_CATEGORY, "OpenAL error: %s\n", str.c_str());
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
void CMusicPlayer::empty()
|
|
{
|
|
/*
|
|
int queued;
|
|
alGetSourcei(source,AL_BUFFERS_QUEUED,&queued);
|
|
|
|
while(queued-- > 0)
|
|
{
|
|
ALuint buffer;
|
|
|
|
alSourceUnqueueBuffers(source,1,&buffer);
|
|
check();
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string CMusicPlayer::errorString(int errorcode)
|
|
{
|
|
/*
|
|
switch(errorcode)
|
|
{
|
|
case AL_INVALID_NAME:
|
|
return "AL_INVALID_NAME";
|
|
case AL_INVALID_ENUM:
|
|
return "AL_INVALID_ENUM";
|
|
case AL_INVALID_VALUE:
|
|
return "AL_INVALID_VALUE";
|
|
case AL_INVALID_OPERATION:
|
|
return "AL_INVALID_OPERATION";
|
|
case AL_OUT_OF_MEMORY:
|
|
return "AL_OUT_OF_MEMORY";
|
|
default:
|
|
std::stringstream str;
|
|
str << "Unknown Ogg error (code "<< errorcode << ")";
|
|
return str.str();
|
|
}
|
|
*/
|
|
return "ENOSYS";
|
|
}
|