0

Hi,
I am trying to change this program to compile in g++ compiler in terminal in linux. I have reached a point where I am stuck. I would really appreciate some help.
I am getting the following errors:

test@linux:~/signalgenerator> g++ -o audio audio_backup.cpp -lasound
audio_backup.cpp: In function ‘int main(int, char**)’:
audio_backup.cpp:485:40: error: invalid conversion from ‘int’ to ‘snd_pcm_format_t’
audio_backup.cpp:485:79: error: no ‘operator++(int)’ declared for postfix ‘++’
audio_backup.cpp:546:85: error: ‘mallc’ cannot be used as a function
audio_backup.cpp:552:64: error: invalid conversion from ‘void*’ to ‘snd_pcm_channel_area_t*’


line 485:

for (format = 0; format < SND_PCM_FORMAT_LAST; format++)

line 546:

samp = mallc(period_size * channels * snd_pcm_format_physical_width(format)) / 8;

line 552:

area = calloc(channels, sizeof(snd_pcm_channel_area_t));
#include <stdio.h>
#include <cstdio>
 #include <stdlib.h>
#include <cstdlib>
 #include <string.h>
#include <cstring>
 #include <sched.h>
 #include <errno.h>
 #include <getopt.h>
 #include <alsa/asoundlib.h>
 #include <sys/time.h>
 #include <math.h>
