DM365 Audio capture -- Rate problem

Capture example program.

~ # cat src/audcap.c
/**
 * @file audcap.c
 * @brief Program to illustrate /dev/dsp device
 */

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <linux/soundcard.h>
#include <unistd.h>
#include <sys/time.h>


int   rate = 48000;              // base sampling rate 48Khz
int   samp_size = 16;            // 2 bytes per sample
int   verbose   = 0;             // verbose level - default is no debug
int   channels  = 2;             // stereo - 2 channels per sample
char  fname[80] = "/dev/null";   // do not store result

double buf_dur   = 0.5;         // default -- read data in 500ms chunks
double dur       = 10.0;        // default -- record 10 seconds
int    force_sz  = 0;           // force input buffersize

/*
 * @brief number of seconds since last timer reset
 */
static double base_tm =  0.0;

/* @brief get number of seconds since timer reset
 *
 */
double get_time()
{
        // faster method?
        struct timeval   tv;
        double tm;
        gettimeofday( &tv, NULL);
        tm =  (1.0*tv.tv_usec) / 1000.0 / 1000.0;   // microseconds
        tm += (double) tv.tv_sec;                   // full seconds
        return tm - base_tm;
}


/*
 * @brief reset time origin
 */
void  init_time()
{
        base_tm = get_time();
}

void hexdump( void *ptr, int len, char *banner, int arg)
{
        int ofs;
        unsigned char *byte_ptr = (unsigned char *) ptr;

        printf("%s(%d) %d bytes @ 0x%p\n",
               banner, arg, len, ptr);
        for (ofs = 0; ofs < len ; ofs +=16) {
                printf("%08x: ", ofs);
                printf("%02x %02x %02x %02x %02x %02x %02x %02x . ",
                       byte_ptr[0], byte_ptr[1], byte_ptr[2], byte_ptr[3],
                       byte_ptr[4], byte_ptr[5], byte_ptr[6], byte_ptr[7]);
                byte_ptr += 8;
                printf("%02x %02x %02x %02x %02x %02x %02x %02x\n",
                       byte_ptr[0], byte_ptr[1], byte_ptr[2], byte_ptr[3],
                       byte_ptr[4], byte_ptr[5], byte_ptr[6], byte_ptr[7]);
                byte_ptr += 8;
        }
}




void args( int argc, char *argv[])
{
        //int flags;
        int opt;

        // getopt
        while (( opt = getopt( argc, argv,"z:g:d:c:v:r:o:")) != -1) {
                switch (opt) {
                case 'z':
                    force_sz = atoi(optarg);
                    printf(" -- force capture size to  %d/0x%x\n",
                           force_sz, force_sz);
                    break;
                case 'g':
                        buf_dur =  1.0 *atoi(optarg)/1000.0;
                        printf(" -- cap_seg  set to %dms\n",
                               (int) (buf_dur/1000));
                        break;
                case 'd':
                        dur =  1.0 *atoi(optarg);
                        printf(" -- duration  set to %f\n", dur);
                        break;
                case 'c':
                        channels = atoi(optarg);
                        printf(" -- channels set to %d\n", channels);
                        break;
                case 'v':
                        verbose = atoi(optarg);
                        printf(" -- verbose set to %d\n", verbose);
                        break;
                case 'r':
                        rate = atoi(optarg);
                        printf(" -- rate set to %d\n", rate);
                        break;
                case 'o':
                        strcpy(fname, optarg);
                        printf(" -- output file is '%s'\n", fname);
                        break;
                default:
                        fprintf(stderr,
                                "Usage: %s "
                                " -d <duration_in_s>"
                                " -c <channels>"
                                " -v <verbose>"
                                " -r <rate>"
                                " -o <output_fname>"
                                " -g <segment_size_in_ms> \n"
                                " -z <force read buffer size in bytes> \n",
                                argv[0]);
                        exit( -1);
                }
        }
}



