/programy/C/ix86/sound/playback.c |
---|
0,0 → 1,173 |
//ALSA Audio playback testing program |
// |
#include <stdio.h> |
#include <stdlib.h> |
#include <alsa/asoundlib.h> |
int exact_rate=44100; |
int linear_chirp(int *pole, int delka_pole, int spozdeni){ // vygeneruje linearni chirp a vzorky ulozi do pole |
static const double pi = 3.141592653589793238462643383279502884197; // Archimedes constant pi |
static const float f0 = 0.01; |
static const float k = 0.0001; |
int t; |
float ble; |
if((spozdeni+delka_pulsu) < delka_pole) |
for(t=0;t < delka_pulsu;t++) pole[spozdeni+t] = round ( 100*sin(2*pi*t*(f0+(k/2)*t)) ); |
else return 0; |
} |
static void async_callback(snd_async_handler_t *ahandler) |
{ |
snd_pcm_t *handle = snd_async_handler_get_pcm(ahandler); |
struct async_private_data *data = snd_async_handler_get_callback_private(ahandler); |
signed short *samples = data->samples; |
snd_pcm_channel_area_t *areas = data->areas; |
snd_pcm_sframes_t avail; |
int err; |
avail = snd_pcm_avail_update(handle); |
while (avail >= period_size) { |
generate_sine(areas, 0, period_size, &data->phase); |
err = snd_pcm_writei(handle, samples, period_size); |
if (err < 0) { |
printf("Write error: %s\n", snd_strerror(err)); |
exit(EXIT_FAILURE); |
} |
if (err != period_size) { |
printf("Write error: written %i expected %li\n", err, period_size); |
exit(EXIT_FAILURE); |
} |
avail = snd_pcm_avail_update(handle); |
} |
} |
static int async_loop(snd_pcm_t *handle, |
signed short *samples, |
snd_pcm_channel_area_t *areas) |
{ |
struct async_private_data data; |
snd_async_handler_t *ahandler; |
int err, count; |
unsigned int i; |
data.samples = samples; |
data.areas = areas; |
data.phase = 0; |
err = snd_async_add_pcm_handler(&ahandler, handle, async_callback, &data); |
if (err < 0) { |
printf("Unable to register async handler\n"); |
exit(EXIT_FAILURE); |
} |
for (count = 0; count < 2; count++) { |
generate_sine(areas, 0, period_size, &data.phase); |
err = snd_pcm_writei(handle, samples, period_size); |
if (err < 0) { |
printf("Initial write error: %s\n", snd_strerror(err)); |
exit(EXIT_FAILURE); |
} |
if (err != period_size) { |
printf("Initial write error: written %i expected %li\n", err, period_size); |
exit(EXIT_FAILURE); |
} |
} |
if (snd_pcm_state(handle) == SND_PCM_STATE_PREPARED) { |
err = snd_pcm_start(handle); |
if (err < 0) { |
printf("Start error: %s\n", snd_strerror(err)); |
exit(EXIT_FAILURE); |
} |
} |
/* because all other work is done in the signal handler, |
suspend the process */ |
for(i=0; i<=10;i++) { |
sleep(1); |
} |
} |
main (int argc, char *argv[]) |
{ |
int i; |
int err; |
short buf[128]; |
snd_pcm_t *playback_handle; |
snd_pcm_hw_params_t *hw_params; |
snd_pcm_channel_area_t *areas; |
if ((err = snd_pcm_open (&playback_handle, argv[1], SND_PCM_STREAM_PLAYBACK, 0)) < 0) { |
fprintf (stderr, "cannot open audio device %s (%s)\n", |
argv[1], |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) { |
fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_any (playback_handle, hw_params)) < 0) { |
fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_set_access (playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { |
fprintf (stderr, "cannot set access type (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_set_format (playback_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) { |
fprintf (stderr, "cannot set sample format (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_set_rate_near (playback_handle, hw_params, &exact_rate, 0)) < 0) { |
fprintf (stderr, "cannot set sample rate (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_set_channels (playback_handle, hw_params, 2)) < 0) { |
fprintf (stderr, "cannot set channel count (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params (playback_handle, hw_params)) < 0) { |
fprintf (stderr, "cannot set parameters (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_prepare (playback_handle)) < 0) { |
fprintf (stderr, "cannot prepare audio interface for use (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
async_loop(playback_handle, samples, areas); |
/* for (i = 0; i < 100; ++i) { |
if ((err = snd_pcm_writei (playback_handle, buf, 128)) != 128) { |
fprintf (stderr, "write to audio interface failed (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
}*/ |
snd_pcm_close (playback_handle); |
exit (0); |
} |
/programy/C/ix86/sound/capture.c |
---|
0,0 → 1,94 |
#include <stdio.h> |
#include <stdlib.h> |
#include <alsa/asoundlib.h> |
int exact_rate = 44100; |
#define BUFFER_SIZE 1024 |
main (int argc, char *argv[]) |
{ |
int i,j; |
int err; |
short buf[BUFFER_SIZE]; |
snd_pcm_t *capture_handle; |
snd_pcm_hw_params_t *hw_params; |
if ((err = snd_pcm_open (&capture_handle, argv[1], SND_PCM_STREAM_CAPTURE, 0)) < 0) { |
fprintf (stderr, "cannot open audio device %s (%s)\n", |
argv[1], |
snd_strerror (err)); |
exit (1); |
} |
fprintf (stdout,"nastaveni formatu\n"); |
if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) { |
fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_any (capture_handle, hw_params)) < 0) { |
fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_set_access (capture_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { |
fprintf (stderr, "cannot set access type (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
if ((err = snd_pcm_hw_params_set_format (capture_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) { |
fprintf (stderr, "cannot set sample format (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
fprintf (stdout,"nastaveni formatu\n"); |
if ((err = snd_pcm_hw_params_set_rate_near (capture_handle, hw_params, &exact_rate, 0)) < 0) { |
fprintf (stderr, "cannot set sample rate (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
fprintf (stdout,"nastaveni vzorkovani\n"); |
if ((err = snd_pcm_hw_params_set_channels (capture_handle, hw_params, 2)) < 0) { |
fprintf (stderr, "cannot set channel count (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
fprintf (stdout,"nastaveni poctu kanalu\n"); |
if ((err = snd_pcm_hw_params (capture_handle, hw_params)) < 0) { |
fprintf (stderr, "cannot set parameters (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
fprintf (stdout,"nastaveni parametru\n"); |
snd_pcm_hw_params_free (hw_params); |
if ((err = snd_pcm_prepare (capture_handle)) < 0) { |
fprintf (stderr, "cannot prepare audio interface for use (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
fprintf (stdout,"povoleni audia\n"); |
if ((err = snd_pcm_readi (capture_handle, buf, BUFFER_SIZE)) != BUFFER_SIZE) { |
fprintf (stderr, "read from audio interface failed (%s)\n", |
snd_strerror (err)); |
exit (1); |
} |
for (j=0; j < 500; j=j+2) fprintf (stdout,"%u:%d %d\n ",j,buf[j], buf[j+1]); |
snd_pcm_close (capture_handle); |
exit (0); |
} |
/programy/C/ix86/sound/duplex.c |
---|
0,0 → 1,166 |
#include <stdio.h> |
#include <stdlib.h> |
#include <errno.h> |
#include <poll.h> |
#include <alsa/asoundlib.h> |
/* you allocate these in heap */ |
int restarting; |
int fragments = 2; |
int channels = 1; |
int buffer_size = 512; |
int sample_rate = 48000; |
int frame_size = 1024; |
int bits = 16; |
char *snd_device_in = "plughw:0,0"; |
char *snd_device_out = "plughw:0,0"; |
snd_pcm_t *playback_handle; |
snd_pcm_t *capture_handle; |
int err; |
int configure_alsa_audio(snd_pcm_t *device, int channels) |
{ |
snd_pcm_hw_params_t *hw_params; |
int err; |
int tmp; |
snd_pcm_uframes_t frames; |
/* allocate memory for hardware parameter structure */ |
if ((err = snd_pcm_hw_params_malloc(&hw_params)) < 0) { |
fprintf (stderr, "cannot allocate parameter structure (%s)\n", |
snd_strerror(err)); |
return 1; |
} |
/* fill structure from current audio parameters */ |
if ((err = snd_pcm_hw_params_any(device, hw_params)) < 0) { |
fprintf (stderr, "cannot initialize parameter structure (%s)\n", |
snd_strerror(err)); |
return 1; |
} |
/* set access type, sample rate, sample format, channels */ |
if ((err = snd_pcm_hw_params_set_access(device, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) { |
fprintf (stderr, "cannot set access type: %s\n", |
snd_strerror(err)); |
return 1; |
} |
// bits = 16 |
if ((err = snd_pcm_hw_params_set_format(device, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) { |
fprintf (stderr, "cannot set sample format: %s\n", |
snd_strerror(err)); |
return 1; |
} |
tmp = sample_rate; |
if ((err = snd_pcm_hw_params_set_rate_near(device, hw_params, &tmp, 0)) < 0) { |
fprintf (stderr, "cannot set sample rate: %s\n", |
snd_strerror(err)); |
return 1; |
} |
if (tmp != sample_rate) { |
fprintf(stderr, "Could not set requested sample rate, asked for %d got %d\n", sample_rate, tmp); |
sample_rate = tmp; |
} |
if ((err = snd_pcm_hw_params_set_channels(device, hw_params, channels)) < 0) { |
fprintf (stderr, "cannot set channel count: %s\n", |
snd_strerror(err)); |
return 1; |
} |
if ((err = snd_pcm_hw_params_set_periods_near(device, hw_params, &fragments, 0)) < 0) { |
fprintf(stderr, "Error setting # fragments to %d: %s\n", fragments, |
snd_strerror(err)); |
return 1; |
} |
frame_size = channels * (bits / 8); |
frames = buffer_size / frame_size * fragments; |
if ((err = snd_pcm_hw_params_set_buffer_size_near(device, hw_params, &frames)) < 0) { |
fprintf(stderr, "Error setting buffer_size %d frames: %s\n", frames, |
snd_strerror(err)); |
return 1; |
} |
if (buffer_size != frames * frame_size / fragments) { |
fprintf(stderr, "Could not set requested buffer size, asked for %d got %d\n", buffer_size, frames * frame_size / fragments); |
buffer_size = frames * frame_size / fragments; |
} |
if ((err = snd_pcm_hw_params(device, hw_params)) < 0) { |
fprintf(stderr, "Error setting HW params: %s\n", |
snd_strerror(err)); |
return 1; |
} |
return 0; |
} |
main (void) |
{ |
int i,frames, inframes, outframes, frame_size; |
if ((err = snd_pcm_open(&playback_handle, snd_device_out, SND_PCM_STREAM_PLAYBACK, 0)) < 0) { |
fprintf(stderr, "cannot open output audio device %s: %s\n", snd_device_in, snd_strerror(err)); |
exit(1); |
} |
if ((err = snd_pcm_open(&capture_handle, snd_device_in, SND_PCM_STREAM_CAPTURE, 0)) < 0) { |
fprintf(stderr, "cannot open input audio device %s: %s\n", snd_device_out, snd_strerror(err)); |
exit(1); |
} |
configure_alsa_audio(snd_device_in, channels); |
configure_alsa_audio(snd_device_out, channels); |
restarting = 1; |
while (1) { |
frame_size = channels * (bits / 8); |
frames = buffer_size / frame_size; |
if (restarting) { |
restarting = 0; |
/* drop any output we might got and stop */ |
snd_pcm_drop(capture_handle); |
snd_pcm_drop(playback_handle); |
/* prepare for use */ |
snd_pcm_prepare(capture_handle); |
snd_pcm_prepare(playback_handle); |
/* fill the whole output buffer */ |
for (i = 0; i < fragments; i += 1) |
snd_pcm_writei(playback_handle, rdbuf, frames); |
} |
while ((inframes = snd_pcm_readi(capture_handle, rdbuf, frames)) < 0) { |
if (inframes == -EAGAIN) |
continue; |
// by the way, writing to terminal emulator is costly if you use |
// bad emulators like gnome-terminal, so don't do this. |
fprintf(stderr, "Input buffer overrun\n"); |
restarting = 1; |
snd_pcm_prepare(capture_handle); |
} |
if (inframes != frames) |
fprintf(stderr, "Short read from capture device: %d, expecting %d\n", inframes, frames); |
/* now processes the frames */ |
do_something(rdbuf, inframes); |
while ((outframes = snd_pcm_writei(playback_handle, rdbuf, inframes)) < 0) { |
if (outframes == -EAGAIN) |
continue; |
fprintf(stderr, "Output buffer underrun\n"); |
restarting = 1; |
snd_pcm_prepare(playback_handle); |
} |
if (outframes != inframes) |
fprintf(stderr, "Short write to playback device: %d, expecting %d\n", outframes, frames); |
snd_pcm_close(snd_device_out); |
snd_pcm_close(snd_device_in); |
exit (0); |
} |
Property changes: |
Added: svn:mergeinfo |