Subversion Repositories svnkaklik

//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);
        }