celtclient udp two-way streamer. Not enabled yet because it's still tricky
authorJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Mon, 18 Feb 2008 23:24:12 +0000 (10:24 +1100)
committerJean-Marc Valin <jean-marc.valin@usherbrooke.ca>
Mon, 18 Feb 2008 23:24:12 +0000 (10:24 +1100)
to build

tools/alsa_device.c [new file with mode: 0644]
tools/alsa_device.h [new file with mode: 0644]
tools/celtclient.c [new file with mode: 0644]

diff --git a/tools/alsa_device.c b/tools/alsa_device.c
new file mode 100644 (file)
index 0000000..e27a7f1
--- /dev/null
@@ -0,0 +1,432 @@
+/*
+   Copyright (C) 2004-2006 Jean-Marc Valin
+   Copyright (C) 2006 Commonwealth Scientific and Industrial Research
+                      Organisation (CSIRO) Australia
+   
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "alsa_device.h"
+#include <stdlib.h>
+#include <alsa/asoundlib.h>
+
+struct AlsaDevice_ {
+   char *device_name;
+   int channels;
+   int period;
+   snd_pcm_t *capture_handle;
+   snd_pcm_t *playback_handle;
+   int readN, writeN;
+   struct pollfd *read_fd, *write_fd;
+};
+
+#define PERIODS 3
+AlsaDevice *alsa_device_open(char *device_name, unsigned int rate, int channels, int period)
+{
+   int dir;
+   int err;
+   snd_pcm_hw_params_t *hw_params;
+   snd_pcm_sw_params_t *sw_params;
+   snd_pcm_uframes_t period_size = period;
+   snd_pcm_uframes_t buffer_size = PERIODS*period;
+   static snd_output_t *jcd_out;
+   AlsaDevice *dev = malloc(sizeof(*dev));
+   if (!dev)
+      return NULL;
+   dev->device_name = malloc(1+strlen(device_name));
+   if (!dev->device_name)
+   {
+      free(dev);
+      return NULL;
+   }
+   strcpy(dev->device_name, device_name);
+   dev->channels = channels;
+   dev->period = period;
+   err = snd_output_stdio_attach(&jcd_out, stdout, 0);
+   
+   if ((err = snd_pcm_open (&dev->capture_handle, dev->device_name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+      fprintf (stderr, "cannot open audio device %s (%s)\n",
+               dev->device_name,
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
+      fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_any (dev->capture_handle, hw_params)) < 0) {
+      fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_set_access (dev->capture_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
+      fprintf (stderr, "cannot set access type (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_set_format (dev->capture_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
+      fprintf (stderr, "cannot set sample format (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_set_rate_near (dev->capture_handle, hw_params, &rate, 0)) < 0) {
+      fprintf (stderr, "cannot set sample rate (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   /*fprintf (stderr, "rate = %d\n", rate);*/
+
+   if ((err = snd_pcm_hw_params_set_channels (dev->capture_handle, hw_params, channels)) < 0) {
+      fprintf (stderr, "cannot set channel count (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   period_size = period;
+   dir = 0;
+   if ((err = snd_pcm_hw_params_set_period_size_near (dev->capture_handle, hw_params, &period_size, &dir)) < 0) {
+      fprintf (stderr, "cannot set period size (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   if ((err = snd_pcm_hw_params_set_periods (dev->capture_handle, hw_params, PERIODS, 0)) < 0) {
+      fprintf (stderr, "cannot set number of periods (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   buffer_size = period_size * PERIODS;
+   dir=0;
+   if ((err = snd_pcm_hw_params_set_buffer_size_near (dev->capture_handle, hw_params, &buffer_size)) < 0) {
+      fprintf (stderr, "cannot set buffer time (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   if ((err = snd_pcm_hw_params (dev->capture_handle, hw_params)) < 0) {
+      fprintf (stderr, "cannot set capture parameters (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   /*snd_pcm_dump_setup(dev->capture_handle, jcd_out);*/
+   snd_pcm_hw_params_free (hw_params);
+
+   if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {
+      fprintf (stderr, "cannot allocate software parameters structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params_current (dev->capture_handle, sw_params)) < 0) {
+      fprintf (stderr, "cannot initialize software parameters structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params_set_avail_min (dev->capture_handle, sw_params, period)) < 0) {
+      fprintf (stderr, "cannot set minimum available count (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params (dev->capture_handle, sw_params)) < 0) {
+      fprintf (stderr, "cannot set software parameters (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }   
+   
+   
+   if ((err = snd_pcm_open (&dev->playback_handle, dev->device_name, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
+      fprintf (stderr, "cannot open audio device %s (%s)\n",
+               dev->device_name,
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
+      fprintf (stderr, "cannot allocate hardware parameter structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_any (dev->playback_handle, hw_params)) < 0) {
+      fprintf (stderr, "cannot initialize hardware parameter structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_set_access (dev->playback_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
+      fprintf (stderr, "cannot set access type (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_set_format (dev->playback_handle, hw_params, SND_PCM_FORMAT_S16_LE)) < 0) {
+      fprintf (stderr, "cannot set sample format (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   if ((err = snd_pcm_hw_params_set_rate_near (dev->playback_handle, hw_params, &rate, 0)) < 0) {
+      fprintf (stderr, "cannot set sample rate (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   /*fprintf (stderr, "rate = %d\n", rate);*/
+
+   if ((err = snd_pcm_hw_params_set_channels (dev->playback_handle, hw_params, channels)) < 0) {
+      fprintf (stderr, "cannot set channel count (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   period_size = period;
+   dir = 0;
+   if ((err = snd_pcm_hw_params_set_period_size_near (dev->playback_handle, hw_params, &period_size, &dir)) < 0) {
+      fprintf (stderr, "cannot set period size (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_hw_params_set_periods (dev->playback_handle, hw_params, PERIODS, 0)) < 0) {
+      fprintf (stderr, "cannot set number of periods (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   buffer_size = period_size * PERIODS;
+   dir=0;
+   if ((err = snd_pcm_hw_params_set_buffer_size_near (dev->playback_handle, hw_params, &buffer_size)) < 0) {
+      fprintf (stderr, "cannot set buffer time (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+
+   if ((err = snd_pcm_hw_params (dev->playback_handle, hw_params)) < 0) {
+      fprintf (stderr, "cannot set playback parameters (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+
+   /*snd_pcm_dump_setup(dev->playback_handle, jcd_out);*/
+   snd_pcm_hw_params_free (hw_params);
+
+   
+   if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {
+      fprintf (stderr, "cannot allocate software parameters structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params_current (dev->playback_handle, sw_params)) < 0) {
+      fprintf (stderr, "cannot initialize software parameters structure (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params_set_avail_min (dev->playback_handle, sw_params, period)) < 0) {
+      fprintf (stderr, "cannot set minimum available count (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params_set_start_threshold (dev->playback_handle, sw_params, period)) < 0) {
+      fprintf (stderr, "cannot set start mode (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_sw_params (dev->playback_handle, sw_params)) < 0) {
+      fprintf (stderr, "cannot set software parameters (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+  
+   
+   snd_pcm_link(dev->capture_handle, dev->playback_handle);
+   if ((err = snd_pcm_prepare (dev->capture_handle)) < 0) {
+      fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   if ((err = snd_pcm_prepare (dev->playback_handle)) < 0) {
+      fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   dev->readN = snd_pcm_poll_descriptors_count(dev->capture_handle);
+   dev->writeN = snd_pcm_poll_descriptors_count(dev->playback_handle);
+
+   dev->read_fd = malloc(dev->readN*sizeof(*dev->read_fd));
+   /*printf ("descriptors: %d %d\n", dev->readN, dev->writeN);*/
+   if (snd_pcm_poll_descriptors(dev->capture_handle, dev->read_fd, dev->readN) != dev->readN)
+   {
+      fprintf (stderr, "cannot obtain capture file descriptors (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   
+   dev->write_fd = malloc(dev->writeN*sizeof(*dev->read_fd));
+   if (snd_pcm_poll_descriptors(dev->playback_handle, dev->write_fd, dev->writeN) != dev->writeN)
+   {
+      fprintf (stderr, "cannot obtain playback file descriptors (%s)\n",
+               snd_strerror (err));
+      assert(0);
+   }
+   return dev;
+}
+
+void alsa_device_close(AlsaDevice *dev)
+{
+   snd_pcm_close(dev->capture_handle);
+   snd_pcm_close(dev->playback_handle);
+   free(dev->device_name);
+   free(dev);
+}
+
+int alsa_device_read(AlsaDevice *dev, short *pcm, int len)
+{
+   int err;
+   /*fprintf (stderr, "-");*/
+   if ((err = snd_pcm_readi (dev->capture_handle, pcm, len)) != len)
+   {
+      if (err<0)
+      {
+         //fprintf(stderr, "error %d, EPIPE = %d\n", err, EPIPE);
+         if (err == -EPIPE)
+         {
+            fprintf (stderr, "An overrun has occured, reseting capture\n");
+         } else
+         {
+            fprintf (stderr, "read from audio interface failed (%s)\n",
+                     snd_strerror (err));
+         }
+         if ((err = snd_pcm_prepare (dev->capture_handle)) < 0)
+         {
+            fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
+                     snd_strerror (err));
+         }
+         if ((err = snd_pcm_start (dev->capture_handle)) < 0)
+         {
+            fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
+                     snd_strerror (err));
+         }
+         /*alsa_device_read(dev,pcm,len);*/
+      } else {
+         fprintf (stderr, "Couldn't read as many samples as I wanted (%d instead of %d)\n", err, len);
+      }
+      return 1;
+   }
+   return 0;
+}
+
+int alsa_device_write(AlsaDevice *dev, const short *pcm, int len)
+{
+   int err;
+   /*fprintf (stderr, "+");*/
+   if ((err = snd_pcm_writei (dev->playback_handle, pcm, len)) != len)
+   {
+      if (err<0)
+      {
+         if (err == -EPIPE)
+         {
+            fprintf (stderr, "An underrun has occured, reseting playback, len=%d\n", len);
+         } else
+         {
+            fprintf (stderr, "write to audio interface failed (%s)\n",
+                     snd_strerror (err));
+         }
+         if ((err = snd_pcm_prepare (dev->playback_handle)) < 0)
+         {
+            fprintf (stderr, "cannot prepare audio interface for use (%s)\n",
+                     snd_strerror (err));
+         }
+      } else {
+         fprintf (stderr, "Couldn't write as many samples as I wanted (%d instead of %d)\n", err, len);
+      }
+      /*alsa_device_write(dev,pcm,len);*/
+      return 1;
+   }
+   return 0;
+}
+
+int alsa_device_capture_ready(AlsaDevice *dev, struct pollfd *pfds, unsigned int nfds)
+{
+   unsigned short revents=0;
+   int err;
+   if ((err = snd_pcm_poll_descriptors_revents(dev->capture_handle, pfds, dev->readN, &revents)) < 0)
+   {
+      //cerr << "error in snd_pcm_poll_descriptors_revents for capture: " << snd_strerror (err) << endl;
+      //FIXME: This is a kludge
+      fprintf (stderr, "error in alsa_device_capture_ready: %s\n", snd_strerror (err));
+      return pfds[0].revents & POLLIN;
+   }
+   //cerr << (revents & POLLERR) << endl;
+   return revents & POLLIN;
+}
+
+int alsa_device_playback_ready(AlsaDevice *dev, struct pollfd *pfds, unsigned int nfds)
+{
+   unsigned short revents=0;
+   int err;
+   if ((err = snd_pcm_poll_descriptors_revents(dev->playback_handle, pfds+dev->readN, dev->writeN, &revents)) < 0)
+   {
+      //cerr << "error in snd_pcm_poll_descriptors_revents for playback: " << snd_strerror (err) << endl;
+      //FIXME: This is a kludge
+      fprintf (stderr, "error in alsa_device_playback_ready: %s\n", snd_strerror (err));
+      return pfds[1].revents & POLLOUT;
+   }
+   //cerr << (revents & POLLERR) << endl;
+   return revents & POLLOUT;
+}
+
+void alsa_device_start(AlsaDevice *dev)
+{
+   int i;
+   short pcm[dev->period*dev->channels];
+   for (i=0;i<dev->period*dev->channels;i++)
+      pcm[i] = 0;
+   alsa_device_write(dev, pcm, dev->period);
+   alsa_device_write(dev, pcm, dev->period);
+   snd_pcm_start(dev->capture_handle);
+   snd_pcm_start(dev->playback_handle);
+}
+
+int alsa_device_nfds(AlsaDevice *dev)
+{
+   return dev->writeN+dev->readN;
+}
+
+void alsa_device_getfds(AlsaDevice *dev, struct pollfd *pfds, unsigned int nfds)
+{
+   int i;
+   assert (nfds >= dev->writeN+dev->readN);
+   for (i=0;i<dev->readN;i++)
+      pfds[i] = dev->read_fd[i];
+   for (i=0;i<dev->writeN;i++)
+      pfds[i+dev->readN] = dev->write_fd[i];
+}
diff --git a/tools/alsa_device.h b/tools/alsa_device.h
new file mode 100644 (file)
index 0000000..a5b3787
--- /dev/null
@@ -0,0 +1,69 @@
+/*
+   Copyright (C) 2004-2006 Jean-Marc Valin
+   Copyright (C) 2006 Commonwealth Scientific and Industrial Research
+                      Organisation (CSIRO) Australia
+   
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+   3. The name of the author may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef ALSA_DEVICE_H
+#define ALSA_DEVICE_H
+
+#include <sys/poll.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct AlsaDevice_;
+
+typedef struct AlsaDevice_ AlsaDevice;
+
+AlsaDevice *alsa_device_open(char *device_name, unsigned int rate, int channels, int period);
+
+void alsa_device_close(AlsaDevice *dev);
+
+int alsa_device_read(AlsaDevice *dev, short *pcm, int len);
+
+int alsa_device_write(AlsaDevice *dev, const short *pcm, int len);
+
+int alsa_device_capture_ready(AlsaDevice *dev, struct pollfd *pfds, unsigned int nfds);
+
+int alsa_device_playback_ready(AlsaDevice *dev, struct pollfd *pfds, unsigned int nfds);
+
+void alsa_device_start(AlsaDevice *dev);
+
+int alsa_device_nfds(AlsaDevice *dev);
+
+void alsa_device_getfds(AlsaDevice *dev, struct pollfd *pfds, unsigned int nfds);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/tools/celtclient.c b/tools/celtclient.c
new file mode 100644 (file)
index 0000000..5da6029
--- /dev/null
@@ -0,0 +1,231 @@
+/***************************************************************************
+   Copyright (C) 2004-2006 by Jean-Marc Valin
+   Copyright (C) 2006 Commonwealth Scientific and Industrial Research
+                      Organisation (CSIRO) Australia
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+   
+   - Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+   
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+   
+   - Neither the name of the Xiph.org Foundation nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+   
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   
+****************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <unistd.h> /* close() */
+#include <string.h> /* memset() */
+
+#include "alsa_device.h"
+#include <celt.h>
+#include <speex/speex_echo.h>
+#include <speex/speex_jitter.h>
+
+#include <sched.h>
+
+#define MAX_MSG 1500
+
+#define SAMPLING_RATE 48000
+#define FRAME_SIZE 256
+
+int main(int argc, char *argv[])
+{
+   
+   int sd, rc, n;
+   int i;
+   struct sockaddr_in cliAddr, remoteAddr;
+   char msg[MAX_MSG];
+   struct hostent *h;
+   int local_port, remote_port;
+   int nfds;
+   struct pollfd *pfds;
+   AlsaDevice *audio_dev;
+   int tmp;
+   int packetSize = 32;
+
+   if (argc != 5)
+   {
+      fprintf(stderr, "wrong options\n");
+      exit(1);
+   }
+  
+   h = gethostbyname(argv[2]);
+   if(h==NULL) {
+      fprintf(stderr, "%s: unknown host '%s' \n", argv[0], argv[1]);
+      exit(1);
+   }
+
+   local_port = atoi(argv[3]);
+   remote_port = atoi(argv[4]);
+   
+   printf("%s: sending data to '%s' (IP : %s) \n", argv[0], h->h_name,
+          inet_ntoa(*(struct in_addr *)h->h_addr_list[0]));
+
+   {
+      remoteAddr.sin_family = h->h_addrtype;
+      memcpy((char *) &remoteAddr.sin_addr.s_addr,
+            h->h_addr_list[0], h->h_length);
+      remoteAddr.sin_port = htons(remote_port);
+   }
+   /* socket creation */
+   sd=socket(AF_INET, SOCK_DGRAM, 0);
+   if(sd<0) {
+      printf("%s: cannot open socket \n",argv[0]);
+      exit(1);
+   }
+
+   /* bind any port */
+   cliAddr.sin_family = AF_INET;
+   cliAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+   cliAddr.sin_port = htons(local_port);
+
+   rc = bind(sd, (struct sockaddr *) &cliAddr, sizeof(cliAddr));
+   if(rc<0) {
+      printf("%s: cannot bind port\n", argv[0]);
+      exit(1);
+   }
+
+   /* Setup audio device */
+   audio_dev = alsa_device_open(argv[1], SAMPLING_RATE, 1, FRAME_SIZE);
+   
+   /* Setup the encoder and decoder in wideband */
+   CELTEncoder *enc_state;
+   CELTDecoder *dec_state;
+   enc_state = celt_encoder_new(celt_mono);   
+   dec_state = celt_decoder_new(celt_mono);   
+   struct sched_param param;
+   /*param.sched_priority = 40; */
+   param.sched_priority = sched_get_priority_min(SCHED_FIFO);
+   if (sched_setscheduler(0,SCHED_FIFO,&param))
+      perror("sched_setscheduler");
+
+   int send_timestamp = 0;
+   int recv_started=0;
+   
+   /* Setup all file descriptors for poll()ing */
+   nfds = alsa_device_nfds(audio_dev);
+   pfds = malloc(sizeof(*pfds)*(nfds+1));
+   alsa_device_getfds(audio_dev, pfds, nfds);
+   pfds[nfds].fd = sd;
+   pfds[nfds].events = POLLIN;
+
+   /* Setup jitter buffer using decoder */
+   JitterBuffer *jitter;
+   jitter = jitter_buffer_init(FRAME_SIZE);
+   
+   /* Echo canceller with 200 ms tail length */
+   SpeexEchoState *echo_state = speex_echo_state_init(FRAME_SIZE, 10*FRAME_SIZE);
+   tmp = SAMPLING_RATE;
+   speex_echo_ctl(echo_state, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);
+   
+   alsa_device_start(audio_dev);
+   
+   /* Infinite loop on capture, playback and receiving packets */
+   while (1)
+   {
+      /* Wait for either 1) capture 2) playback 3) socket data */
+      poll(pfds, nfds+1, -1);
+      /* Received packets */
+      if (pfds[nfds].revents & POLLIN)
+      {
+         /*fprintf (stderr, "x");*/
+         n = recv(sd, msg, MAX_MSG, 0);
+         int recv_timestamp = ((int*)msg)[0];
+   
+         JitterBufferPacket packet;
+         packet.data = msg+4;
+         packet.len = n-4;
+         packet.timestamp = recv_timestamp;
+         packet.span = FRAME_SIZE;
+         packet.sequence = 0;
+         /* Put content of the packet into the jitter buffer, except for the pseudo-header */
+         jitter_buffer_put(jitter, &packet);
+         recv_started = 1;
+
+      }
+      /* Ready to play a frame (playback) */
+      if (alsa_device_playback_ready(audio_dev, pfds, nfds))
+      {
+         short pcm[FRAME_SIZE];
+         if (recv_started)
+         {
+            JitterBufferPacket packet;
+            /* Get audio from the jitter buffer */
+            jitter_buffer_get(jitter, &packet, FRAME_SIZE, NULL);
+            celt_decode(dec_state, packet.data, packet.len, pcm);
+         } else {
+            for (i=0;i<FRAME_SIZE;i++)
+               pcm[i] = 0;
+         }
+         /* Playback the audio and reset the echo canceller if we got an underrun */
+         if (alsa_device_write(audio_dev, pcm, FRAME_SIZE))
+            speex_echo_state_reset(echo_state);
+         /* Put frame into playback buffer */
+         speex_echo_playback(echo_state, pcm);
+      }
+      /* Audio available from the soundcard (capture) */
+      if (alsa_device_capture_ready(audio_dev, pfds, nfds))
+      {
+         short pcm[FRAME_SIZE], pcm2[FRAME_SIZE];
+         char outpacket[MAX_MSG];
+         /* Get audio from the soundcard */
+         alsa_device_read(audio_dev, pcm, FRAME_SIZE);
+         
+         /* Perform echo cancellation */
+         speex_echo_capture(echo_state, pcm, pcm2);
+         for (i=0;i<FRAME_SIZE;i++)
+            pcm[i] = pcm2[i];
+         
+         /* Encode */
+         celt_encode(enc_state, pcm, outpacket+4, packetSize);
+         
+         /* Pseudo header: four null bytes and a 32-bit timestamp */
+         ((int*)outpacket)[0] = send_timestamp;
+         send_timestamp += FRAME_SIZE;
+         rc = sendto(sd, outpacket, packetSize+4, 0,
+                (struct sockaddr *) &remoteAddr,
+                sizeof(remoteAddr));
+         
+         if(rc<0) {
+            printf("cannot send audio data\n");
+            close(sd);
+            exit(1);
+         }
+      }
+      
+
+   }
+
+
+   return 0;
+}