Hi,

Thanks Stan, for your response - Instead of copying pcm data from a wav file, i decided to copy all the data to a master buffer first and then see if the circular buffer implementation works -

so now instead of copying from the wave file, i m copying data from the master buffer to the circular buffer.. however, as per your suggestion, if i copy the data in the while loop in main, then, it might not always be copied between 2 consecutive callbacks, but maybe more, as the callbacks are asynchronous.

however, the hardware still does not ask for more data after executing the callback function about twice -- is there a way to flush the hardware buffer before beginning playback? I have pasted my code below

Regards, Ashlesha.

/* Reading wav file into a buffer and then trying to play it */

#include <stdio.h> #include </usr/include/alsa/asoundlib.h> #include </usr/include/alsa/pcm.h> #include <sys/types.h> #include <unistd.h> #include <fcntl.h>

#define SIZE 128 //mpos is the position in the master buffer to write from short int *buffer, *mbuf, *mpos; int ind=10, fd1, length; static snd_pcm_t *handle; static char *device = "default"; /* playback device */ snd_output_t *output = NULL; static short int *wto, *rfrom, buflen;

void MyCallback(snd_async_handler_t *pcm_callback);

int main() { int i,j,n,count,a,err,k=0; char c; snd_pcm_sframes_t frames; snd_async_handler_t *pcm_callback;

if((fd1=open("SA2.WAV",O_RDONLY,0))==-1)
    printf("error opening wav file\n");

count=0;
while(count++<40)
    a=read(fd1,&c,sizeof(char));

a=read(fd1,&length,sizeof(int));

n=length/SIZE;

printf("length = %d\n",length);
mbuf = (short int *) malloc (length * sizeof(short int));
mpos = &mbuf[0];

buflen = 4*SIZE;
buffer = (short int *) malloc (buflen*sizeof(short int));

wto = NULL;
rfrom = &buffer[0];

/* reading to master buffer */
count=0;
a=1;
while(count<length && a>0)
    a=read(fd1,&mbuf[count++],sizeof(short int));
if(a<0){
    printf("error in reading from wav file\n");
    exit(1);
    }
close (fd1);

for(count =0; count < buflen; count++)
{
    buffer[count]=mbuf[count];
}
/******************************/

/*ALSA DEV INIT*/
if((err = snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK, 0)) <

0. { printf("error opening device: %s\n",snd_strerror(err)); return -1; }

   if((err = snd_pcm_set_params(handle, SND_PCM_FORMAT_S16_LE, SND_PCM_ACCESS_RW_INTERLEAVED, 1, 16000, 1, 1000)) < 0) { /* 2 sec */ printf("Playback open error: %s\n", snd_strerror(err)); return -2; } /*****************************/

   printf("n=%d\n",n); for (i=0; i<50; i++) { printf("i=%d\n",i); frames = snd_pcm_writei(handle, rfrom, SIZE); if(frames < 0) // underrun { printf("underrun recovery\n"); frames = snd_pcm_recover(handle, frames,0); if(frames < 0){ printf("error in recovery\n"); return -3; } } if(frames >0 && frames < SIZE) printf("expected to write %d, wrote %d\n",SIZE,frames);

    printf("distance between ptrs before reinit is %d\n",rfrom - wto);
    if(rfrom < &buffer[buflen-1])
        {
            wto = rfrom;
            rfrom = rfrom + SIZE;
        }
    if(rfrom >= &buffer[buflen-1])
        {
            printf("rfm at the end, rfrom -buffer[buflen-1]
   

=%d\n",(*rfrom - buffer[buflen-1])); //wto = rfrom; rfrom = &buffer[0]; }

    if((a = writetobuf())<0)
            printf("error in reading from wav file k = %d\n");

    printf("buffer[i*SIZE] - rfrom = %d\n",(buffer[(i+1)*SIZE] -

*rfrom));

}

/* Async Handler */


err = snd_async_add_pcm_handler(&pcm_callback,handle,MyCallback,NULL);
if(err<0)
    printf("add pcm handler error = %d\n%s\n",err,snd_strerror(err));

err = snd_pcm_start(handle);
if(err<0)
    printf("error in starting snd pcm start err

:%s\n",snd_strerror(err)); /******************************/

while (1) {

             if(wto == NULL)
                break;      // redundancy -- already checking for this

condition in MyCallback printf("infinite loop\n"); sleep(1); }

err = snd_pcm_close(handle);
if(err<0)
    printf("error in closing pcm device: %s\n",snd_strerror(err));

return 0;

}

void MyCallback(snd_async_handler_t *pcm_callback) {

snd_pcm_t *pcm_handle = snd_async_handler_get_pcm(pcm_callback);
snd_pcm_sframes_t avail;
int count,a;
snd_pcm_uframes_t period_size = 64;
snd_pcm_sframes_t frames;

if((avail=snd_pcm_avail_update(pcm_handle)) >= period_size)
    {
        printf("available frames = %d\n",avail);
        frames = snd_pcm_writei(pcm_handle, rfrom, SIZE);
        if(frames < 0)              // underrun
        {
            printf("underrun recovery\n");
            frames = snd_pcm_prepare(pcm_handle);
            printf("error from snd_pcm_prepare is: %d\n",frames);
            if(frames < 0){
                printf("error in recovery\n");

                }
        }

        if(frames >0 && frames < SIZE)
            printf("expected to write %d, wrote %d\n",SIZE,frames);


        if(rfrom < &buffer[buflen-1])
            {
                wto = rfrom;
                rfrom = rfrom + SIZE;
            }
        if(rfrom >= &buffer[buflen-1])
            {

// wto = rfrom; rfrom = &buffer[0]; } //location of where to start writing from next

        if(writetobuf()<0){
            wto=NULL;
            exit(0); // returns 0 to the operating system -- so it

ends the program! } ++ind; }

    printf("going out of callback, ind = %d\n",ind);

}

/*Function to copy data from master buffer (mbuf) to circular buffer (buffer)*/ int writetobuf() { int count=-1;

while((++count < SIZE) && (mpos < &mbuf[length]))
    *(mpos++) = *(wto+count);

if(mpos >= &mbuf[length-1])
    return -1;
else
    return 0;

}