static void myexit(void)
{
bool playing;
playing = al_get_audio_stream_playing(music_stream);
if (playing && music_stream)
al_drain_audio_stream(music_stream);
al_destroy_audio_stream(music_stream);
}
int isMusicPaused(void)
{
/* return true if music is paused */
if (music != NULL)
{
return !(al_get_audio_stream_playing(music));
}
return false;
}
/* Function: al_drain_audio_stream
*/
void al_drain_audio_stream(ALLEGRO_AUDIO_STREAM *stream)
{
bool playing;
if (!al_get_audio_stream_attached(stream)) {
al_set_audio_stream_playing(stream, false);
return;
}
stream->is_draining = true;
do {
al_rest(0.01);
playing = al_get_audio_stream_playing(stream);
} while (playing);
stream->is_draining = false;
}
static int allua_audio_stream_get_playing(lua_State * L)
{
ALLUA_audio_stream audio_stream = allua_check_audio_stream(L, 1);
lua_pushboolean(L, al_get_audio_stream_playing(audio_stream));
return 1;
}
int main(int argc, char **argv)
{
ALLEGRO_AUDIO_RECORDER *r;
ALLEGRO_AUDIO_STREAM *s;
ALLEGRO_EVENT_QUEUE *q;
ALLEGRO_DISPLAY *d;
ALLEGRO_FILE *fp = NULL;
ALLEGRO_PATH *tmp_path = NULL;
int prev = 0;
bool is_recording = false;
int n = 0; /* number of samples written to disk */
(void) argc;
(void) argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
if (!al_init_primitives_addon()) {
abort_example("Unable to initialize primitives addon");
}
if (!al_install_keyboard()) {
abort_example("Unable to install keyboard");
}
if (!al_install_audio()) {
abort_example("Unable to initialize audio addon");
}
if (!al_init_acodec_addon()) {
abort_example("Unable to initialize acodec addon");
}
/* Note: increasing the number of channels will break this demo. Other
* settings can be changed by modifying the constants at the top of the
* file.
*/
r = al_create_audio_recorder(1000, samples_per_fragment, frequency,
audio_depth, ALLEGRO_CHANNEL_CONF_1);
if (!r) {
abort_example("Unable to create audio recorder");
}
s = al_create_audio_stream(playback_fragment_count,
playback_samples_per_fragment, frequency, audio_depth,
ALLEGRO_CHANNEL_CONF_1);
if (!s) {
abort_example("Unable to create audio stream");
}
al_reserve_samples(0);
al_set_audio_stream_playing(s, false);
al_attach_audio_stream_to_mixer(s, al_get_default_mixer());
q = al_create_event_queue();
/* Note: the following two options are referring to pixel samples, and have
* nothing to do with audio samples. */
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 8, ALLEGRO_SUGGEST);
d = al_create_display(320, 256);
if (!d) {
abort_example("Error creating display\n");
}
al_set_window_title(d, "SPACE to record. P to playback.");
al_register_event_source(q, al_get_audio_recorder_event_source(r));
al_register_event_source(q, al_get_audio_stream_event_source(s));
al_register_event_source(q, al_get_display_event_source(d));
al_register_event_source(q, al_get_keyboard_event_source());
al_start_audio_recorder(r);
while (true) {
ALLEGRO_EVENT e;
al_wait_for_event(q, &e);
if (e.type == ALLEGRO_EVENT_AUDIO_RECORDER_FRAGMENT) {
/* We received an incoming fragment from the microphone. In this
* example, the recorder is constantly recording even when we aren't
* saving to disk. The display is updated every time a new fragment
* comes in, because it makes things more simple. If the fragments
* are coming in faster than we can update the screen, then it will be
* a problem.
*/
ALLEGRO_AUDIO_RECORDER_EVENT *re = al_get_audio_recorder_event(&e);
audio_buffer_t input = (audio_buffer_t) re->buffer;
int sample_count = re->samples;
const int R = sample_count / 320;
int i, gain = 0;
/* Calculate the volume, and display it regardless if we are actively
* recording to disk. */
for (i = 0; i < sample_count; ++i) {
if (gain < abs(input[i] - sample_center))
gain = abs(input[i] - sample_center);
}
al_clear_to_color(al_map_rgb(0,0,0));
if (is_recording) {
/* Save raw bytes to disk. Assumes everything is written
* succesfully. */
if (fp && n < frequency / (float) samples_per_fragment *
max_seconds_to_record) {
al_fwrite(fp, input, sample_count * sample_size);
++n;
}
/* Draw a pathetic visualization. It draws exactly one fragment
* per frame. This means the visualization is dependent on the
* various parameters. A more thorough implementation would use this
* event to copy the new data into a circular buffer that holds a
* few seconds of audio. The graphics routine could then always
* draw that last second of audio, which would cause the
* visualization to appear constant across all different settings.
*/
for (i = 0; i < 320; ++i) {
int j, c = 0;
/* Take the average of R samples so it fits on the screen */
for (j = i * R; j < i * R + R && j < sample_count; ++j) {
c += input[j] - sample_center;
}
c /= R;
/* Draws a line from the previous sample point to the next */
al_draw_line(i - 1, 128 + ((prev - min_sample_val) /
(float) sample_range) * 256 - 128, i, 128 +
((c - min_sample_val) / (float) sample_range) * 256 - 128,
al_map_rgb(255,255,255), 1.2);
prev = c;
}
}
/* draw volume bar */
al_draw_filled_rectangle((gain / (float) max_sample_val) * 320, 251,
0, 256, al_map_rgba(0, 255, 0, 128));
al_flip_display();
}
else if (e.type == ALLEGRO_EVENT_AUDIO_STREAM_FRAGMENT) {
/* This event is received when we are playing back the audio clip.
* See ex_saw.c for an example dedicated to playing streams.
*/
if (fp) {
audio_buffer_t output = al_get_audio_stream_fragment(s);
if (output) {
/* Fill the buffer from the data we have recorded into the file.
* If an error occurs (or end of file) then silence out the
* remainder of the buffer and stop the playback.
*/
const size_t bytes_to_read =
playback_samples_per_fragment * sample_size;
size_t bytes_read = 0, i;
do {
bytes_read += al_fread(fp, (uint8_t *)output + bytes_read,
bytes_to_read - bytes_read);
} while (bytes_read < bytes_to_read && !al_feof(fp) &&
!al_ferror(fp));
/* silence out unused part of buffer (end of file) */
for (i = bytes_read / sample_size;
i < bytes_to_read / sample_size; ++i) {
output[i] = sample_center;
}
al_set_audio_stream_fragment(s, output);
if (al_ferror(fp) || al_feof(fp)) {
al_drain_audio_stream(s);
al_fclose(fp);
fp = NULL;
}
}
}
}
else if (e.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if (e.type == ALLEGRO_EVENT_KEY_CHAR) {
if (e.keyboard.unichar == 27) {
/* pressed ESC */
break;
}
else if (e.keyboard.unichar == ' ') {
if (!is_recording) {
/* Start the recording */
is_recording = true;
if (al_get_audio_stream_playing(s)) {
al_drain_audio_stream(s);
}
/* Reuse the same temp file for all recordings */
if (!tmp_path) {
fp = al_make_temp_file("alrecXXX.raw", &tmp_path);
}
else {
if (fp) al_fclose(fp);
fp = al_fopen(al_path_cstr(tmp_path, '/'), "w");
}
n = 0;
}
else {
is_recording = false;
if (fp) {
al_fclose(fp);
fp = NULL;
}
}
}
else if (e.keyboard.unichar == 'p') {
/* Play the previously recorded wav file */
if (!is_recording) {
if (tmp_path) {
fp = al_fopen(al_path_cstr(tmp_path, '/'), "r");
if (fp) {
al_set_audio_stream_playing(s, true);
}
}
}
}
}
}
/* clean up */
al_destroy_audio_recorder(r);
al_destroy_audio_stream(s);
if (fp)
al_fclose(fp);
if (tmp_path) {
al_remove_filename(al_path_cstr(tmp_path, '/'));
al_destroy_path(tmp_path);
}
return 0;
}
static void event_handler(const ALLEGRO_EVENT * event)
{
int i;
switch (event->type) {
/* Was the X button on the window pressed? */
case ALLEGRO_EVENT_DISPLAY_CLOSE:
exiting = true;
break;
/* Was a key pressed? */
case ALLEGRO_EVENT_KEY_CHAR:
if (event->keyboard.keycode == ALLEGRO_KEY_LEFT) {
double pos = al_get_audio_stream_position_secs(music_stream);
pos -= 5.0;
if (pos < 0.0)
pos = 0.0;
al_seek_audio_stream_secs(music_stream, pos);
}
else if (event->keyboard.keycode == ALLEGRO_KEY_RIGHT) {
double pos = al_get_audio_stream_position_secs(music_stream);
pos += 5.0;
if (!al_seek_audio_stream_secs(music_stream, pos))
log_printf("seek error!\n");
}
else if (event->keyboard.keycode == ALLEGRO_KEY_SPACE) {
bool playing;
playing = al_get_audio_stream_playing(music_stream);
playing = !playing;
al_set_audio_stream_playing(music_stream, playing);
}
else if (event->keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
exiting = true;
}
break;
case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:
mouse_button[event->mouse.button] = 1;
maybe_fiddle_sliders(event->mouse.x, event->mouse.y);
break;
case ALLEGRO_EVENT_MOUSE_AXES:
maybe_fiddle_sliders(event->mouse.x, event->mouse.y);
break;
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
mouse_button[event->mouse.button] = 0;
break;
case ALLEGRO_EVENT_MOUSE_LEAVE_DISPLAY:
for (i = 0; i < 16; i++)
mouse_button[i] = 0;
break;
/* Is it time for the next timer tick? */
case ALLEGRO_EVENT_TIMER:
logic();
render();
break;
case ALLEGRO_EVENT_AUDIO_STREAM_FINISHED:
log_printf("Stream finished.\n");
break;
}
}
bool AudioStream::playing()
{
return al_get_audio_stream_playing(m_stream);
}
bool AllegroMusicSample5::IsPlaying() const
{
if ( !m_pInstance )
return false;
return al_get_audio_stream_playing( m_pInstance );
}
bool
is_sound_playing(sound_t* sound)
{
return al_get_audio_stream_playing(sound->stream);
}