#include <cmath>
#include <iostream>
using namespace std;

 static const char *device = "plughw:0,0";                     /* playback device */
 static snd_pcm_format_t format = SND_PCM_FORMAT_S16;    /* sample format */
 static unsigned int rate = 96000;                       /* stream rate */
 static unsigned int channels = 128;                       /* count of channels */
 static unsigned int buffer_time = 500000;               /* ring buffer length in us */
 static unsigned int period_time = 100000;               /* period time in us */
 static double freq = 440;                               /* sinusoidal wave frequency in Hz */
 static int verbose = 0;                                 /* verbose flag */
 static int resample = 1;                                /* enable alsa-lib resampling */
 static int period_event = 0; 				/* produce poll event after each period */
 static snd_pcm_sframes_t buffer_size;
 static snd_pcm_sframes_t period_size;
 static snd_output_t *output = NULL;
 static float amplitude = 1;
 static int generate_sine(const snd_pcm_channel_area_t *areas, 
                           snd_pcm_uframes_t offset,
                           int count, double *_phase)
 {
         static double max_phase = 2. * M_PI;
         double phase = *_phase;
         double step = max_phase*freq/(double)rate;
         unsigned char *samples[channels];
         int steps[channels];
         unsigned int chn;
         int format_bits = snd_pcm_format_width(format);
         unsigned int maxval = (1 << (format_bits - 1)) - 1;
         int bps = format_bits / 8;  /* bytes per sample */
         int phys_bps = snd_pcm_format_physical_width(format) / 8;
         int big_endian = snd_pcm_format_big_endian(format) == 1;
         int to_unsigned = snd_pcm_format_unsigned(format) == 1;
         int is_float = (format == SND_PCM_FORMAT_FLOAT_LE ||
                         format == SND_PCM_FORMAT_FLOAT_BE);
	 float amplitude_scale = amplitude/8.56;
	 
	
	 /* verify and prepare the contents of areas */
         for (chn = 0; chn < channels; chn++) {
                 if ((areas[chn].first % 8) != 0) {
                         printf("areas[%i].first == %i, aborting...\n", chn, areas[chn].first);
                         exit(EXIT_FAILURE);
                 }
                 samples[chn] = /*(signed short *)*/(((unsigned char *)areas[chn].addr) + (areas[chn].first / 8));
                 if ((areas[chn].step % 16) != 0) {
                          printf("areas[%i].step == %i, aborting...\n", chn, areas[chn].step);
                         exit(EXIT_FAILURE);
                 }
                 steps[chn] = areas[chn].step / 8;
                 samples[chn] += offset * steps[chn];
         }
         /* fill the channel areas */
         while (count-- > 0) {
                 union {
                         float f;
                         int i;
                 } fval;
                 int res, i;
                 if (is_float) {
                         fval.f = amplitude_scale * sin(phase) * maxval;
                         res = fval.i;
                 } else
                         res = amplitude_scale * sin(phase) * maxval;
                 if (to_unsigned)
                         res ^= 1U << (format_bits - 1);
                 for (chn = 0; chn < channels; chn++) {
                         /* Generate data in native endian format */
                         if (big_endian) {
                                 for (i = 0; i < bps; i++)
                                         *(samples[chn] + phys_bps - 1 - i) = (res >> i * 8) & 0xff;
                         } else {
                                 for (i = 0; i < bps; i++)
                                         *(samples[chn] + i) = (res >>  i * 8) & 0xff;
                         }
                         samples[chn] += steps[chn];
                 }
                 phase += step;
                 if (phase >= max_phase)
                         phase -= max_phase;
         }
         *_phase = phase;
 }
 
 static int set_hwparams(snd_pcm_t *handle,
                         snd_pcm_hw_params_t *params,
                         snd_pcm_access_t access)
 {
         unsigned int rrate;
         snd_pcm_uframes_t size;
         int err, dir;
 
         /* choose all parameters */
         err = snd_pcm_hw_params_any(handle, params);
         if (err < 0) {
		  printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));                 
		  return err;
         }
         /* set hardware resampling */
         err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
         if (err < 0) {
                 printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
                 return err;
         }
         /* set the interleaved read/write format */
         err = snd_pcm_hw_params_set_access(handle, params, access);
         if (err < 0) {
                 printf("Access type not available for playback: %s\n", snd_strerror(err));
                 return err;
         }
         /* set the sample format */
         err = snd_pcm_hw_params_set_format(handle, params, format);
         if (err < 0) {
                 printf("Sample format not available for playback: %s\n", snd_strerror(err));
                 return err;
         }
         /* set the count of channels */
         err = snd_pcm_hw_params_set_channels(handle, params, channels);
         if (err < 0) {
                  printf("Channels count (%i) not available for playbacks: %s\n", channels, snd_strerror(err));
                 return err;
         }
         /* set the stream rate */
         rrate = rate;
         err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
         if (err < 0) {
                 printf("Rate %iHz not available for playback: %s\n", rate, snd_strerror(err));
                 return err;
         }
         if (rrate != rate) {
                  printf("Rate doesn't match (requested %iHz, get %iHz)\n", rate, err);
                 return -EINVAL;
         }
         /* set the buffer time */
         err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, &dir);
         if (err < 0) {
                 printf("Unable to set buffer time %i for playback: %s\n", buffer_time, snd_strerror(err));
                 return err;
         }
         err = snd_pcm_hw_params_get_buffer_size(params, &size);
         if (err < 0) {
                 printf("Unable to get buffer size for playback: %s\n", snd_strerror(err));
                 return err;
         }
         buffer_size = size;
         /* set the period time */
         err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, &dir);
         if (err < 0) {
                  printf("Unable to set period time %i for playback: %s\n", period_time, snd_strerror(err));
                 return err;
         }
         err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
         if (err < 0) {
                 printf("Unable to get period size for playback: %s\n", snd_strerror(err));
                 return err;
         }
         period_size = size;
         /* write the parameters to device */
         err = snd_pcm_hw_params(handle, params);
         if (err < 0) {
                 printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
                 return err;
         }
         return 0;
 }
 
 static int set_swparams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
 {
         int err;
 
         /* get the current swparams */
         err = snd_pcm_sw_params_current(handle, swparams);
         if (err < 0) {
                 printf("Unable to determine current swparams for playback: %s\n", snd_strerror(err));
                 return err;
         }
         /* start the transfer when the buffer is almost full: */
         /* (buffer_size / avail_min) * avail_min */
         err = snd_pcm_sw_params_set_start_threshold(handle, swparams, (buffer_size / period_size) * period_size);
         if (err < 0) {
                 printf("Unable to set start threshold mode for playback: %s\n", snd_strerror(err));
                 return err;
         }
         /* allow the transfer when at least period_size samples can be processed */
         /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
         err = snd_pcm_sw_params_set_avail_min(handle, swparams, period_event ? buffer_size : period_size);
         if (err < 0) {
                 printf("Unable to set avail min for playback: %s\n", snd_strerror(err));
                 return err;
         }
         /* enable period events when requested */
         if (period_event) {
                 err = snd_pcm_sw_params_set_period_event(handle, swparams, 1);
                 if (err < 0) {
                         printf("Unable to set period event: %s\n", snd_strerror(err));
                         return err;
                 }
         }
         /* write the parameters to the playback device */
         err = snd_pcm_sw_params(handle, swparams);
         if (err < 0) {
                 printf("Unable to set sw params for playback: %s\n", snd_strerror(err));
                 return err;
         }
         return 0;
 }
 
 /*
  *   Underrun and suspend recovery
  */
  
 static int xrun_recovery(snd_pcm_t *handle, int err)
 {
         if (verbose)
                 printf("stream 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("Unable to set sw params for playback: %s\n", snd_strerror(err));
                 }
                 return 0;
         }
         return err;
 }
 struct async_private_data {
         signed short *samples;
         snd_pcm_channel_area_t *areas;
         double phase;
 };
 /*
 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", 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;
 
         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", snd_strerror(err));
                         exit(EXIT_FAILURE);
                 }
                 if (err != period_size) {
                         printf("Initial write error: written %i expected %li", 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 */
        /* while (1) {
                 sleep(1);
         }
 }
 *//*
	 Transfer method - write only
  */
 
 static int write_loop(snd_pcm_t *handle,
                       signed short *samples,
                       snd_pcm_channel_area_t *areas)
 {
         double phase = 0;
         signed short *ptr;
         int err, cptr;
 
         while (1) {
                 generate_sine(areas, 0, period_size, &phase);
                 ptr = samples;
                 cptr = period_size;
                 while (cptr > 0) {
                         err = snd_pcm_writei(handle, ptr, cptr);
                         if (err == -EAGAIN)
                                 continue;
                         if (err < 0) {
                                 if (xrun_recovery(handle, err) < 0) {
                                         printf("Write error: %s\n", snd_strerror(err));
                                         exit(EXIT_FAILURE);
                                 }
                                 break;  /* skip one period */
                         }
                         ptr += err * channels;
                         cptr -= err;
                 }
         }
 }

 struct transfer_method {
         const char *name;
         snd_pcm_access_t access;
         int (*transfer_loop)(snd_pcm_t *handle,
                              signed short *samples,
                              snd_pcm_channel_area_t *areas);
 };
 
 static struct transfer_method transfer_methods[] = {
       
      
           { "write", SND_PCM_ACCESS_RW_INTERLEAVED, write_loop },
      /*   { "write_and_poll", SND_PCM_ACCESS_RW_INTERLEAVED, write_and_poll_loop },
         { "async", SND_PCM_ACCESS_RW_INTERLEAVED, async_loop },
         { "async_direct", SND_PCM_ACCESS_MMAP_INTERLEAVED, async_direct_loop },
         { "direct_interleaved", SND_PCM_ACCESS_MMAP_INTERLEAVED, direct_loop },
         { "direct_noninterleaved", SND_PCM_ACCESS_MMAP_NONINTERLEAVED, direct_loop },
         { "direct_write", SND_PCM_ACCESS_MMAP_INTERLEAVED, direct_write_loop },*/
         { NULL, SND_PCM_ACCESS_RW_INTERLEAVED, NULL }
 };
 /*
 static void help(void)
 {
         int k;
         printf(
 "Usage: pcm [OPTION]... [FILE]...  "
 "-h,--help      help  "
 "-D,--device    playback device  "
 "-r,--rate      stream rate in Hz  "
 "-c,--channels  count of channels in stream  "
 "-f,--frequency sine wave frequency in Hz  "
 "-b,--buffer    ring buffer size in us  "
 "-p,--period    period size in us  "
 "-m,--method    transfer method  "
 "-o,--format    sample format  "
 "-v,--verbose   show the PCM setup parameters  "
 "-n,--noresample  do not resample  "
 "-e,--pevent    enable poll event after each period  "
	 );
         printf("Recognized sample formats are:");
         for (k = 0; k < SND_PCM_FORMAT_LAST; ++k) {
                 const char *s = snd_pcm_format_name(k);
                 if (s)
                         printf(" %s", s);
         }
         printf("\n");
          printf("Recognized transfer methods are:");
         for (k = 0; transfer_methods[k].name; k++)
                  printf(" %s", transfer_methods[k].name);
         printf("\n");
 }
 */
 int main(int argc, char *argv[])
 {
         struct option long_option[] =
         {
                 {"help", 0, NULL, 'h'},
                 {"device", 1, NULL, 'D'},
                 {"rate", 1, NULL, 'r'},
                 {"channels", 1, NULL, 'c'},
                 {"frequency", 1, NULL, 'f'},
                 {"buffer", 1, NULL, 'b'},
                 {"period", 1, NULL, 'p'},
                 {"method", 1, NULL, 'm'},
                 {"format", 1, NULL, 'o'},
                 {"verbose", 1, NULL, 'v'},
                 {"noresample", 1, NULL, 'n'},
                 {"pevent", 1, NULL, 'e'},
                 {NULL, 0, NULL, 0},
         };
         
         int err, morehelp;
         snd_pcm_hw_params_t *hwparams;
         snd_pcm_sw_params_t *swparams;
         int method = 0;
	 short int *samp;
	 snd_pcm_t *h;
	 snd_pcm_channel_area_t *area;
         snd_pcm_t *handle = (snd_pcm_t*) h;
	 unsigned char *samples  = (unsigned char*) samp;
         unsigned int chn;
         snd_pcm_channel_area_t *areas = (snd_pcm_channel_area_t*) area;
	 char mallc = *((char *)malloc);
	 
 
         snd_pcm_hw_params_alloca(&hwparams);
         snd_pcm_sw_params_alloca(&swparams);
 
         morehelp = 0;
         while (1) {
                 int c;
                 if ((c = getopt_long(argc, argv, "hD:r:c:f:b:p:m:o:vne", long_option, NULL)) < 0)
                         break;
                 switch (c) {
                 case 'h':
                         morehelp++;
                         break;
                 case 'D':
                         device = strdup(optarg);
                         break;
                 case 'r':
                         rate = atoi(optarg);
                         rate = rate < 4000 ? 4000 : rate;
                         rate = rate > 196000 ? 196000 : rate;
                         break;
                 case 'c':
                         channels = atoi(optarg);
                         channels = channels < 1 ? 1 : channels;
                         channels = channels > 1024 ? 1024 : channels;
                         break;
                 case 'f':
                         freq = atoi(optarg);
                         freq = freq < 50 ? 50 : freq;
                         freq = freq > 5000 ? 5000 : freq;
                         break;
                 case 'b':
                         buffer_time = atoi(optarg);
                         buffer_time = buffer_time < 1000 ? 1000 : buffer_time;
                         buffer_time = buffer_time > 1000000 ? 1000000 : buffer_time;
                         break;
                 case 'p':
                         period_time = atoi(optarg);samp;
                         period_time = period_time < 1000 ? 1000 : period_time;
                         period_time = period_time > 1000000 ? 1000000 : period_time;
                         break;
                 case 'm':
                         for (method = 0; transfer_methods[method].name; method++)
                                         if (!strcasecmp(transfer_methods[method].name, optarg))
                                         break;
                         if (transfer_methods[method].name == NULL)
                                 method = 0;
                         break;
                 case 'o':
                         for (format = 0; format < SND_PCM_FORMAT_LAST; format++) {
                                 const char *format_name = snd_pcm_format_name(format);
                                 if (format_name)
                                         if (!strcasecmp(format_name, optarg))
                                         break;
                         }
                         if (format == SND_PCM_FORMAT_LAST)
                                 format = SND_PCM_FORMAT_S16;
                        if (!snd_pcm_format_linear(format) &&
                            !(format == SND_PCM_FORMAT_FLOAT_LE ||
                               format == SND_PCM_FORMAT_FLOAT_BE)) {
                                  printf("Invalid (non-linear/float) format %s\n",
                                        optarg);
                                 return 1;
                         }
                         break;
                 case 'v':
                         verbose = 1;
                         break;
                 case 'n':
                         resample = 0;
                         break;
                 case 'e':
                         period_event = 1;
                         break;
                 }
         }
 
       /*  if (morehelp) {
                 help();
                 return 0;
         }*/
 
         err = snd_output_stdio_attach(&output, stdout, 0);
         if (err < 0) {
                 printf("Output failed: %s\n", snd_strerror(err));
                 return 0;
         }
 
   /*      cout<<"Playback device is %s  "<<","<< device);
         cout<<"Stream parameters are %iHz, %s, %i channels  "<<","<< rate<<","<< snd_pcm_format_name(format), channels;
        cout<<"Sine wave rate is %.4fHz  "<<","<< freq;
         cout<<"Using transfer method: %s  "<<","<< transfer_methods[method].name;
 */
         if ((err = snd_pcm_open(&h, device, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
                 printf("Playback open error: %s\n", snd_strerror(err));
                 return 0;
         }
         
         if ((err = set_hwparams(h, hwparams, transfer_methods[method].access)) < 0) {
                 printf("Setting of hwparams failed: %s\n", snd_strerror(err));
                 exit(EXIT_FAILURE);
         }
         if ((err = set_swparams(h, swparams)) < 0) {
                 printf("Setting of swparams failed: %s\n", snd_strerror(err));
                 exit(EXIT_FAILURE);
         }
 
         if (verbose > 0)
                 snd_pcm_dump(h, output);
 
         samp = mallc(period_size * channels * snd_pcm_format_physical_width(format)) / 8;
         if (samp == NULL) {
                 printf("Not enough memory\n");
                 exit(EXIT_FAILURE);
         }
         
         area = calloc(channels, sizeof(snd_pcm_channel_area_t));
         if (area == NULL) {
                 printf("Not enough memory\n");
                 exit(EXIT_FAILURE);
         }
         for (chn = 0; chn < channels; chn++) {
                 area[chn].addr = samp;
                 area[chn].first = chn * snd_pcm_format_physical_width(format);
                 area[chn].step = channels * snd_pcm_format_physical_width(format);
         }
 
         err = transfer_methods[method].transfer_loop(h, samp, area);
         if (err < 0)
                 printf("Transfer failed: %s\n", snd_strerror(err));

         free(area);
         free(samp);
         snd_pcm_close(h);
         return 0;
 }
2
Contributors
1
Reply
2
Views
5 Years
Discussion Span
Last Post by Salem
This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.