int main( int argc, char *argv[])
{
        int f_in;       /* sound device file descriptor */
        FILE *fd_out;   /* file output  */
        int arg;        /* argument for ioctl calls */
        int status;     /* return status of system calls */
        int nbytes;     /* number of bytes read */
        double t0, tdiff;

        /* this buffer holds the digitized audio */
        unsigned char *buf;
        int            buf_sz;

        args(argc, argv);

        printf("Audcap:  "
               "\trate=%d, samp_size=%d, num_channels=%d\n"
               "\tbuffer is 0x%x/%d bytes\n",
               rate, channels, channels,
               sizeof buf, sizeof buf);

        init_time();

        if (verbose > 0) {
                t0 = get_time(); sleep(2); tdiff = get_time() - t0;
                printf("!! timecheck: 2sec = %f\n", tdiff);
        }

        buf_sz = (int) (buf_dur * rate * channels * samp_size /8);
        if ( force_sz) {
            buf_sz = force_sz;
            buf_dur = 8.0*buf_sz / rate / channels / samp_size;
        }

        buf = malloc(buf_sz);
        if ( buf == NULL) {
                perror("Memory Error");
                return -1;
        }

        /* open sound device */
        f_in = open("/dev/dsp", O_RDWR);
        if (f_in < 0) {
                perror("open of /dev/dsp failed\n");
                exit(1);
        }

        /* open sound device */
        fd_out = fopen (fname, "rw+" );
        if (fd_out < 0) {
            printf("create of '%s' failed\n", fname);
            perror("create failed\n");
                exit(1);
        }

        char raw_buf[32768];
        setvbuf( fd_out, raw_buf, _IOFBF, sizeof raw_buf);

        // set sampling parms:
        //        -- 2 bytes per sample
        //        -- num channels
        //        -- sampling rate

        // need to make this an argument!!!
        arg = AFMT_S16_LE;
        status = ioctl(f_in, SNDCTL_DSP_SETFMT, &arg);
        if (status == -1)
                perror("SOUND_SNDCTRL_DSP_SETFMT ioctl failed");
        if (arg != AFMT_S16_LE)
                perror("audcap: unable to set fmt\n");

        arg = channels;  /* mono or stereo */
        status = ioctl(f_in, SNDCTL_DSP_CHANNELS, &arg);
        if (status == -1)
                perror("SOUND_SNDCTRL_DSP_CHANNELS ioctl failed");
        if (arg != channels)
                printf("audcap:unable to set number of channels\n");

        arg = rate;        /* sampling rate */
        status = ioctl(f_in, SNDCTL_DSP_SPEED, &arg);
        if (status == -1)
                perror("SOUND_SNDCTRL_DSP_SPEED ioctl failed");
        if (arg != rate)
                printf("audcap:unable to set rate (%d,%d)\n",
                       arg,rate);

        printf("Starting Capture using buffer_sz=%d:\n", buf_sz);

        double secs = 0;
        double tstart = get_time();
        double err;
        t0 = get_time();
        while (secs <  dur) {
                nbytes = read(f_in, buf, buf_sz); /* capture some sound */
                tdiff = get_time() - t0;
                t0 = get_time();
                if (nbytes != buf_sz) {
                        //perror("read wrong number of bytes");
                        printf("read asks for %d bytes, but gets %d bytes\n",
                               buf_sz, nbytes);
                }
                fwrite(buf, nbytes, 1, fd_out);  /* save it */
                printf("%5.2f:",secs);
                err =  100.0 * (tdiff/buf_dur) - 100.0;
                printf("%10.2f bps (%8.2f samp/s): "
                       "%d in %5.3fs (er=%6.2f%%)%s",
                       (1.0*nbytes/tdiff),
                       (8.0*nbytes/samp_size/channels)/tdiff,
                       nbytes, tdiff,
                       err, (abs((int) err) > 2)? "!!" : "  ");


                if (verbose > 2) {
                        hexdump( buf, 2*16, "Audio @", secs);
                }
                if (1) {
                    int      j;
                    int      max_index = 0;
                    int      min_index = 0;
                    int16_t  max = 0;
                    int16_t  min = 16384;
                    int16_t *aud_buf = ( int16_t *) buf;
                    for ( j = 0; j < nbytes/2; j++) {
                        if ( abs(aud_buf[j]) > max) {
                            max_index = j;
                            max = abs(aud_buf[j]);
                        }
                        if ( abs(aud_buf[j]) < min) {
                            min_index = j;
                            min = abs(aud_buf[j]);
                        }
                    }
                    printf(" max@%06x=%04x\n",
                           (int)max_index, (int)max);
                }
                secs += buf_dur;
        }
        double total_tdiff = get_time() - tstart;


        printf("... total capture time is %10.5f, total error = %7.3f %%\n",
               total_tdiff, ( 100* (total_tdiff - dur)/dur));

        fclose(fd_out);
        close(f_in);

        return 0;
}

~ #