ref: 224d2dab9c60d1e26ac80b7317151bad3c1b502d
parent: dba28a52ce617bcd9559b03c6a1b31d44c404c07
author: Jean-Marc Valin <[email protected]>
date: Tue Feb 19 05:24:12 EST 2008
celtclient udp two-way streamer. Not enabled yet because it's still tricky to build
--- /dev/null
+++ b/tools/alsa_device.c
@@ -1,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];
+}
--- /dev/null
+++ b/tools/alsa_device.h
@@ -1,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
--- /dev/null
+++ b/tools/celtclient.c
@@ -1,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,¶m))
+ 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;
+}