Re: Any standard ALSA application for simultaneous capture and playabck ?????

Re: Any standard ALSA application for simultaneous capture and playabck ?????

[Ciaccia]

[-- Attachment #1: Type: text/plain, Size: 2090 bytes --]

> What are the complications in implementing simultaneous playback and
> capture in ALSA???


I would like to add something to this post: what is the "best" way to
program a full duplex application? I would like to have an application
that does full-duplex, with the lowest possible latency and using less
CPU resource as possible. I tried different approaches, but I was not
completely satisfied with none of them....


Here is what I tried:
-having two threads, one for playback and one for capture
-defining 2 callbacks with async_handles and do all the processing in the callback functions
(the last attempt)
-using poll() to wait for one of the streams to be ready (see attached file fullduplex.c)

Could some of you look at the attached code (it is not generic and contains lots of asserts, but it's supposed to work only on one single machine) and tell me if the last approach using poll is well structured?

The main loop looks as following:

>    while (1) {
>        err = poll(ufds, 2, -1);
>
>        for (i = 0; i < 2; i++)
>        {
>            if (snd_pcm_poll_descriptors_revents(handles[i], &ufds[i], 1, &revents) < 0)
>            {
>                printf("Error getting revents for %s\n", descriptors[i].name);
>                exit(1);
>            }
>    
>            if (revents & descriptors[i].poll_flag)
>            {
>                if (transfer_loop(handles[i], &first[i], descriptors[i].func) < 0)
>                {
>                    printf("transfer_loop error for %s\n", descriptors[i].name);
>                    // TODO exit?!?
>                }
>            }
>        }
>    }

and the transfer_loop is a modified version of the loop found in the ALSA examples (pcm.c and latency.c).
Is this strategy optimal in respect to low latency and low CPU usage? 

Every comment is greatly appreciated
Andrea




       
____________________________________________________________________________________Luggage? GPS? Comic books? 
Check out fitting gifts for grads at Yahoo! Search
http://search.yahoo.com/search?fr=oni_on_mail&p=graduation+gifts&cs=bz

[-- Attachment #2: fullduplex.c --]
[-- Type: application/octet-stream, Size: 8803 bytes --]

#include <sys/time.h>
#include <sys/resource.h>
#include <alsa/asoundlib.h>
#include <stdio.h>
#include <math.h>

#define PLAYBACK		0
#define CAPTURE			1
#define CARD			"hw:0,0"

static snd_pcm_format_t format = SND_PCM_FORMAT_S16_LE;	/* sample format */
static unsigned int rate = 44100;			/* stream rate */
static snd_pcm_uframes_t period_size = 512;		/* period size */
static short buffer[512];

typedef void (*area_callback)(const snd_pcm_channel_area_t*, snd_pcm_uframes_t, int);

void capture_area(const snd_pcm_channel_area_t *areas, snd_pcm_uframes_t offset, int count);
void playback_area(const snd_pcm_channel_area_t *areas, snd_pcm_uframes_t offset, int count);

struct STREAM_DESC {
	char *name;
	snd_pcm_stream_t stream;
	area_callback func;
	unsigned short poll_flag;
};

struct STREAM_DESC descriptors[2] = {
	{ .name = "PLAYBACK",
	  .stream = SND_PCM_STREAM_PLAYBACK,
	  .func = playback_area,
	  .poll_flag = POLLOUT,
	}, 
	{ .name = "CAPTURE",
	  .stream = SND_PCM_STREAM_CAPTURE,
	  .func = capture_area,
	  .poll_flag = POLLIN,
	}
};

void capture_area(const snd_pcm_channel_area_t *areas, 
		snd_pcm_uframes_t offset, int count)
{
	short *isamples;		// interleaved samples
	short *dst;

	assert(areas[0].first == 0);
	assert(areas[0].step == 2 * 8 * sizeof(short));
	assert(areas[1].first == 8 * sizeof(short));
	assert(areas[1].step == 2 * 8 * sizeof(short));
	assert(areas[0].addr == areas[1].addr);
	assert(count == 512);

	isamples = (short *)areas[0].addr + offset * 2; // offset for two interleaved channels
	dst = buffer;

	while (count-- > 0)
	{	
		*dst++ = (short)*isamples;
		isamples++;
		isamples++;
	}
}

void playback_area(const snd_pcm_channel_area_t *areas, 
		snd_pcm_uframes_t offset, int count)
{
	short *isamples;		// interleaved samples
	short *src;

	assert(areas[0].first == 0);
	assert(areas[0].step == 2 * 8 * sizeof(short));
	assert(areas[1].first == 8 * sizeof(short));
	assert(areas[1].step == 2 * 8 * sizeof(short));
	assert(areas[0].addr == areas[1].addr);
	assert(count == 512);

	isamples = (short *)areas[0].addr + offset * 2; // offset for two interleaved channels
	src = buffer;

	while (count-- > 0)
	{	
		*isamples++ = *src;
		*isamples++ = *src;
		src++;
	}	
}

/*
 *   Underrun and suspend recovery
 */
static int xrun_recovery(snd_pcm_t *handle, int err)
{
	printf("xrun_recovery...\n");
	if (err == -EPIPE) {    /* under-run */
		err = snd_pcm_prepare(handle);
		if (err < 0)
			printf("Can't recovery from underrun, prepare failed: %s\n", snd_strerror(err));
		return 0;
	} else if (err == -ESTRPIPE) {
		while ((err = snd_pcm_resume(handle)) == -EAGAIN)
			sleep(1);       /* wait until the suspend flag is released */
		if (err < 0) {
			err = snd_pcm_prepare(handle);
			if (err < 0)
				printf("Can't recovery from suspend, prepare failed: %s\n", snd_strerror(err));
		}
		return 0;
	}
	return err;
}

int setparams(const char *name, snd_pcm_t **handle, snd_pcm_stream_t stream)
{
	int err, dir;
	unsigned int rrate;
	snd_pcm_hw_params_t *hw_params;

	snd_pcm_uframes_t buffer_size;

	if ((err = snd_pcm_open (handle, name, stream, SND_PCM_NONBLOCK)) < 0) {
		fprintf (stderr, "cannot open audio device %s (%s)\n", 
			name,
			snd_strerror (err));
		return err;
	}
	
	if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
		fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
			snd_strerror (err));
		return err;
	}
			
	if ((err = snd_pcm_hw_params_any (*handle, hw_params)) < 0) {
		fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
			snd_strerror (err));
		return err;
	}

	if ((err = snd_pcm_hw_params_set_access (*handle, hw_params, SND_PCM_ACCESS_MMAP_INTERLEAVED)) < 0) {
		fprintf (stderr, "cannot set access type (%s)\n",
			snd_strerror (err));
		return err;
	}

	if ((err = snd_pcm_hw_params_set_format (*handle, hw_params, format)) < 0) {
		fprintf (stderr, "cannot set sample format (%s)\n",
			snd_strerror (err));
		return err;
	}

	// Rate
	rrate = rate;
	printf("Trying to set rate near %d\n", rrate);
	if ((err = snd_pcm_hw_params_set_rate_near (*handle, hw_params, &rrate, 0)) < 0) {
		fprintf (stderr, "cannot set sample rate (%s)\n",
			snd_strerror (err));
		return err;
	}
	printf("Rate set to %d\n", rrate);

	// Buffer (in frames size)
	printf("Trying to set buffer size %d\n", 1024);
	if ((err = snd_pcm_hw_params_set_buffer_size (*handle, hw_params, 1024)) < 0) {
		fprintf (stderr, "cannot set buffer size (%s)\n",
			snd_strerror (err));
		return err;
	}

	if ((err = snd_pcm_hw_params_get_buffer_size (hw_params, &buffer_size)) < 0) {
		fprintf (stderr, "cannot get buffer size (%s)\n",
			snd_strerror (err));
		return err;
	}
	printf("Buffer size set to %ld\n", buffer_size);

	printf("Trying to set period to %ld\n", period_size);
	dir = 0;
	if ((err = snd_pcm_hw_params_set_period_size (*handle, hw_params, period_size, dir)) < 0) {
		fprintf (stderr, "cannot set period_size (%s)\n",
			snd_strerror (err));
		return err;
	}
	printf("Period set to %ld\n", period_size);

	if ((err = snd_pcm_hw_params_set_channels (*handle, hw_params, 2)) < 0) {
		fprintf (stderr, "cannot set channel count (%s)\n",
			snd_strerror (err));
		return err;
	}

	if ((err = snd_pcm_hw_params (*handle, hw_params)) < 0) {
		fprintf (stderr, "cannot set parameters (%s)\n",
			snd_strerror (err));
		return err;
	}

	snd_pcm_hw_params_free (hw_params);

	if ((err = snd_pcm_prepare (*handle)) < 0) {
		fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
			snd_strerror (err));
		return err;
	}
	return 0;
}

