mirror of
https://github.com/servalproject/serval-dna.git
synced 2024-12-20 21:53:12 +00:00
275 lines
8.8 KiB
C
275 lines
8.8 KiB
C
/*
|
|
Copyright (C) 2012 Paul Gardner-Stephen
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "serval.h"
|
|
|
|
#ifndef HAVE_ALSA_ASOUNDLIB_H
|
|
/* XXX Android NDK lacks the header files needed to build this.
|
|
Will deal with it later */
|
|
monitor_audio *audio_alsa_detect() {
|
|
return NULL;
|
|
}
|
|
#else
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <dlfcn.h>
|
|
#include <alsa/asoundlib.h>
|
|
|
|
#ifndef ANDROID
|
|
#define ALSA_LIB_PATH "/lib/libasound.so.2"
|
|
#else
|
|
// XXX Verify on a SGS2 ?
|
|
#define ALSA_LIB_PATH "/system/lib/libasound.so.2"
|
|
#endif
|
|
|
|
/*
|
|
For Android systems we have the fun that this binary (not just the source code)
|
|
needs to be able to run on systems that lack the alsa library.
|
|
|
|
This means it is time for some more dlopen() and dlsym() fun to get the
|
|
necessary symbols we need.
|
|
*/
|
|
typedef struct alsa_functions {
|
|
int (*snd_pcm_open_preferred)(snd_pcm_t **,int *,int *,int);
|
|
int (*snd_pcm_close)(snd_pcm_t *);
|
|
int (*snd_pcm_hw_params_malloc)(snd_pcm_hw_params_t **);
|
|
int (*snd_pcm_hw_params_any)(snd_pcm_t *,snd_pcm_hw_params_t *);
|
|
int (*snd_pcm_hw_params_set_access)(snd_pcm_t *,snd_pcm_hw_params_t *,int);
|
|
int (*snd_pcm_hw_params_set_format)(snd_pcm_t *,snd_pcm_hw_params_t *,int);
|
|
int (*snd_pcm_hw_params_set_rate_near)(snd_pcm_t *,snd_pcm_hw_params_t *,int,int);
|
|
int (*snd_pcm_hw_params_set_channels)(snd_pcm_t *,snd_pcm_hw_params_t *,int);
|
|
int (*snd_pcm_hw_params)(snd_pcm_t *,snd_pcm_hw_params_t *);
|
|
void (*snd_pcm_hw_params_free)(snd_pcm_hw_params_t *);
|
|
int (*snd_pcm_prepare)(snd_pcm_t *);
|
|
int (*snd_pcm_writei)(snd_pcm_t *,short *,int);
|
|
int (*snd_pcm_readi)(snd_pcm_t *,short *,int);
|
|
int (*snd_pcm_poll_descriptors)(snd_pcm_t *,struct pollfd *,unsigned int);
|
|
} alsa_functions;
|
|
|
|
#define S(X) #X
|
|
#define GETSYM(X) {a->X = dlsym(h,S(X)); if (!a->X) { dlclose(h); free(a); return -1; }}
|
|
|
|
alsa_functions *alsa = NULL;
|
|
|
|
int alsa_load()
|
|
{
|
|
WHY("Trying to load ALSA library");
|
|
void *h = dlopen(ALSA_LIB_PATH,RTLD_LAZY);
|
|
if (!h) h=dlopen("/usr/lib/i386-linux-gnu/libasound.so.2",RTLD_LAZY);
|
|
if (!h) return -1;
|
|
alsa_functions *a=calloc(sizeof(alsa_functions),1);
|
|
GETSYM(snd_pcm_open_preferred);
|
|
GETSYM(snd_pcm_hw_params_malloc);
|
|
GETSYM(snd_pcm_hw_params_any);
|
|
GETSYM(snd_pcm_hw_params_set_access);
|
|
GETSYM(snd_pcm_hw_params_set_format);
|
|
GETSYM(snd_pcm_hw_params_set_rate_near);
|
|
GETSYM(snd_pcm_hw_params_set_channels);
|
|
GETSYM(snd_pcm_hw_params);
|
|
GETSYM(snd_pcm_hw_params_free);
|
|
GETSYM(snd_pcm_writei);
|
|
GETSYM(snd_pcm_readi);
|
|
GETSYM(snd_pcm_close);
|
|
GETSYM(snd_pcm_poll_descriptors);
|
|
alsa=a;
|
|
dlclose(h);
|
|
WHY("Loaded ALSA library");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int alsa_handles_initialised=0;
|
|
snd_pcm_t *play_handle;
|
|
snd_pcm_t *record_handle;
|
|
snd_pcm_hw_params_t *play_params;
|
|
snd_pcm_hw_params_t *record_params;
|
|
|
|
int audio_alsa_stop_play()
|
|
{
|
|
if (!alsa) return 0;
|
|
alsa->snd_pcm_hw_params_free(play_params); play_params=NULL;
|
|
alsa->snd_pcm_close(play_handle);
|
|
return 0;
|
|
}
|
|
|
|
int audio_alsa_stop_record()
|
|
{
|
|
if (!alsa) return 0;
|
|
alsa->snd_pcm_hw_params_free(record_params); record_params=NULL;
|
|
alsa->snd_pcm_close(record_handle);
|
|
return 0;
|
|
}
|
|
|
|
int audio_alsa_start_play()
|
|
{
|
|
int r;
|
|
|
|
/* if already playing, then return. */
|
|
if (alsa_handles_initialised) return 0;
|
|
|
|
if (!alsa) return -1;
|
|
record_handle=NULL; play_handle=NULL;
|
|
record_params=NULL; play_params=NULL;
|
|
|
|
/* Open playback device */
|
|
r = alsa->snd_pcm_open_preferred (&play_handle,NULL,NULL,
|
|
SND_PCM_STREAM_PLAYBACK|SND_PCM_NONBLOCK);
|
|
if (r) { WHYF("ALSA pcm_open() failed"); goto error; }
|
|
|
|
/* Configure playback device for 8000Hz, 16 bit, mono */
|
|
r=alsa->snd_pcm_hw_params_malloc(&play_params);
|
|
if (r) { WHYF("ALSA hw_params_malloc() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_any(play_handle,play_params);
|
|
if (r) { WHYF("ALSA hw_params_any() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_access(play_handle,play_params,
|
|
SND_PCM_ACCESS_RW_INTERLEAVED);
|
|
if (r) { WHYF("ALSA hw_params_set_access() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_format(play_handle,play_params,
|
|
SND_PCM_FORMAT_S16_LE);
|
|
if (r) { WHYF("ALSA hw_params_set_format() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_rate_near(play_handle,play_params,8000,0);
|
|
if (r) { WHYF("ALSA hw_params_set_rate_near() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_channels(play_handle,play_params,1);
|
|
if (r) { WHYF("ALSA hw_params_set_channels() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params(play_handle,play_params);
|
|
if (r) { WHYF("ALSA snd_pcm_hw_params() failed"); goto error; }
|
|
alsa->snd_pcm_hw_params_free(play_params); play_params=NULL;
|
|
|
|
r=alsa->snd_pcm_prepare(play_handle);
|
|
if (r) { WHYF("ALSA snd_pcm_prepare() failed"); goto error; }
|
|
|
|
WHY("Playback device configured");
|
|
|
|
error:
|
|
/* close handles and generally cleanup after ourselves */
|
|
audio_alsa_stop_play();
|
|
return -1;
|
|
}
|
|
|
|
int audio_alsa_start_record()
|
|
{
|
|
/* Open recording device non-blocking */
|
|
int r = alsa->snd_pcm_open_preferred(&record_handle,NULL,NULL,
|
|
SND_PCM_STREAM_CAPTURE|SND_PCM_NONBLOCK);
|
|
if (r) { WHYF("ALSA pcm_open() failed"); goto error; }
|
|
|
|
/* Configure playback device for 8000Hz, 16 bit, mono */
|
|
r=alsa->snd_pcm_hw_params_malloc(&record_params);
|
|
if (r) { WHYF("ALSA hw_params_malloc() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_any(record_handle,record_params);
|
|
if (r) { WHYF("ALSA hw_params_any() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_access(record_handle,record_params,
|
|
SND_PCM_ACCESS_RW_INTERLEAVED);
|
|
if (r) { WHYF("ALSA hw_params_set_access() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_format(record_handle,record_params,
|
|
SND_PCM_FORMAT_S16_LE);
|
|
if (r) { WHYF("ALSA hw_params_set_format() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_rate_near(record_handle,record_params,8000,0);
|
|
if (r) { WHYF("ALSA hw_params_set_rate_near() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params_set_channels(record_handle,record_params,1);
|
|
if (r) { WHYF("ALSA hw_params_set_channels() failed"); goto error; }
|
|
r=alsa->snd_pcm_hw_params(record_handle,record_params);
|
|
if (r) { WHYF("ALSA snd_pcm_hw_params() failed"); goto error; }
|
|
alsa->snd_pcm_hw_params_free(record_params); record_params=NULL;
|
|
|
|
r=alsa->snd_pcm_prepare(record_handle);
|
|
if (r) { WHYF("ALSA snd_pcm_prepare() failed"); goto error; }
|
|
|
|
WHY("Record device configured");
|
|
return 0;
|
|
|
|
error:
|
|
/* close handles and generally cleanup after ourselves */
|
|
audio_alsa_stop_record();
|
|
return -1;
|
|
}
|
|
|
|
int audio_alsa_stop()
|
|
{
|
|
audio_alsa_stop_play();
|
|
audio_alsa_stop_record();
|
|
return 0;
|
|
}
|
|
|
|
int audio_alsa_start()
|
|
{
|
|
if (audio_alsa_start_play()) return -1;
|
|
if (audio_alsa_start_record()) {
|
|
audio_alsa_stop();
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int audio_alsa_pollfds(struct pollfd *fds,int slots)
|
|
{
|
|
int used_play
|
|
=alsa->snd_pcm_poll_descriptors(play_handle,fds,slots);
|
|
int used_record
|
|
=alsa->snd_pcm_poll_descriptors(record_handle,&fds[used_play],slots);
|
|
return used_play+used_record;
|
|
}
|
|
|
|
int audio_alsa_read(unsigned char *buffer,int maximum_bytes)
|
|
{
|
|
int frames_read=0;
|
|
if ((frames_read=
|
|
alsa->snd_pcm_readi(record_handle, (short *)buffer, maximum_bytes/2))<0)
|
|
{
|
|
alsa->snd_pcm_prepare(record_handle);
|
|
frames_read
|
|
=alsa->snd_pcm_readi(play_handle, (short *)buffer, maximum_bytes/2);
|
|
}
|
|
return frames_read*2;
|
|
}
|
|
|
|
int audio_alsa_write(unsigned char *buffer,int bytes)
|
|
{
|
|
/* 16 bits per sample, so frames = bytes/2 */
|
|
int frames_written=0;
|
|
if ((frames_written=alsa->snd_pcm_writei(play_handle, (short *)buffer, bytes/2))<0)
|
|
{
|
|
alsa->snd_pcm_prepare(play_handle);
|
|
return alsa->snd_pcm_writei(play_handle, (short *)buffer, bytes/2)*2;
|
|
}
|
|
else return 0;
|
|
}
|
|
|
|
monitor_audio *audio_alsa_detect()
|
|
{
|
|
if (!alsa) alsa_load();
|
|
if (!alsa) return NULL;
|
|
snd_pcm_t *handle;
|
|
if (alsa->snd_pcm_open_preferred(&handle,NULL,NULL,SND_PCM_STREAM_PLAYBACK) < 0)
|
|
return NULL;
|
|
alsa->snd_pcm_close(handle);
|
|
|
|
monitor_audio *au=calloc(sizeof(monitor_audio),1);
|
|
strcpy(au->name,"ALSA compatible");
|
|
au->start=audio_alsa_start;
|
|
au->stop=audio_alsa_stop;
|
|
au->poll_fds=audio_alsa_pollfds;
|
|
au->read=audio_alsa_read;
|
|
au->write=audio_alsa_write;
|
|
return au;
|
|
}
|
|
|
|
#endif
|