/** Start a compressed sound channel */
static glui32 play_compressed(schanid_t chan, char *ext)
{
SDL_LockAudio();
chan->status = CHANNEL_SOUND;
chan->buffered = 1;
chan->sdl_channel = Mix_GroupAvailable(FREE);
Mix_GroupChannel(chan->sdl_channel, BUSY);
SDL_UnlockAudio();
chan->decode = Sound_NewSample(chan->sdl_rwops, ext, output, 65536);
Uint32 soundbytes = Sound_Decode(chan->decode);
Sound_Sample *sample = chan->decode;
chan->sample = Mix_QuickLoad_RAW(sample->buffer, soundbytes);
if (chan->sdl_channel < 0)
gli_strict_warning("No available sound channels");
if (chan->sdl_channel >= 0 && chan->sample)
{
SDL_LockAudio();
sound_channels[chan->sdl_channel] = chan;
SDL_UnlockAudio();
Mix_Volume(chan->sdl_channel, chan->volume);
Mix_ChannelFinished(&sound_completion_callback);
if (Mix_PlayChannel(chan->sdl_channel, chan->sample, 0) >= 0)
return 1;
}
gli_strict_warning("play sound failed");
gli_strict_warning(Mix_GetError());
SDL_LockAudio();
cleanup_channel(chan);
SDL_UnlockAudio();
return 0;
}
void SourceSample::Load(char *filename) {
#define BUFSIZE 1024 * 1024
SDL_RWops *rwops;
rwops = SDL_RWFromFile(filename, "rb");
Sound_Sample *sample = Sound_NewSample(rwops, NULL,
_system->GetAudioInfo(),
_buffersize );
if(sample == NULL) {
fprintf(stderr, "[error] failed loading sample from '%s': %s\n",
filename, Sound_GetError());
return;
}
Sound_DecodeAll(sample);
_buffersize = sample->buffer_size;
_buffer = new Uint8[_buffersize];
memcpy(_buffer, sample->buffer, _buffersize);
Sound_FreeSample(sample);
// fprintf(stderr, "done decoding sample '%s'\n", filename);
_position = 0;
}
static void start(sstate *data)
{
// data->sample = Sound_NewSampleFromFile("rain.mtm", NULL, 65536);
data->rw = SDL_RWFromConstMem(song, song_size);
data->sample = Sound_NewSample(data->rw, ".mtm", NULL, 65536);
if (data->sample == NULL)
{
fprintf(stderr, "Failed to init sound: %s\n", Sound_GetError());
return;
}
data->devformat.freq = data->sample->actual.rate;
data->devformat.format = data->sample->actual.format;
data->devformat.channels = data->sample->actual.channels;
data->devformat.samples = 4096; /* I just picked a largish number here. */
data->devformat.callback = audio_callback;
data->devformat.userdata = data;
if (SDL_OpenAudio(&data->devformat, NULL) < 0)
{
fprintf(stderr, "Couldn't open audio device: %s.\n", SDL_GetError());
Sound_FreeSample(data->sample);
return;
}
SDL_PauseAudio(0);
data->done_flag = 0;
}
bool tryRead(SDL_RWops &ops, const char *ext)
{
Sound_Sample *sample = Sound_NewSample(&ops, ext, 0, STREAM_BUF_SIZE);
if (!sample)
{
SDL_RWclose(&ops);
return false;
}
/* Do all of the decoding in the handler so we don't have
* to keep the source ops around */
uint32_t decBytes = Sound_DecodeAll(sample);
uint8_t sampleSize = formatSampleSize(sample->actual.format);
uint32_t sampleCount = decBytes / sampleSize;
buffer = new SoundBuffer;
buffer->bytes = sampleSize * sampleCount;
ALenum alFormat = chooseALFormat(sampleSize, sample->actual.channels);
AL::Buffer::uploadData(buffer->alBuffer, alFormat, sample->buffer,
buffer->bytes, sample->actual.rate);
Sound_FreeSample(sample);
return true;
}
Sound_Sample *Sound_NewSampleFromMem(const Uint8 *data,
Uint32 size,
const char *ext,
Sound_AudioInfo *desired,
Uint32 bufferSize)
{
SDL_RWops *rw;
BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, NULL);
BAIL_IF_MACRO(data == NULL, ERR_INVALID_ARGUMENT, NULL);
BAIL_IF_MACRO(size == 0, ERR_INVALID_ARGUMENT, NULL);
rw = SDL_RWFromMem(data, size);
/* !!! FIXME: rw = RWops_FromMem(data, size);*/
BAIL_IF_MACRO(rw == NULL, SDL_GetError(), NULL);
return(Sound_NewSample(rw, ext, desired, bufferSize));
} /* Sound_NewSampleFromMem */
Sound_Sample *Sound_NewSampleFromFile(const char *filename,
Sound_AudioInfo *desired,
Uint32 bufferSize)
{
const char *ext;
SDL_RWops *rw;
BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, NULL);
BAIL_IF_MACRO(filename == NULL, ERR_INVALID_ARGUMENT, NULL);
ext = strrchr(filename, '.');
rw = SDL_RWFromFile(filename, "rb");
BAIL_IF_MACRO(rw == NULL, SDL_GetError(), NULL);
if (ext != NULL)
ext++;
return(Sound_NewSample(rw, ext, desired, bufferSize));
} /* Sound_NewSampleFromFile */
SDLSoundSource(SDL_RWops &ops,
const char *extension,
uint32_t maxBufSize,
bool looped)
: srcOps(ops),
looped(looped)
{
sample = Sound_NewSample(&srcOps, extension, 0, maxBufSize);
if (!sample)
{
SDL_RWclose(&ops);
throw Exception(Exception::SDLError, "SDL_sound: %s", Sound_GetError());
}
sampleSize = formatSampleSize(sample->actual.format);
alFormat = chooseALFormat(sampleSize, sample->actual.channels);
alFreq = sample->actual.rate;
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "usage: %s <filename>\n", argv[0]);
return 1;
}
if (SDL_Init(SDL_INIT_AUDIO) != 0) {
fprintf(stderr, "Error: %s\n", SDL_GetError());
return 1;
}
if (Sound_Init() == 0) {
fprintf(stderr, "Error: %s\n", Sound_GetError());
return 1;
}
SDL_RWops* rw = SDL_RWFromFile(argv[1], "r");
if (rw == NULL) {
fprintf(stderr, "Error: %s\n", SDL_GetError());
return 1;
}
Sound_AudioInfo wantedFormat;
wantedFormat.channels = 2;
wantedFormat.rate = 44100;
wantedFormat.format = AUDIO_S16LSB;
Sound_Sample* sample = Sound_NewSample(rw, 0, &wantedFormat, 8192);
if (sample == 0) {
fprintf(stderr, "Error: %s\n", Sound_GetError());
return 1;
}
Sound_DecodeAll(sample);
printf("Format: %s\n", sample->decoder->description);
printf("Decoded %d bytes of data.\n", sample->buffer_size);
Sound_FreeSample(sample);
return 0;
}
void SourceMusic::CreateSample(void) {
_rwops = SDL_RWFromFile(_filename, "rb");
char *ext = _filename;
for(int i = 0; *(_filename + i); i++)
{
if(*(_filename + i) == '.')
ext = _filename + i + 1;
}
_sample = Sound_NewSample(_rwops, ext,
_system->GetAudioInfo(),
_sample_buffersize );
if(_sample == NULL) {
fprintf(stderr, "[error] failed loading sample type %s, from %s: %s\n", ext,
_filename, Sound_GetError());
return;
}
_read = 0;
_decoded = 0;
// fprintf(stderr, "created sample\n");
}