int transfer_loop(snd_pcm_t *handle, int *first, area_callback func)
{
	const snd_pcm_channel_area_t *my_areas;
	snd_pcm_uframes_t offset, frames, size;
	snd_pcm_sframes_t avail, commitres;
	snd_pcm_state_t state;
	int err;

	while (1) {
		state = snd_pcm_state(handle);
		if (state == SND_PCM_STATE_XRUN) {
			err = xrun_recovery(handle, -EPIPE);
			if (err < 0) {
				printf("XRUN recovery failed: %s\n", snd_strerror(err));
				return err;
			}
			*first = 1;
		} else if (state == SND_PCM_STATE_SUSPENDED) {
			err = xrun_recovery(handle, -ESTRPIPE);
			if (err < 0) {
				printf("SUSPEND recovery failed: %s\n", snd_strerror(err));
				return err;
			}
		}
		avail = snd_pcm_avail_update(handle);
		if (avail < 0) {
			err = xrun_recovery(handle, avail);
			if (err < 0) {
				printf("avail update failed: %s\n", snd_strerror(err));
				return err;
			}
			*first = 1;
			continue;
		}
		if (avail < period_size) {
			if (*first) {
				*first = 0;
				printf("snd_pcm_start\n");
				err = snd_pcm_start(handle);
				if (err < 0) {
					printf("Start error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
			} else {
				// err = snd_pcm_wait(playback_handle, -1);
				// return to the main loop (poll)
 				return 0;
			}
			continue;
		}
		size = period_size;
		while (size > 0) {
			frames = size;
			err = snd_pcm_mmap_begin(handle, &my_areas, &offset, &frames);
			if (err < 0) {
				if ((err = xrun_recovery(handle, err)) < 0) {
					printf("MMAP begin avail error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				*first = 1;
			}

			func(my_areas, offset, frames);

			commitres = snd_pcm_mmap_commit(handle, offset, frames);
			if (commitres < 0 || (snd_pcm_uframes_t)commitres != frames) {
				if ((err = xrun_recovery(handle, commitres >= 0 ? -EPIPE : commitres)) < 0) {
					printf("MMAP commit error: %s\n", snd_strerror(err));
					exit(EXIT_FAILURE);
				}
				*first = 1;
			}
			size -= frames;
		}
	}
}

int main(int argc, char *argv[])
{
	int i, err;
	snd_pcm_t *handles[2];
	struct pollfd ufds[2];
	unsigned short revents;
	int first[2] = {1, 0};

	for (i = 0; i < 2; i++)
	{
		if (setparams(CARD, &handles[i], descriptors[i].stream) < 0)
		{
			printf("Could not initialize stream %s\n", descriptors[i].name); 
			exit(1);
		}

		assert(snd_pcm_poll_descriptors_count(handles[i]) == 1);
		if ((err = snd_pcm_poll_descriptors(handles[i], &ufds[i], 1)) < 0)
		{
			printf("Unable to obtain poll descriptors for stream %s\n", descriptors[i].name);
			exit(1);
		}
	}

	// The capture stream has to be started manually...
	err = snd_pcm_start(handles[CAPTURE]);
	if (err < 0)
	{
		printf("Start error: %s\n", snd_strerror(err));
		exit(EXIT_FAILURE);
	}

	while (1) {
		err = poll(ufds, 2, -1);

		for (i = 0; i < 2; i++)
		{
			if (snd_pcm_poll_descriptors_revents(handles[i], &ufds[i], 1, &revents) < 0)
			{
				printf("Error getting revents for %s\n", descriptors[i].name);
				exit(1);
			}
	
			if (revents & descriptors[i].poll_flag)
			{
				if (transfer_loop(handles[i], &first[i], descriptors[i].func) < 0)
				{
					printf("transfer_loop error for %s\n", descriptors[i].name);
					// TODO exit?!?
				}
			}
		}
	}

	for (i = 0; i < 2; i++)
	{
		snd_pcm_close (handles[i]);
	}
	exit (0);
}

[-- Attachment #3: Type: text/plain, Size: 160 bytes --]

_______________________________________________
Alsa-devel mailing list
Alsa-devel@alsa-project.org
http://mailman.alsa-project.org/mailman/listinfo/alsa-devel

Re: Any standard ALSA application for simultaneous capture and playabck ?????

[Nobin Mathew]

[-- Attachment #1: Type: text/plain, Size: 2688 bytes --]

I have a single threaded ALSA application which does simultaneous
capture and playback. But i am getting overflow error XRUN from
capture side.

 I am attaching the code to this mail.

Is there any problem with single threaded approach?

Is there any global configuration for ALSA lib?

When i run this app, ALSA state is getting corrupted, even aplay and
arecord is not working properly after that.

Any comments on this issue?

Thanks in advance
Nobin Mathew

On 5/22/07, Ciaccia <ciacciax@yahoo.com> wrote:
> > What are the complications in implementing simultaneous playback and
> > capture in ALSA???
>
>
> I would like to add something to this post: what is the "best" way to
> program a full duplex application? I would like to have an application
> that does full-duplex, with the lowest possible latency and using less
> CPU resource as possible. I tried different approaches, but I was not
> completely satisfied with none of them....
>
>
> Here is what I tried:
> -having two threads, one for playback and one for capture
> -defining 2 callbacks with async_handles and do all the processing in the callback functions
> (the last attempt)
> -using poll() to wait for one of the streams to be ready (see attached file fullduplex.c)
>
> Could some of you look at the attached code (it is not generic and contains lots of asserts, but it's supposed to work only on one single machine) and tell me if the last approach using poll is well structured?
>
> The main loop looks as following:
>
> >    while (1) {
> >        err = poll(ufds, 2, -1);
> >
> >        for (i = 0; i < 2; i++)
> >        {
> >            if (snd_pcm_poll_descriptors_revents(handles[i], &ufds[i], 1, &revents) < 0)
> >            {
> >                printf("Error getting revents for %s\n", descriptors[i].name);
> >                exit(1);
> >            }
> >
> >            if (revents & descriptors[i].poll_flag)
> >            {
> >                if (transfer_loop(handles[i], &first[i], descriptors[i].func) < 0)
> >                {
> >                    printf("transfer_loop error for %s\n", descriptors[i].name);
> >                    // TODO exit?!?
> >                }
> >            }
> >        }
> >    }
>
> and the transfer_loop is a modified version of the loop found in the ALSA examples (pcm.c and latency.c).
> Is this strategy optimal in respect to low latency and low CPU usage?
>
> Every comment is greatly appreciated
> Andrea
>
>
>
>
>
> ____________________________________________________________________________________Luggage? GPS? Comic books?
> Check out fitting gifts for grads at Yahoo! Search
> http://search.yahoo.com/search?fr=oni_on_mail&p=graduation+gifts&cs=bz
>

[-- Attachment #2: Audio.c --]
[-- Type: text/plain, Size: 14915 bytes --]

/********************************************************
 * Copyright (c) 2002 Impulsesoft Pvt. Ltd.			   *
 *					All rights reserved				   *
 *******************************************************/

/*******************************************************
 * Name			:	Audio.c
 * Description	:	Wrapper function to access Audio data
 *                  over Bluetooth module
 *
 * Module		:   PhoneGW
 * Author		:   Mayank
 *
 * Revision No	:   $Revision: 1.11 $
 * Changed On   :   $Date: 2003/10/10 05:17:39 $
 * Changed By   :   $Author: kausik $
 *******************************************************/   

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <errno.h>

#include <sys/ioctl.h>
#include "Audio.h"

#define DEBUG_LOG printf
#define DEBUG_ERR printf
#define SND_PCM_NAME_DEFAULT "default"
#define MONO 1
#define SAMPLE_8000HZ 8000

static int gbPcmOpen = 0 ;
static my_snd_pcm uPcm;
int start_delay = 0;
static size_t g_bits_per_sample;

//#define USE_NEWAPI
#define CAPTURE_ENABLED    
#ifndef USE_NEWAPI
void set_params(snd_pcm_t *puHandle, int iFormat);
#endif

static
int MySndPcmOpen(my_snd_pcm *puPcm,int iCard)
{
    int iResult;
    if ((iResult = snd_pcm_open(&puPcm->playback, 
                                SND_PCM_NAME_DEFAULT, 
                                SND_PCM_STREAM_PLAYBACK, 
                                0)) < 0) 
    {
        DEBUG_ERR("Error: audio open error: %s\n", snd_strerror(iResult));
        return -1;
    }
   
    snd_pcm_info_alloca(&puPcm->playback_info);
    if (snd_pcm_info(puPcm->playback,puPcm->playback_info) < 0)
    {
        DEBUG_ERR("Error in info\n");
        return -1;
    }
   
#ifdef CAPTURE_ENABLED    
    if ((iResult = snd_pcm_open(&puPcm->capture, 
                                SND_PCM_NAME_DEFAULT, 
                                SND_PCM_STREAM_CAPTURE, 
                                0)) < 0) 
    {
        DEBUG_ERR("Error: audio open error: %s\n", snd_strerror(iResult));
        return -1;
    }
   
    snd_pcm_info_alloca(&puPcm->capture_info);
    if (snd_pcm_info(puPcm->capture,puPcm->capture_info) < 0)
    {
        DEBUG_ERR("Error in info\n");
        return -1;
    }  
    //snd_pcm_drain(puPcm->capture);
#endif
    snd_pcm_drain(puPcm->playback);
    return(0);
}

static
int MySetPcmParam(my_snd_pcm *puPcm, int iFragment,int iFormat)
{
#ifdef USE_NEWAPI
    int iRet = -1;
    iRet = snd_pcm_set_params(puPcm->playback,
                       iFormat,
                       SND_PCM_ACCESS_RW_INTERLEAVED,
		               MONO,
		               SAMPLE_8000HZ,
		               0/*Resampling*/,
		               0/*Latency*/);
    if(iRet < 0)
    {
        printf("snd_pcm_set_params(playback) returned error. %d\n", iRet);
        return -1;
    }
    
    g_bits_per_sample = snd_pcm_format_physical_width(iFormat);

#ifdef CAPTURE_ENABLED    
    iRet = snd_pcm_set_params(puPcm->capture,
                       iFormat,
                       SND_PCM_ACCESS_RW_INTERLEAVED,
		               MONO,
		               SAMPLE_8000HZ,
		               0/*Resampling*/,
		               0/*Latency*/); 
    if(iRet < 0)
    {
        printf("snd_pcm_set_params(capture) returned error. %d\n", iRet);
        return -1;
    }
#endif
    snd_pcm_drain(puPcm->playback);

    printf("MySetPcmParam():Before PrepareState:%d\n",snd_pcm_state(puPcm->playback));
    if (snd_pcm_prepare(puPcm->playback) < 0) 
    {
        DEBUG_ERR("unable to prepare channel\n");
        return(-1);
    }
    printf("MySetPcmParam():after prepare-State:%d\n",snd_pcm_state(puPcm->playback));
    
#ifdef CAPTURE_ENABLED    
    snd_pcm_drain(puPcm->capture);
    if (snd_pcm_prepare(puPcm->capture)<0)
    {
	    DEBUG_ERR("unable to set recording channel params\n");
    	return(-1);
    }
#endif
    alsa_print_hw_info();
#else
    
    set_params(puPcm->playback, iFormat);
    start_delay = 1;
    set_params(puPcm->capture, iFormat);
#endif
    
    return(0);
}

void alsa_print_hw_info()
{
    my_snd_pcm *puPcm = &uPcm;
    snd_pcm_uframes_t uBufferSize = 0;
    snd_pcm_uframes_t uPeriodSize = 0;   
    unsigned int iBufferTime = 0, iPeriodTime = 0;   
    unsigned int iPeriods = 0;
    int iErr = 0;
    int dir = 0;

    snd_pcm_hw_params_t *params;
    snd_pcm_hw_params_t *cparams;
    snd_pcm_hw_params_alloca(&params);
    snd_pcm_hw_params_alloca(&cparams);

    snd_pcm_get_params(puPcm->playback,&uBufferSize, &uPeriodSize);	 
    printf("snd_pcm_get_params for playback returned the values as 0x%x, 0x%x\n",uBufferSize,uPeriodSize);
    snd_pcm_get_params(puPcm->capture,&uBufferSize, &uPeriodSize);	 
    printf("snd_pcm_get_params for capture returned the values as 0x%x, 0x%x\n",uBufferSize,uPeriodSize);

    iErr = snd_pcm_hw_params_any(puPcm->playback, params);
    if (iErr < 0) 
    {
        printf("Broken configuration for this PCM: no configurations available\n");
        return;
    }
    
    snd_pcm_hw_params_get_period_size(params, &uPeriodSize, &dir);
    snd_pcm_hw_params_get_period_time(params, &iPeriodTime, &dir);
    snd_pcm_hw_params_get_periods(params, &iPeriods, &dir);
    snd_pcm_hw_params_get_buffer_size(params, &uBufferSize); 
    snd_pcm_hw_params_get_buffer_time(params, &iBufferTime, &dir); 
    printf("alsa_print_hw_info():  buffersize:0x%x periodsize:0x%x\n"
            "buffertime:0%x periodtime:%x periods:0x%x\n",
            uBufferSize, uPeriodSize,iBufferTime, iPeriodTime, iPeriods);
    
    iErr = snd_pcm_hw_params_any(puPcm->capture, cparams);
    if (iErr < 0) 
    {
        printf("Broken configuration for this PCM: no configurations available\n");
        return;
    }
    snd_pcm_hw_params_get_period_size(cparams, &uPeriodSize, &dir);
    snd_pcm_hw_params_get_period_time(cparams, &iPeriodTime, &dir);
    snd_pcm_hw_params_get_periods(cparams, &iPeriods, &dir);
    snd_pcm_hw_params_get_buffer_size(cparams, &uBufferSize); 
    snd_pcm_hw_params_get_buffer_time(cparams, &iBufferTime, &dir); 
    printf("alsa_print_hw_info():  buffersize:0x%x periodsize:0x%x\n"
            "buffertime:0%x periodtime:%x periods:0x%x\n",
            uBufferSize, uPeriodSize,iBufferTime, iPeriodTime, iPeriods);

}

int wait_for_pcm_ready()
{
    my_snd_pcm *puPcm = &uPcm;
    snd_pcm_wait(puPcm->playback, 10);
    snd_pcm_wait(puPcm->capture, 10);
}
int ReadFromAlsa(void *buf, int len)
{
    my_snd_pcm *puPcm = &uPcm;
    snd_pcm_uframes_t uNumFrames = (len * 8)/(g_bits_per_sample*1);
    if (gbPcmOpen)
    {
        int iLen;
        static iiLen = 0;
        iLen = snd_pcm_mmap_readi(puPcm->capture, buf, uNumFrames);
        if(iLen == -EAGAIN)
        {
            /* Wait for a max of 10 ms for pcm to get ready/be in a sane state*/
            printf("ReadFromAlsa(): read error EAGAIN\n");
            printf("WriteToAlsa():State:%d\n",snd_pcm_state(puPcm->capture));
            snd_pcm_wait(puPcm->playback, 10);
            return iLen;
        }
        else if(iLen == -EPIPE)
        {
            printf("ReadFromAlsa():State:%d, iiLen=%d\n",snd_pcm_state(puPcm->capture),iiLen);
            iiLen = 0;
            snd_pcm_drain(puPcm->capture);
            if (snd_pcm_prepare(puPcm->capture)<0)
            {
	            DEBUG_ERR("unable to set recording channel params\n");
            	return 0;
            }
            printf("ReadFromAlsa():State:%d\n",snd_pcm_state(puPcm->capture));
            return 0;
        }
        else if(iLen <= 0)
        {
            printf("ReadFromAlsa():State:%d\n",snd_pcm_state(puPcm->capture));
            printf("ReadFromAlsa(): read error %d\n", iLen);
            return iLen;
        }
        iiLen += iLen;
        return iLen*((g_bits_per_sample*1)/8);
    }
    else
        return -EBADF;
}

int WriteToAlsa(void *buf, int len)
{
    my_snd_pcm *puPcm = &uPcm;
    snd_pcm_uframes_t uNumFrames = (len * 8)/(g_bits_per_sample*1);
    //printf("WriteToAlsa():State:%d\n",snd_pcm_state(puPcm->playback));
    if (gbPcmOpen)
    {
        int iLen;
        static iiLen = 0;
        iLen = snd_pcm_mmap_writei(puPcm->playback, buf, uNumFrames);
        if(iLen == -EPIPE)
        {
            printf("WriteToAlsa():State:%d, iiLen=%d\n",snd_pcm_state(puPcm->playback),iiLen);
            iiLen = 0;
            snd_pcm_drain(puPcm->playback);
            if (snd_pcm_prepare(puPcm->playback)<0)
            {
            	//return 0;
            }
            printf("WriteToAlsa():State:%d\n",snd_pcm_state(puPcm->playback));
            return 0;
        }
        else if(iLen < 0)
        {
            return iLen;
        }
        iiLen += iLen;
        return iLen*((g_bits_per_sample*1)/8);
    }
    else
        return -EBADF;
}
static snd_output_t *log;

int StartAudio(int iFragment, int iFormat)
{
    my_snd_pcm *puPcm = &uPcm;
    int err;
    
	err = snd_output_stdio_attach(&log, stderr, 0);
	assert(err >= 0);

    
    if (!gbPcmOpen)
    {
        if (MySndPcmOpen(puPcm,0) < 0)
        return -1;
        
        if (MySetPcmParam(puPcm, iFragment,iFormat) < 0)
        {
            printf("MySetPcmParam(): Failed\n");
            return -1;
        }
        gbPcmOpen = 1 ;
    }
    else
        DEBUG_ERR("Audio Device is already opened\n");
    return 0;
}

int StopAudio()
{
    my_snd_pcm *puPcm = &uPcm;

    DEBUG_LOG("Closing Audio device\n");
    if (gbPcmOpen)
    {
        gbPcmOpen = 0 ;
        snd_pcm_drain(puPcm->playback);
        snd_pcm_drain(puPcm->capture);
        snd_pcm_close(puPcm->playback);
        snd_pcm_close(puPcm->capture);
    }
    snd_output_close(log);
    snd_config_update_free_global();
    return 0;
}

#ifndef USE_NEWAPI /* Aplay set params.. storing for adversity :) */
void set_params(snd_pcm_t *puHandle, int iFormat)
{
    snd_pcm_uframes_t chunk_size = 0;
    unsigned period_time = 0;
    unsigned buffer_time = 0;
    snd_pcm_uframes_t period_frames = 0;
    snd_pcm_uframes_t buffer_frames = 0;
    unsigned int sleep_min = 0;
    int avail_min = -1;
    int mmap_flag = 1;
    int stop_delay = 0;
    size_t bits_per_frame;
    size_t chunk_bytes;

	snd_pcm_hw_params_t *params;
	snd_pcm_sw_params_t *swparams;
	snd_pcm_uframes_t buffer_size;
	int err;
	size_t n;
	snd_pcm_uframes_t xfer_align;
	unsigned int rate;
	snd_pcm_uframes_t start_threshold, stop_threshold;
	snd_pcm_hw_params_alloca(&params);
	snd_pcm_sw_params_alloca(&swparams);
	err = snd_pcm_hw_params_any(puHandle, params);
	if (err < 0) {
		printf("Broken configuration for this PCM: no configurations available");
        return;
	}
       	if(mmap_flag)
	{
	snd_pcm_access_mask_t *mask = alloca(snd_pcm_access_mask_sizeof());
	snd_pcm_access_mask_none(mask);
	snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_INTERLEAVED);
	snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_NONINTERLEAVED);
	snd_pcm_access_mask_set(mask, SND_PCM_ACCESS_MMAP_COMPLEX);
	err = snd_pcm_hw_params_set_access_mask(puHandle, params, mask);
	}
	
       	
//    err = snd_pcm_hw_params_set_access(puHandle, params,
//	                                   SND_PCM_ACCESS_RW_INTERLEAVED);
	if (err < 0) {
		printf("Access type not available\n");
        return;
	}
	err = snd_pcm_hw_params_set_format(puHandle, params, iFormat);
	if (err < 0) {
		printf("Sample format non available\n");
        return;
	}
	err = snd_pcm_hw_params_set_channels(puHandle, params, 1);
	if (err < 0) {
		printf("Channels count non available");
        return;
	}

	rate = SAMPLE_8000HZ;
	err = snd_pcm_hw_params_set_rate_near(puHandle, params, &rate, 0);
	
	if (buffer_time == 0 && buffer_frames == 0)
	{
	err = snd_pcm_hw_params_get_buffer_time_max(params,
							    &buffer_time, 0);
		assert(err >= 0);
		if (buffer_time > 500000)
			buffer_time = 500000;
	}
        printf("ALSA : BufferTime = %d\n",buffer_time);
	if (period_time == 0 && period_frames == 0) {
		if (buffer_time > 0)
			period_time = buffer_time / 4;
		else
			period_frames = buffer_frames / 4;
	}
    printf("ALSA : period_time=%x, period_frames=%x, buffer_time=%x, buffer_frames=%x\n",
            period_time,period_frames,buffer_time,buffer_frames);
	if (period_time > 0)
		err = snd_pcm_hw_params_set_period_time_near(puHandle, params,
							     &period_time, 0);
	else
		err = snd_pcm_hw_params_set_period_size_near(puHandle, params,
							     &period_frames, 0);
	assert(err >= 0);
	if (buffer_time > 0) {
		err = snd_pcm_hw_params_set_buffer_time_near(puHandle, params,
							     &buffer_time, 0);
	} else {
		err = snd_pcm_hw_params_set_buffer_size_near(puHandle, params,
							     &buffer_frames);
	}
	assert(err >= 0);
	err = snd_pcm_hw_params(puHandle, params);
	if (err < 0) {
		printf("Unable to install hw params:");
        return;
	}
	snd_pcm_hw_params_get_period_size(params, &chunk_size, 0);
	snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
	if (chunk_size == buffer_size) {
		printf("Can't use period equal to buffer size (%lu == %lu)",
		      chunk_size, buffer_size);
        return;
	}
	snd_pcm_sw_params_current(puHandle, swparams);
	err = snd_pcm_sw_params_get_xfer_align(swparams, &xfer_align);
	if (err < 0) {
		printf("Unable to obtain xfer align\n");
        return;
	}
	
	if (sleep_min)
		xfer_align = 1;
	
	err = snd_pcm_sw_params_set_sleep_min(puHandle, swparams,
					      sleep_min);
	assert(err >= 0);
	if(avail_min < 0)
		n = chunk_size;
	else 
		n = (double) rate * avail_min/1000000;

	err = snd_pcm_sw_params_set_avail_min(puHandle, swparams, n);

	/* round up to closest transfer boundary */
	n = (buffer_size / xfer_align) * xfer_align;
	if (start_delay <= 0) {
		start_threshold = n + (double) rate * start_delay / 1000000;
	} else
		start_threshold = (double) rate * start_delay / 1000000;
	if (start_threshold < 1)
		start_threshold = 1;
	if (start_threshold > n)
		start_threshold = n;
	err = snd_pcm_sw_params_set_start_threshold(puHandle, swparams, start_threshold);
	assert(err >= 0);
	if (stop_delay <= 0) 
		stop_threshold = buffer_size + (double) rate * stop_delay / 1000000;
	else
		stop_threshold = (double) rate * stop_delay / 1000000;

	err = snd_pcm_sw_params_set_stop_threshold(puHandle, swparams, stop_threshold);
	assert(err >= 0);

	err = snd_pcm_sw_params_set_xfer_align(puHandle, swparams, xfer_align);
	assert(err >= 0);

	if (snd_pcm_sw_params(puHandle, swparams) < 0) {
		printf("unable to install sw params:");
        return;
	}

	g_bits_per_sample = snd_pcm_format_physical_width(iFormat);
	bits_per_frame = g_bits_per_sample * 1;
	chunk_bytes = chunk_size * bits_per_frame / 8;

	snd_pcm_dump(puHandle, log);

    
    printf("ALSA : period_time=0x%x, period_frames=0x%x, buffer_time=0x%x, buffer_frames=0x%x\n",
            period_time,period_frames,buffer_time,buffer_frames);
    printf("chunk_size:%d chunk_bytes:%d bits/frame:%d b/s:%d\n",
            chunk_size, chunk_bytes, bits_per_frame, g_bits_per_sample);
    return;
}
#endif 


[-- Attachment #3: Audio.h --]
[-- Type: application/octet-stream, Size: 1481 bytes --]

/*******************************************************
                Copyright Notice
        Copyright (c) 2002 Impulsesoft Pvt. Ltd.
                All rights reserved  
        Impulsesoft Proprietary And Confidential
 *******************************************************

 *******************************************************
 Name           :   Audio.h
 Description    :   This file declares functions used to
                    Access Bluetooth Audio data

 Module         :   Phone Gateway
 Author         :   Mayank
 Date           :   02/05/2003

 Revision No	:   $Revision: 1.7 $
 Changed On     :   $Date: 2003/10/10 05:17:39 $
 Changed By     :   $Author: kausik $
 *******************************************************/ 



#ifndef _AUDIO_H_
#define _AUDIO_H_


#define SPEED		8000

/* Define the supported Formats */
#define IPCOM_SND_FMT_PCM       1
#define IPCOM_SND_FMT_ULAW      2
#define IPCOM_SND_FMT_G729      3

#include <alsa/asoundlib.h>

#ifndef __cplusplus
#ifdef EXTERN
#undef EXTERN
#endif
#define EXTERN
typedef struct
{
   snd_pcm_t *playback;
   snd_pcm_info_t *playback_info;
   snd_pcm_t *capture;
   snd_pcm_info_t *capture_info;
} my_snd_pcm;
#else
#ifdef EXTERN
#undef EXTERN
#endif
#define EXTERN  extern "C"
#endif /* __cplusplus */
    
EXTERN int ReadFromAlsa(void *buf, int len);
EXTERN int WriteToAlsa(void *buf, int len);
EXTERN int StartAudio(int iFragment,int iFormat);
EXTERN int StopAudio(void);

#endif /* _AUDIO_H_ */

[-- Attachment #4: test.c --]
[-- Type: text/plain, Size: 3029 bytes --]

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <termio.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
//#include "ipc-char-ioctls.h"
#include <sys/signal.h>
#include <signal.h>
#include <alsa/asoundlib.h>
#include <sys/time.h>
#include <time.h>

typedef int int32;
typedef unsigned int uint32;
typedef char int8;
typedef unsigned char uint8;

#define SCO_CHUNK_SIZE 256
#define PRINT
#define CAPTURE_ENABLED
int uninit(int iIpcFd);

int StartAudio(int iFragment, int iFormat);
int StopAudio();
int ReadFromAlsa(void *buf, int len);
int WriteToAlsa(void *buf, int len);

//GSC3A_CREATE_MODULEID(OSA);

int giIpcFd = -1;
int giAudFd = -1;
int ghUpstreamThread = 0;

void usage()
{
    printf("USAGE:\n\t<exe> </dev/ipc...> <file to be sent>");    
    printf("Example:\tipcsco-tester /dev/ipcttysco sine.wav");    
}
int iAudioFd = -1;
void signal_handler(int sig)
{
    switch(sig)
	{
	case SIGHUP:
	    {
		}break;
	case SIGTERM:
		{
            if(iAudioFd>=0)
            {
                close(iAudioFd);
            }
            printf("Calling Uninit");
            uninit(giIpcFd);
            printf("Exiting \n");
            exit(0);
        }break;
    }
}


int StartPlaybackAndCapture(int ipcFD)
{
    unsigned char acData[SCO_CHUNK_SIZE];
    int iCount;
    int iCount123;
    
    printf("Start the while looop\n");
    //iCount123 = WriteToAlsa(acData,SCO_CHUNK_SIZE);
    while(1)
    {
#ifdef CAPTURE_ENABLED	    
        //gettimeofday(&start, &tz);
        //iCount = ReadFromAlsa(acData, SCO_CHUNK_SIZE);
        iCount = ReadFromAlsa(acData, SCO_CHUNK_SIZE);
	//printf("Written iCount\t%d\n", iCount);
#else
	iCount = read(giAudFd,acData,SCO_CHUNK_SIZE);
#endif
        if(iCount < 0)
        {
            printf("Read Error. %d\n", iCount);
            break;
        }
        else if(iCount == 0)
        {
            printf("Overflow state\n");
#ifndef CAPTURE_ENABLED
	    lseek(giAudFd, 0, SEEK_SET);
#endif	    
            continue;
        }
        {
	//	iCount = 0;
//printf("");	
            iCount = WriteToAlsa(acData,iCount);
            if (iCount < 0)
            {
                printf("Write Error : %d\n",iCount);
                break;
            }
        }
        
    }

    return 0;
}

int main(int argc, char *argv[])
{
    int iIpcFd = -1;
    if(argc < 2)
    {
        usage();
        return -1;
    }
    else
    {
        printf("In Execution  - [%s %s]\n", argv[0], argv[1]);
    }
   
    signal(SIGHUP,signal_handler); /* catch hangup signal */
	signal(SIGTERM,signal_handler); /* catch kill signal */

    StartAudio(SCO_CHUNK_SIZE, SND_PCM_FORMAT_S16_LE);
#ifndef CAPTURE_ENABLED
    giAudFd = open(argv[2],O_RDONLY);
    if(giAudFd < 0)
    {
        printf("OPeing Audio file failed \n");
	return -1;
    }
#endif 
    StartPlaybackAndCapture(iIpcFd);
    uninit(iIpcFd);
    return 0;
}

int uninit(int iIpcFd)
{
    StopAudio();
#ifndef CAPTURE_ENABLED
    close(giAudFd);
#endif 
    return 0;
}

[-- Attachment #5: Type: text/plain, Size: 160 bytes --]

_______________________________________________
Alsa-devel mailing list
Alsa-devel@alsa-project.org
http://mailman.alsa-project.org/mailman/listinfo/alsa-devel

Re: Any standard ALSA application for simultaneous capture and playabck ?????

[Ciaccia]

It looks like your application uses the following pattern:

for (;;) {
    ReadFromAlsa
    WriteToAlsa
}

The ReadFormAlsa function waits for the capture channel to become available (i.e., there is some data to be read), while WriteToAlsa waits till the output buffer becomes available (i.e., it's possible to send data to the card without blocking).

Ho do you know that this is the correct order? Could it be that you should before write data to the output buffer and then read data from the capture stream? I think your design is not completely correct...

Look at my code, it works fine, but maybe there is a better approach...


Andrea



----- Original Message ----
From: Nobin Mathew <nobin.mathew@gmail.com>
To: Ciaccia <ciacciax@yahoo.com>
Cc: alsa-devel@alsa-project.org
Sent: Tuesday, May 22, 2007 10:53:54 AM
Subject: Re: [alsa-devel] Any standard ALSA application for simultaneous capture and playabck ?????

I have a single threaded ALSA application which does simultaneous
capture and playback. But i am getting overflow error XRUN from
capture side.

 I am attaching the code to this mail.

Is there any problem with single threaded approach?

Is there any global configuration for ALSA lib?

When i run this app, ALSA state is getting corrupted, even aplay and
arecord is not working properly after that.

Any comments on this issue?

Thanks in advance
Nobin Mathew

On 5/22/07, Ciaccia <ciacciax@yahoo.com> wrote:
> > What are the complications in implementing simultaneous playback and
> > capture in ALSA???
>
>
> I would like to add something to this post: what is the "best" way to
> program a full duplex application? I would like to have an application
> that does full-duplex, with the lowest possible latency and using less
> CPU resource as possible. I tried different approaches, but I was not
> completely satisfied with none of them....
>
>
> Here is what I tried:
> -having two threads, one for playback and one for capture
> -defining 2 callbacks with async_handles and do all the processing in the callback functions
> (the last attempt)
> -using poll() to wait for one of the streams to be ready (see attached file fullduplex.c)
>
> Could some of you look at the attached code (it is not generic and contains lots of asserts, but it's supposed to work only on one single machine) and tell me if the last approach using poll is well structured?
>
> The main loop looks as following:
>
> >    while (1) {
> >        err = poll(ufds, 2, -1);
> >
> >        for (i = 0; i < 2; i++)
> >        {
> >            if (snd_pcm_poll_descriptors_revents(handles[i], &ufds[i], 1, &revents) < 0)
> >            {
> >                printf("Error getting revents for %s\n", descriptors[i].name);
> >                exit(1);
> >            }
> >
> >            if (revents & descriptors[i].poll_flag)
> >            {
> >                if (transfer_loop(handles[i], &first[i], descriptors[i].func) < 0)
> >                {
> >                    printf("transfer_loop error for %s\n", descriptors[i].name);
> >                    // TODO exit?!?
> >                }
> >            }
> >        }
> >    }
>
> and the transfer_loop is a modified version of the loop found in the ALSA examples (pcm.c and latency.c).
> Is this strategy optimal in respect to low latency and low CPU usage?
>
> Every comment is greatly appreciated
> Andrea
>
>
>
>
>
> ____________________________________________________________________________________Luggage? GPS? Comic books?
> Check out fitting gifts for grads at Yahoo! Search
> http://search.yahoo.com/search?fr=oni_on_mail&p=graduation+gifts&cs=bz
>






 
____________________________________________________________________________________
Need Mail bonding?
Go to the Yahoo! Mail Q&A for great tips from Yahoo! Answers users.
http://answers.yahoo.com/dir/?link=list&sid=396546091

Any standard ALSA application for simultaneous capture and playabck ?????

[Nobin Mathew]

Hi,

Is there any standard ALSA appplication which does simultaneous
capture and playback??

What are the complications in implementing simultaneous playback and
capture in ALSA???

What are the plugin (.asoundrc) configurations needed for simultaneous
playback and capture????

Thanks
Nobin Mathew

Re: Any standard ALSA application for simultaneous capture and playabck ?????

[James Courtier-Dutton]

Nobin Mathew wrote:
> Hi,
> 
> Is there any standard ALSA appplication which does simultaneous
> capture and playback??
> 
> What are the complications in implementing simultaneous playback and
> capture in ALSA???
> 
> What are the plugin (.asoundrc) configurations needed for simultaneous
> playback and capture????
> 
> Thanks
> Nobin Mathew

You might want to look at jackd. It down full duplex low latency.
It really depends on your application as to how you program alsa to do
the job. Will your application want one thread for both capture and
playback, or one thread for capture, and one for playback?

James

Re: Any standard ALSA application for simultaneous capture and playabck ?????

[Nobin Mathew]

 I am using single thread for both capture and playback




On 5/24/07, James Courtier-Dutton <James@superbug.co.uk> wrote:
> Nobin Mathew wrote:
> > Hi,
> >
> > Is there any standard ALSA appplication which does simultaneous
> > capture and playback??
> >
> > What are the complications in implementing simultaneous playback and
> > capture in ALSA???
> >
> > What are the plugin (.asoundrc) configurations needed for simultaneous
> > playback and capture????
> >
> > Thanks
> > Nobin Mathew
>
> You might want to look at jackd. It down full duplex low latency.
> It really depends on your application as to how you program alsa to do
> the job. Will your application want one thread for both capture and
> playback, or one thread for capture, and one for playback?
>
> James
>
>