void CSoundStream::Stop ()
{
if (m_pStream)
{
stop_audio_stream(m_pStream);
m_pStream = NULL;
}
}
void SoundDriver_Allegro::Stop()
{
if (_stream != NULL) {
stop_audio_stream(_stream);
_stream = NULL;
}
remove_sound();
if (--_allegro_instance_count == 0) allegro_exit();
}
void logg_stop_stream(LOGG_Stream* s)
{
int i;
stop_audio_stream(s->audio_stream);
for (i = 0; i < OGG_PAGES_TO_BUFFER; i++) {
free(s->buf[i]);
s->buf[i] = 0;
}
}
void al_stop_duh(AL_DUH_PLAYER *dp)
{
if (dp) {
if (dp->sigrenderer) {
duh_end_sigrenderer(dp->sigrenderer);
stop_audio_stream(dp->stream);
}
free(dp);
}
}
// Should this be changed? User might want to hack the underlying SIGRENDERER
// and resurrect it (e.g. change pattern number), before it gets destroyed...
DUH_SIGRENDERER *al_duh_decompose_to_sigrenderer(AL_DUH_PLAYER *dp)
{
if (dp) {
DUH_SIGRENDERER *sigrenderer = dp->sigrenderer;
if (sigrenderer) stop_audio_stream(dp->stream);
free(dp);
return sigrenderer;
}
return NULL;
}
void alogg_stop_oggstream(ALOGG_OGGSTREAM *ogg) {
/* continue if we are playing it */
if (!alogg_is_playing_oggstream(ogg))
return;
/* remove the interrupt, if we were using autopolling */
if (ogg->auto_polling)
remove_param_int(&alogg_autopoll_oggstream, (void *)ogg);
/* stop the audio stream */
stop_audio_stream(ogg->audiostream);
ogg->audiostream = NULL;
}
void logg_destroy_stream(LOGG_Stream* s)
{
int i;
if (s->audio_stream) {
stop_audio_stream(s->audio_stream);
}
ov_clear(&s->ovf);
for (i = 0; i < OGG_PAGES_TO_BUFFER; i++) {
if (s->buf[i]) {
free(s->buf[i]);
}
}
free(s->filename);
free(s);
}
void saPlayStreamedSampleBase( int channel, signed char *data, int len, int freq, int volume, int bits , int pan ){
// This one should leave most of the sync work to allegro
int pos;
void *buff; // position in the stream
unsigned short *dout;
signed short *din;
int i;
if (bits == 8) {
fprintf(stderr,"error: Can't play 8 bits\n");
// Just because I don't want to bother with this now.
return;
}
if( audio_sample_rate == 0 || channel >= NUMVOICES ) return;
if( SndMachine == NULL ) return;
if( !playing[channel] ){
if( stream[channel] ){
stop_audio_stream(stream[channel]);
free_audio_stream_buffer(stream[channel]);
stream[channel] = NULL;
}
if (!(stream[channel] = play_audio_stream(len,bits,0,freq,volume,pan))){
return;
}
playing[channel] = 1; /* use front surface */
// Wait for the buffer to be ready...
while (!(buff = get_audio_stream_buffer(stream[channel])));
//print_debug("first stream entry. [%d:%d:%d:%d]\n", channel, len, freq, volume );
}
if (!(buff = get_audio_stream_buffer(stream[channel]))) {
fprintf(stderr,"init stream impossible : buffer NULL\n");
return;
}
// fprintf(stderr,"len memcpy : %d\n",len);
dout=buff;
din = ((signed short*)data);
for (i=0; i<len; i+=2)
*(dout++) = *(din++)^0x8000;
//fprintf(stderr,"set chanel vol = %d\n",volume);
}
AL_DUH_PLAYER *al_start_duh(DUH *duh, int n_channels, long pos, float volume, long bufsize, int freq)
{
AL_DUH_PLAYER *dp;
/* This restriction is imposed by Allegro. */
ASSERT(n_channels > 0);
ASSERT(n_channels <= 2);
if (!duh)
return NULL;
dp = malloc(sizeof(*dp));
if (!dp)
return NULL;
dp->flags = ADP_PLAYING;
dp->bufsize = bufsize;
dp->freq = freq;
dp->stream = play_audio_stream(bufsize, 16, n_channels - 1, freq, 255, 128);
if (!dp->stream) {
free(dp);
return NULL;
}
voice_set_priority(dp->stream->voice, 255);
dp->sigrenderer = duh_start_sigrenderer(duh, 0, n_channels, pos);
if (!dp->sigrenderer) {
stop_audio_stream(dp->stream);
free(dp);
return NULL;
}
dp->volume = volume;
dp->silentcount = 0;
return dp;
}
int al_poll_duh(AL_DUH_PLAYER *dp)
{
unsigned short *sptr;
long n;
long size;
int n_channels;
if (!dp || !dp->sigrenderer)
return 1;
if (!(dp->flags & ADP_PLAYING))
return 0;
sptr = get_audio_stream_buffer(dp->stream);
if (!sptr)
return 0;
n = duh_render(dp->sigrenderer, 16, 1, dp->volume, 65536.0 / dp->freq, dp->bufsize, sptr);
if (n == 0) {
if (++dp->silentcount >= 2) {
duh_end_sigrenderer(dp->sigrenderer);
free_audio_stream_buffer(dp->stream);
stop_audio_stream(dp->stream);
dp->sigrenderer = NULL;
return 1;
}
}
n_channels = duh_sigrenderer_get_n_channels(dp->sigrenderer);
n *= n_channels;
size = dp->bufsize * n_channels;
for (; n < size; n++)
sptr[n] = 0x8000;
free_audio_stream_buffer(dp->stream);
return 0;
}
void alogg_stop_ogg(ALOGG_OGG *ogg) {
/* continue if we are playing it */
if (!alogg_is_playing_ogg(ogg))
return;
/* remove the interrupt, if we were using autopolling */
if (ogg->auto_polling)
remove_param_int(&alogg_autopoll_ogg, (void *)ogg);
/* stop the audio stream */
stop_audio_stream(ogg->audiostream);
ogg->audiostream = NULL;
if (ogg->time_stretch_buffer[0])
{
free(ogg->time_stretch_buffer[0]);
ogg->time_stretch_buffer[0] = NULL;
}
if (ogg->time_stretch_buffer[1])
{
free(ogg->time_stretch_buffer[1]);
ogg->time_stretch_buffer[1] = NULL;
}
}
