Skip to contentSkip to conversation

Little question about ALSA callbacks

DISCUSSION Alfredo 3 participants 5 messages Jul 27, 2005

lore
Share & tools
lore

Alfredo

author
#0 lore raw

Hello, I have read the article "Introduction to Sound Programming with ALSA from Linux Journal. This article explains:

// Starts here:
------------------------------------------------------------------------
-------------------------------------------

"In the previous examples, the PCM streams were operating in blocking mode, that is, the calls would not return until the data had been transferred. In an interactive event-driven application, this situation could lock up the application for unacceptably long periods of time. ALSA allows opening a stream in nonblocking mode where the read and write functions return immediately. If data transfers are pending and the calls cannot be processed, ALSA returns an error code of EBUSY.

Many graphical applications use callbacks to handle events. ALSA supports opening a PCM stream in asynchronous mode. This allows registering a callback function to be called when a period of sample data has been transferred."

// Finishes here:
------------------------------------------------------------------------
-------

I'm developing an event driven Linux server that will use ALSA library. Please, could you point me to some resources in order to learn how to use alsa in asynchronous mode (the event driven mechanism will be based in poll()).

Clemens Ladisch helped me suggesting that I must use poll to wait for events in different file descriptors. I need to be notified when audio buffer has been recorded. I need to learn how to use ALSA in conjunction with poll.

I'm a Linux developer beginner and I'm glad to use ALSA.

Thank you very much ;-)

#1 lore raw

At Wed, 27 Jul 2005 11:28:26 +0200,

Quoted 21 lines · Alfredo

Hello, I have read the article $B!H(BIntroduction to Sound Programming with ALSA from Linux Journal. This article explains:

// Starts here:
-------------------------------------------------------------------------------------------------------------------

$B!H(BIn the previous examples, the PCM streams were operating in blocking mode, that is, the calls would not return until the data had been transferred. In an interactive event-driven application, this situation could lock up the application for unacceptably long periods of time. ALSA allows opening a stream in nonblocking mode where the read and write functions return immediately. If data transfers are pending and the calls cannot be processed, ALSA returns an error code of EBUSY.

Many graphical applications use callbacks to handle events. ALSA supports opening a PCM stream in asynchronous mode. This allows registering a callback function to be called when a period of sample data has been transferred.$B!H(B

// Finishes here:
-------------------------------------------------------------------------------

Quoted 7 lines

I.FN"m developing an event driven Linux server that will use ALSA library. Please, could you point me to some resources in order to learn how to use alsa in asynchronous mode (the event driven mechanism will be based in poll()).

Clemens Ladisch helped me suggesting that I must use poll to wait for events in different file descriptors. I need to be notified when audio buffer has been recorded. I need to learn how to use ALSA in conjunction with poll.

The async mode described above uses a signal instead of poll, so this is not a recommended way although it seems working on most of architectures. Using poll is better.

If your app is a graphical one or do a heavy job (e.g. encoding) together with a sound engine, you'll likely need a dedicated audio thread for stability. In that case, consdering to use JACK would be a good idea, too...

Takashi

-------------------------------------------------------
SF.Net email is sponsored by: Discover Easy Linux Migration Strategies from IBM. Find simple to follow Roadmaps, straightforward articles, informative Webcasts and more! Get everything you need to get up to speed, fast. http://ads.osdn.com/?ad_id=7477&alloc_id=16492&op=click

#3 lore raw
In reply to Alfredo

Hi Alfredo,

I just had the same problem here some days ago. (It was mainly about recording)

This is my solution: (taken from a bigger project and hacked together from some tutorials - so this is not really clean!)

opening as usual (with SND_PCM_NONBLOCK) and then do:

---- snip --------

/* tell ALSA to wake us up whenever 256 or more frames
of record data can be delivered. Also, tell ALSA that we'll start the device ourselves.
*/

  if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {
    fprintf (stderr, "cannot allocate software parameters structure (%s)\n",
	     snd_strerror (err));
    exit (1);
  }
  if ((err = snd_pcm_sw_params_current (rec_handle, sw_params)) < 0) {
    fprintf (stderr, "cannot initialize software parameters structure (%s)\n",
	     snd_strerror (err));
    exit (1);

}

  int handleBytes = 256; // bytesToCapture/2;

if ((err = snd_pcm_sw_params_set_avail_min (rec_handle, sw_params,

handleBytes)) < 0) {
    fprintf (stderr, "cannot set minimum available count (%s)\n",
	     snd_strerror (err));
    exit (1);
  }
  if ((err = snd_pcm_sw_params_set_start_threshold (rec_handle, sw_params, 
handleBytes)) < 0) {
    fprintf (stderr, "cannot set start mode (%s)\n",
	     snd_strerror (err));
    exit (1);
  }
  if ((err = snd_pcm_sw_params (rec_handle, sw_params)) < 0) {
    fprintf (stderr, "cannot set software parameters (%s)\n",
	     snd_strerror (err));
    exit (1);

}

/* the interface will interrupt the kernel every 256 Samples, and ALSA
will wake up this program very soon after that.
*/

  if ((err = snd_pcm_prepare (rec_handle)) < 0) {
    fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
	     snd_strerror (err));
    exit (1);

}

  snd_pcm_sw_params_free (sw_params);

// now get the descriptors:
int count = snd_pcm_poll_descriptors_count(rec_handle);

  slog(Slog::levelDebug)<<" count = "<<count<<oendl;

  if (count <= 0) {
    printf("Invalid poll descriptors count\n");
    return count;
  }

struct pollfd *ufds;

  ufds = new pollfd[count];
  if (ufds == NULL) {
    printf("Not enough memory\n");
    return -ENOMEM;
  }
  if ((err = snd_pcm_poll_descriptors(rec_handle, ufds, count)) < 0) {
    printf("Unable to obtain poll descriptors for playback: %s\n", 
snd_strerror(err));
    return err;

}

recDesc = ufds->fd; //< this is my descriptor for select!!!

// tell scheduler, that we want to be informed on soundcard events sched->add_select(this, recDesc);

  snd_pcm_start(rec_handle);

--- snip --------

The following method will be called, if the descriptor is set via select/FD_SET etc (see manpage for this)

--- snip --------

void alsaSoundLayer::descHandler(Event e)
{
[...]
snd_pcm_sframes_t samples_to_deliver;
if ((samples_to_deliver = snd_pcm_avail_update (rec_handle)) <= 0) {
if (samples_to_deliver == 0) {
slog(Slog::levelDebug)<<name<<": desc was called, but no data

available!?\n";
      return;
    }

[ ... error handling ... ]

char* samples = new char[samples_to_deliver*2]; // samples are short if ((rc = snd_pcm_readi( rec_handle, (void*) samples, samples_to_deliver ))
< 0)

    [... error handling ...]
  len = rc*2;

[... do whatever with the packet ...]

return;
}

--- snip ------

Hope this helps!

regards - Jörn

Am Mittwoch, 27. Juli 2005 11:28 schrieb Alfredo:

Quoted 31 lines

Hello, I have read the article "Introduction to Sound Programming with ALSA from Linux Journal. This article explains:

// Starts here:
------------------------------------------------------------------------
-------------------------------------------

"In the previous examples, the PCM streams were operating in blocking mode, that is, the calls would not return until the data had been transferred. In an interactive event-driven application, this situation could lock up the application for unacceptably long periods of time. ALSA allows opening a stream in nonblocking mode where the read and write functions return immediately. If data transfers are pending and the calls cannot be processed, ALSA returns an error code of EBUSY.

Many graphical applications use callbacks to handle events. ALSA supports opening a PCM stream in asynchronous mode. This allows registering a callback function to be called when a period of sample data has been transferred."

// Finishes here:
------------------------------------------------------------------------
-------

I'm developing an event driven Linux server that will use ALSA library. Please, could you point me to some resources in order to learn how to use alsa in asynchronous mode (the event driven mechanism will be based in poll()).

Quoted 8 lines

Clemens Ladisch helped me suggesting that I must use poll to wait for events in different file descriptors. I need to be notified when audio buffer has been recorded. I need to learn how to use ALSA in conjunction with poll.

I'm a Linux developer beginner and I'm glad to use ALSA.

Thank you very much ;-)

-------------------------------------------------------
SF.Net email is sponsored by: Discover Easy Linux Migration Strategies from IBM. Find simple to follow Roadmaps, straightforward articles, informative Webcasts and more! Get everything you need to get up to speed, fast. http://ads.osdn.com/?ad_idt77&alloc_id492&op=click

author
#2 lore raw
In reply to Takashi Iwai

Thank you very much for your suggestions Takashi.

-----Original Message-----
From: Takashi Iwai [mailto:[email protected]]
Sent: miércoles, 27 de julio de 2005 10:48
To: Alfredo
Cc: [email protected]
Subject: Re: [Alsa-devel] Little question about ALSA callbacks

At Wed, 27 Jul 2005 11:28:26 +0200,

Quoted 2 lines · Alfredo

Hello, I have read the article $B!H(BIntroduction to Sound

Programming with ALSA from Linux

Quoted 4 lines

Journal. This article explains:

// Starts here:

------------------------------------------------------------------------
-------------------------------------------

Quoted 2 lines

$B!H(BIn the previous examples, the PCM streams were operating in

blocking mode, that is,

Quoted 1 line

the calls would not return until the data had been transferred. In an

interactive

Quoted 1 line

event-driven application, this situation could lock up the application

for

Quoted 1 line

unacceptably long periods of time. ALSA allows opening a stream in

nonblocking mode

Quoted 1 line

where the read and write functions return immediately. If data

transfers are pending

Quoted 1 line

and the calls cannot be processed, ALSA returns an error code of

EBUSY.

Quoted 2 lines

Many graphical applications use callbacks to handle events. ALSA

supports opening a

Quoted 1 line

PCM stream in asynchronous mode. This allows registering a callback

function to be

Quoted 4 lines

called when a period of sample data has been transferred.$B!H(B

// Finishes here:

------------------------------------------------------------------------
-------

Quoted 2 lines

I.FN"m developing an event driven Linux server that will use ALSA

library. Please, could

Quoted 1 line

you point me to some resources in order to learn how to use alsa in

asynchronous mode

Quoted 3 lines

(the event driven mechanism will be based in poll()).

Clemens Ladisch helped me suggesting that I must use poll to wait for

events in

Quoted 1 line

different file descriptors. I need to be notified when audio buffer

has been recorded.

Quoted 1 line

I need to learn how to use ALSA in conjunction with poll.

The async mode described above uses a signal instead of poll, so this is not a recommended way although it seems working on most of architectures. Using poll is better.

If your app is a graphical one or do a heavy job (e.g. encoding) together with a sound engine, you'll likely need a dedicated audio thread for stability. In that case, consdering to use JACK would be a good idea, too...

Takashi

-------------------------------------------------------
SF.Net email is sponsored by: Discover Easy Linux Migration Strategies from IBM. Find simple to follow Roadmaps, straightforward articles, informative Webcasts and more! Get everything you need to get up to speed, fast. http://ads.osdn.com/?ad_idt77&alloc_id492&op=click

author
#4 lore raw
In reply to Joern Seger

Thank you very much! Your help is really appreciated.

I will improve my knowledge to help other developers.

-----Original Message-----
From: Joern Seger [mailto:[email protected]]
Sent: miércoles, 27 de julio de 2005 11:06
To: [email protected]
Cc: Alfredo
Subject: Re: [Alsa-devel] Little question about ALSA callbacks

Hi Alfredo,

I just had the same problem here some days ago. (It was mainly about recording)

This is my solution: (taken from a bigger project and hacked together from
some tutorials - so this is not really clean!)

opening as usual (with SND_PCM_NONBLOCK) and then do:

---- snip --------

/* tell ALSA to wake us up whenever 256 or more frames
of record data can be delivered. Also, tell ALSA that we'll start the device ourselves.
*/

if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {
fprintf (stderr, "cannot allocate software parameters structure
(%s)\n",

	     snd_strerror (err));
    exit (1);

}
if ((err = snd_pcm_sw_params_current (rec_handle, sw_params)) < 0) {
fprintf (stderr, "cannot initialize software parameters structure
(%s)\n",

	     snd_strerror (err));
    exit (1);

}

  int handleBytes = 256; // bytesToCapture/2;

if ((err = snd_pcm_sw_params_set_avail_min (rec_handle, sw_params,

handleBytes)) < 0) {
    fprintf (stderr, "cannot set minimum available count (%s)\n",
	     snd_strerror (err));
    exit (1);
  }
  if ((err = snd_pcm_sw_params_set_start_threshold (rec_handle,
sw_params,
handleBytes)) < 0) {
    fprintf (stderr, "cannot set start mode (%s)\n",
	     snd_strerror (err));
    exit (1);
  }
  if ((err = snd_pcm_sw_params (rec_handle, sw_params)) < 0) {
    fprintf (stderr, "cannot set software parameters (%s)\n",
	     snd_strerror (err));
    exit (1);

}

/* the interface will interrupt the kernel every 256 Samples, and ALSA
will wake up this program very soon after that.
*/

  if ((err = snd_pcm_prepare (rec_handle)) < 0) {
    fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
	     snd_strerror (err));
    exit (1);

}

  snd_pcm_sw_params_free (sw_params);

// now get the descriptors:
int count = snd_pcm_poll_descriptors_count(rec_handle);

  slog(Slog::levelDebug)<<" count = "<<count<<oendl;

  if (count <= 0) {
    printf("Invalid poll descriptors count\n");
    return count;
  }

struct pollfd *ufds;

  ufds = new pollfd[count];
  if (ufds == NULL) {
    printf("Not enough memory\n");
    return -ENOMEM;
  }
  if ((err = snd_pcm_poll_descriptors(rec_handle, ufds, count)) < 0) {
    printf("Unable to obtain poll descriptors for playback: %s\n",
snd_strerror(err));
    return err;

}

recDesc = ufds->fd; //< this is my descriptor for select!!!

// tell scheduler, that we want to be informed on soundcard events sched->add_select(this, recDesc);

  snd_pcm_start(rec_handle);

--- snip --------

The following method will be called, if the descriptor is set via select/FD_SET etc (see manpage for this)

--- snip --------

void alsaSoundLayer::descHandler(Event e)
{
[...]
snd_pcm_sframes_t samples_to_deliver;
if ((samples_to_deliver = snd_pcm_avail_update (rec_handle)) <= 0) {
if (samples_to_deliver == 0) {
slog(Slog::levelDebug)<<name<<": desc was called, but no data

available!?\n";
      return;
    }

[ ... error handling ... ]

char* samples = new char[samples_to_deliver*2]; // samples are short if ((rc = snd_pcm_readi( rec_handle, (void*) samples,
samples_to_deliver ))
< 0)

    [... error handling ...]
  len = rc*2;

[... do whatever with the packet ...]

return;
}

--- snip ------

Hope this helps!

regards - Jörn

Am Mittwoch, 27. Juli 2005 11:28 schrieb Alfredo:

Quoted 7 lines

Hello, I have read the article "Introduction to Sound Programming with ALSA from Linux Journal. This article explains:

// Starts here:

------------------------------------------------------------------------

Quoted 5 lines

-------------------------------------------

"In the previous examples, the PCM streams were operating in blocking mode, that is, the calls would not return until the data had been transferred. In an interactive event-driven application, this

situation

Quoted 5 lines

could lock up the application for unacceptably long periods of time. ALSA allows opening a stream in nonblocking mode where the read and write functions return immediately. If data transfers are pending and the calls cannot be processed, ALSA returns an error code of EBUSY.

Quoted 7 lines

Many graphical applications use callbacks to handle events. ALSA supports opening a PCM stream in asynchronous mode. This allows registering a callback function to be called when a period of sample data has been transferred."

// Finishes here:

------------------------------------------------------------------------

Quoted 3 lines

-------

I'm developing an event driven Linux server that will use ALSA

library.

Quoted 2 lines

Please, could you point me to some resources in order to learn how to use alsa in asynchronous mode (the event driven mechanism will be

based

Quoted 5 lines

in poll()).

Clemens Ladisch helped me suggesting that I must use poll to wait for events in different file descriptors. I need to be notified when audio buffer has been recorded. I need to learn how to use ALSA in

conjunction

Quoted 5 lines

with poll.

I'm a Linux developer beginner and I'm glad to use ALSA.

Thank you very much ;-)

-------------------------------------------------------
SF.Net email is sponsored by: Discover Easy Linux Migration Strategies from IBM. Find simple to follow Roadmaps, straightforward articles, informative Webcasts and more! Get everything you need to get up to speed, fast. http://ads.osdn.com/?ad_idt77&alloc_id492&op=click