static int ao_esd_get_property (ao_driver_t *this_gen, int property) {
esd_driver_t *this = (esd_driver_t *) this_gen;
int mixer_fd;
esd_player_info_t *esd_pi;
esd_info_t *esd_i;
switch(property) {
case AO_PROP_MIXER_VOL:
if((mixer_fd = esd_open_sound(NULL)) >= 0) {
if((esd_i = esd_get_all_info(mixer_fd)) != NULL) {
for(esd_pi = esd_i->player_list; esd_pi != NULL; esd_pi = esd_pi->next) {
if(!strcmp(this->pname, esd_pi->name)) {
this->mixer.source_id = esd_pi->source_id;
if(!this->mixer.mute)
this->mixer.volume = (((esd_pi->left_vol_scale * 100) / 256) +
((esd_pi->right_vol_scale * 100) / 256)) >> 1;
}
}
esd_free_all_info(esd_i);
}
esd_close(mixer_fd);
}
return this->mixer.volume;
break;
case AO_PROP_MUTE_VOL:
return this->mixer.mute;
break;
}
static void
mix_init (int *esd, int *player)
{
esd_info_t *all_info;
esd_player_info_t *player_info;
if (*esd < 0 && (*esd = esd_open_sound (NULL)) < 0)
return;
if (*player < 0)
{
all_info = esd_get_all_info (*esd);
if (all_info)
{
for (player_info = all_info->player_list; player_info;
player_info = player_info->next)
if (!strcmp(player_info->name, ident))
{
*player = player_info->source_id;
break;
}
esd_free_all_info (all_info);
}
}
}
int ESDGetConnection()
{
static int ConFD=-1;
if (ConFD==-1) ConFD=esd_open_sound(NULL);
return(ConFD);
}
static int
setup_sound(void)
{
server_fd = esd_open_sound(hostname);
if (server_fd < 0) {
module_logger(&esdSound, _L|LOG_ERROR|LOG_USER, _("could not open audio (%s)\n"),
strerror(errno));
soundblksize = 512;
} else {
/*
soundblksize = esd_get_latency(server_fd);
// 16-bit, mono
soundblksize *= 2;
*/
soundblksize = 512;
}
sound_fd = esd_play_stream(
ESD_BITS16|ESD_MONO|ESD_STREAM|ESD_PLAY,
soundhz,
hostname,
"V9t9 sndESD module");
if (sound_fd < 0) {
module_logger(&esdSound, _L|LOG_ERROR|LOG_USER, _("could not open stream (%s)\n"),
strerror(errno));
return 0;
}
module_logger(&esdSound, _L|LOG_USER, _("\nwarning, this module is not optimal and\n"
"sound can be delayed up to a second.\n"
"Consider killing esd and using native OSS or ALSA sound.\n\n"));
return 1;
}
CSndserv::CSndserv()
{
#ifdef G_OS_WIN32
canplay = true;
#else
fd=esd_open_sound(NULL);//"localhost";
canplay = (fd>=0);
#endif
if (!canplay)
g_print("esd initialization failed,no sound will be play!\n");
}
void *grab_write_esd(void) {
esd_format_t fmt;
int socket;
const char *esdkey = genesdkey();
const char *espeaker = getenv("ESPEAKER");
int esd;
esd = esd_open_sound(espeaker);
if(esd < 0) {
fprintf(stderr, "esd open sound failed.\n");
return NULL;
}
fmt = ESD_STREAM | ESD_PLAY;
switch(DEF_CHANNELS) {
case 1: fmt |= ESD_MONO; break;
case 2: fmt |= ESD_STEREO; break;
default: break;
}
switch(_al_formatbits(DEF_FORMAT)) {
case 8: fmt |= ESD_BITS8; break;
case 16: fmt |= ESD_BITS16; break;
default: break;
}
socket = esd_play_stream(fmt, DEF_SPEED, espeaker, esdkey);
if(socket < 0) {
fprintf(stderr, "esd play stream failed.\n");
return NULL;
}
_alBlitBuffer = esd_blitbuffer;
fprintf(stderr, "esd grab audio ok\n");
_alDebug(ALD_CONTEXT, __FILE__, __LINE__,
"esd grab audio ok");
esd_info.speed = DEF_SPEED;
esd_info.fmt = fmt;
esd_info.socket = socket;
esd_info.espeaker = espeaker;
esd_info.paused = AL_FALSE;
esd_info.esdhandle = esd;
strncpy(esd_info.name, esdkey, ESD_NAMELEN);
return &esd_info;
}
static
int init(struct audio_init *init)
{
host = init->path;
if (host && *host == 0)
host = 0;
/* test opening a socket */
esd = esd_open_sound(host);
if (esd < 0) {
audio_error = ":esd_open_sound";
return -1;
}
return 0;
}
int ao_plugin_test()
{
int sock;
/* don't wake up the beast while detecting */
putenv(strdup("ESD_NO_SPAWN=1"));
sock = esd_open_sound(NULL);
portable_unsetenv("ESD_NO_SPAWN");
if (sock < 0)
return 0;
if (esd_get_standby_mode(sock) != ESM_RUNNING) {
esd_close(sock);
return 0;
}
esd_close(sock);
return 1;
}
static vmResult
esd_init(void)
{
#if OSS_SOUND
/* don't init if OSS is running, since this will spawn
a server which will make OSS fail to load */
if (ossSound.runtimeflags & vmRTUnavailable)
#endif
{
server_fd = esd_open_sound(hostname);
if (server_fd <= 0) {
module_logger(&esdSound, _L|LOG_ERROR | LOG_USER, _("Could not open Enlightened Sound Daemon: %s\n"),
strerror(errno));
return vmNotAvailable;
}
}
return vmOk;
}
int AudioESound::open_input()
{
esd_format_t format = ESD_STREAM | ESD_RECORD;
device->in_channels = 2;
device->in_bits = 16;
format |= get_channels_flag(device->in_channels);
format |= get_bit_flag(device->in_bits);
if((esd_in = esd_open_sound(translate_device_string(device->in_config->esound_in_server, device->in_config->esound_in_port))) <= 0)
{
fprintf(stderr, "AudioESound::open_input: open failed\n");
return 1;
}
esd_in_fd = esd_record_stream_fallback(format, device->in_samplerate,
translate_device_string(device->out_config->esound_out_server, device->out_config->esound_out_port),
"Cinelerra");
return 0;
}
int
open (const char *pathname, int flags, ...)
{
static int (*func) (const char *, int, mode_t) = NULL;
va_list args;
mode_t mode;
if (!func)
func = (int (*) (const char *, int, mode_t)) dlsym (REAL_LIBC, "open");
dsp_init ();
va_start (args, flags);
mode = va_arg (args, mode_t);
va_end (args);
if (!strcmp (pathname, "/dev/dsp"))
{
if (!getenv ("ESPEAKER"))
{
int ret;
flags |= O_NONBLOCK;
if ((ret = (*func) (pathname, flags, mode)) >= 0)
return ret;
}
DPRINTF ("hijacking /dev/dsp open, and taking it to esd...\n");
settings = done = 0;
return (sndfd = esd_open_sound (NULL));
}
else if (use_mixer && !strcmp (pathname, "/dev/mixer"))
{
DPRINTF ("hijacking /dev/mixer open, and taking it to esd...\n");
return (mixfd = (*func) (mixer, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR));
}
else
return (*func) (pathname, flags, mode);
}
int AudioESound::open_output()
{
esd_format_t format = ESD_STREAM | ESD_PLAY;
device->out_channels = 2;
device->out_bits = 16;
format |= get_channels_flag(device->out_channels);
format |= get_bit_flag(device->out_bits);
if((esd_out = esd_open_sound(translate_device_string(device->out_config->esound_out_server, device->out_config->esound_out_port))) <= 0)
{
fprintf(stderr, "AudioESound::open_output: open failed\n");
return 1;
};
esd_out_fd = esd_play_stream_fallback(format, device->out_samplerate,
translate_device_string(device->out_config->esound_out_server, device->out_config->esound_out_port),
"Cinelerra");
device->device_buffer = esd_get_latency(esd_out);
device->device_buffer *= device->out_bits / 8 * device->out_channels;
return 0;
}
static gboolean
gst_esdsink_open (GstAudioSink * asink)
{
esd_server_info_t *server_info;
GstPadTemplate *pad_template;
GstEsdSink *esdsink;
gchar *saved_env;
gint i;
esdsink = GST_ESDSINK (asink);
GST_DEBUG_OBJECT (esdsink, "open");
/* ensure libesd doesn't auto-spawn a sound daemon if none is running yet */
saved_env = g_strdup (g_getenv ("ESD_NO_SPAWN"));
g_setenv ("ESD_NO_SPAWN", "1", TRUE);
/* now try to connect to any existing/running sound daemons */
esdsink->ctrl_fd = esd_open_sound (esdsink->host);
/* and restore the previous state */
if (saved_env != NULL) {
g_setenv ("ESD_NO_SPAWN", saved_env, TRUE);
} else {
g_unsetenv ("ESD_NO_SPAWN");
}
g_free (saved_env);
if (esdsink->ctrl_fd < 0)
goto couldnt_connect;
/* get server info */
server_info = esd_get_server_info (esdsink->ctrl_fd);
if (!server_info)
goto no_server_info;
GST_INFO_OBJECT (esdsink, "got server info rate: %i", server_info->rate);
pad_template = gst_static_pad_template_get (&sink_factory);
esdsink->cur_caps = gst_caps_copy (gst_pad_template_get_caps (pad_template));
gst_object_unref (pad_template);
for (i = 0; i < esdsink->cur_caps->structs->len; i++) {
GstStructure *s;
s = gst_caps_get_structure (esdsink->cur_caps, i);
gst_structure_set (s, "rate", G_TYPE_INT, server_info->rate, NULL);
}
esd_free_server_info (server_info);
GST_INFO_OBJECT (esdsink, "server caps: %" GST_PTR_FORMAT, esdsink->cur_caps);
return TRUE;
/* ERRORS */
couldnt_connect:
{
GST_ELEMENT_ERROR (esdsink, RESOURCE, OPEN_WRITE,
(_("Could not establish connection to sound server")),
("can't open connection to esound server"));
return FALSE;
}
no_server_info:
{
GST_ELEMENT_ERROR (esdsink, RESOURCE, OPEN_WRITE,
(_("Failed to query sound server capabilities")),
("couldn't get server info!"));
return FALSE;
}
}
int main(int argc, char **argv)
{
char buf[ESD_BUF_SIZE];
int sock = -1, rate = ESD_DEFAULT_RATE;
int arg = 0, length = 0, total = 0;
int bits = ESD_BITS16, channels = ESD_STEREO;
int mode = ESD_STREAM, func = ESD_PLAY ;
esd_format_t format = 0;
int sample_id = 0;
FILE *source = NULL;
struct stat source_stats;
char *host = NULL;
char *name = NULL;
for ( arg = 1 ; arg < argc ; arg++)
{
if (!strcmp("-h",argv[arg]))
{
printf("usage:\n\t%s [-s server ] [-b] [-m] [-r freq] < file\n",
argv[0]);
exit(0);
}
else if ( !strcmp( "-s", argv[ arg ] ) )
host = argv[ ++arg ];
else if ( !strcmp( "-b", argv[ arg ] ) )
bits = ESD_BITS8;
else if ( !strcmp( "-m", argv[ arg ] ) )
channels = ESD_MONO;
else if ( !strcmp( "-r", argv[ arg ] ) )
{
arg++;
rate = atoi( argv[ arg ] );
} else {
name = argv[ arg ];
source = fopen( name, "r" );
}
}
signal( SIGINT, clean_exit );
if ( source == NULL ) {
fprintf( stderr, "%s, sample file not specified\n", argv[ 0 ] );
return -1;
}
format = bits | channels | mode | func;
printf( "opening socket, format = 0x%08x at %d Hz\n",
format, rate );
sock = esd_open_sound( host );
if ( sock <= 0 )
return 1;
stat( name, &source_stats );
sample_id = esd_sample_cache( sock, format, rate, source_stats.st_size, name );
printf( "sample id is <%d>\n", sample_id );
while ( ( length = fread( buf, 1, ESD_BUF_SIZE, source ) ) > 0 )
{
/* fprintf( stderr, "read %d\n", length ); */
if ( ( length = write( sock, buf, length) ) <= 0 )
return 1;
else
total += length;
}
printf( "sample uploaded, %d bytes\n", total );
esd_sample_loop( sock, sample_id );
printf( "press <enter> to quit.\n" );
getchar();
/* TODO: make sample_free clean out all playing samples */
esd_sample_stop( sock, sample_id );
esd_sample_free( sock, sample_id );
printf( "closing down\n" );
close( sock );
return 0;
}
static int open_esound(audio_output_t *ao)
{
esd_format_t format = ESD_STREAM | ESD_PLAY;
if (!esd_rate)
{
int esd;
esd_server_info_t *info;
esd_format_t fmt;
if ((esd = esd_open_sound(NULL)) >= 0)
{
info = esd_get_server_info(esd);
esd_rate = info->rate;
fmt = info->format;
esd_free_server_info(info);
esd_close(esd);
}
else
{
esd_rate = esd_audio_rate;
fmt = esd_audio_format;
}
esd_format = MPG123_ENC_UNSIGNED_8;
if ((fmt & ESD_MASK_BITS) == ESD_BITS16)
esd_format |= MPG123_ENC_SIGNED_16;
esd_channels = fmt & ESD_MASK_CHAN;
}
if (ao->format == -1)
ao->format = esd_format;
else if (!(ao->format & esd_format))
{
error1("Unsupported audio format: %d\n", ao->format);
errno = EINVAL;
return -1;
}
if (ao->format & MPG123_ENC_SIGNED_16)
format |= ESD_BITS16;
else if (ao->format & MPG123_ENC_UNSIGNED_8)
format |= ESD_BITS8;
else assert(0);
if (ao->channels == -1) ao->channels = 2;
else if (ao->channels <= 0 || ao->channels > esd_channels)
{
error1("Unsupported no of channels: %d\n", ao->channels);
errno = EINVAL;
return -1;
}
if (ao->channels == 1)
format |= ESD_MONO;
else if (ao->channels == 2)
format |= ESD_STEREO;
else assert(0);
if (ao->rate == -1) ao->rate = esd_rate;
else if (ao->rate > esd_rate)
return -1;
ao->fn = esd_play_stream_fallback(format, ao->rate, ao->device, "mpg123");
return (ao->fn);
}
/*
* open & setup audio device
* return: 1=success 0=fail
*/
static int init(int rate_hz, int channels, int format, int flags)
{
esd_format_t esd_fmt;
int bytes_per_sample;
int fl;
char *server = ao_subdevice; /* NULL for localhost */
float lag_seconds, lag_net, lag_serv;
struct timeval proto_start, proto_end;
esd_fd = esd_open_sound(server);
if (esd_fd < 0) {
mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ESD_CantOpenSound,
strerror(errno));
return 0;
}
/* get server info, and measure network latency */
gettimeofday(&proto_start, NULL);
esd_svinfo = esd_get_server_info(esd_fd);
if(server) {
gettimeofday(&proto_end, NULL);
lag_net = (proto_end.tv_sec - proto_start.tv_sec) +
(proto_end.tv_usec - proto_start.tv_usec) / 1000000.0;
lag_net /= 2.0; /* round trip -> one way */
} else
lag_net = 0.0; /* no network lag */
/*
if (esd_svinfo) {
mp_msg(MSGT_AO, MSGL_INFO, "AO: [esd] server info:\n");
esd_print_server_info(esd_svinfo);
}
*/
esd_fmt = ESD_STREAM | ESD_PLAY;
#if ESD_RESAMPLES
/* let the esd daemon convert sample rate */
#else
/* let mplayer's audio filter convert the sample rate */
if (esd_svinfo != NULL)
rate_hz = esd_svinfo->rate;
#endif
ao_data.samplerate = rate_hz;
/* EsounD can play mono or stereo */
switch (channels) {
case 1:
esd_fmt |= ESD_MONO;
ao_data.channels = bytes_per_sample = 1;
break;
default:
esd_fmt |= ESD_STEREO;
ao_data.channels = bytes_per_sample = 2;
break;
}
/* EsounD can play 8bit unsigned and 16bit signed native */
switch (format) {
case AF_FORMAT_S8:
case AF_FORMAT_U8:
esd_fmt |= ESD_BITS8;
ao_data.format = AF_FORMAT_U8;
break;
default:
esd_fmt |= ESD_BITS16;
ao_data.format = AF_FORMAT_S16_NE;
bytes_per_sample *= 2;
break;
}
/* modify audio_delay depending on esd_latency
* latency is number of samples @ 44.1khz stereo 16 bit
* adjust according to rate_hz & bytes_per_sample
*/
#ifdef CONFIG_ESD_LATENCY
esd_latency = esd_get_latency(esd_fd);
#else
esd_latency = ((channels == 1 ? 2 : 1) * ESD_DEFAULT_RATE *
(ESD_BUF_SIZE + 64 * (4.0f / bytes_per_sample))
) / rate_hz;
esd_latency += ESD_BUF_SIZE * 2;
#endif
if(esd_latency > 0) {
lag_serv = (esd_latency * 4.0f) / (bytes_per_sample * rate_hz);
lag_seconds = lag_net + lag_serv;
audio_delay += lag_seconds;
mp_msg(MSGT_AO, MSGL_INFO,MSGTR_AO_ESD_LatencyInfo,
lag_serv, lag_net, lag_seconds);
}
esd_play_fd = esd_play_stream_fallback(esd_fmt, rate_hz,
server, ESD_CLIENT_NAME);
if (esd_play_fd < 0) {
mp_msg(MSGT_AO, MSGL_ERR, MSGTR_AO_ESD_CantOpenPBStream, strerror(errno));
return 0;
}
/* enable non-blocking i/o on the socket connection to the esd server */
if ((fl = fcntl(esd_play_fd, F_GETFL)) >= 0)
fcntl(esd_play_fd, F_SETFL, O_NDELAY|fl);
#if ESD_DEBUG
{
int sbuf, rbuf, len;
len = sizeof(sbuf);
getsockopt(esd_play_fd, SOL_SOCKET, SO_SNDBUF, &sbuf, &len);
len = sizeof(rbuf);
getsockopt(esd_play_fd, SOL_SOCKET, SO_RCVBUF, &rbuf, &len);
dprintf("esd: send/receive socket buffer space %d/%d bytes\n",
sbuf, rbuf);
}
#endif
ao_data.bps = bytes_per_sample * rate_hz;
ao_data.outburst = ao_data.bps > 100000 ? 4*ESD_BUF_SIZE : 2*ESD_BUF_SIZE;
esd_play_start.tv_sec = 0;
esd_samples_written = 0;
esd_bytes_per_sample = bytes_per_sample;
return 1;
}
int audio_open(struct audio_info_struct *ai)
{
esd_format_t format = ESD_STREAM | ESD_PLAY;
if (!esd_rate)
{
int esd;
esd_server_info_t *info;
esd_format_t fmt;
if ((esd = esd_open_sound(NULL)) >= 0)
{
info = esd_get_server_info(esd);
esd_rate = info->rate;
fmt = info->format;
esd_free_server_info(info);
esd_close(esd);
}
else
{
esd_rate = esd_audio_rate;
fmt = esd_audio_format;
}
esd_format = AUDIO_FORMAT_UNSIGNED_8;
if ((fmt & ESD_MASK_BITS) == ESD_BITS16)
esd_format |= AUDIO_FORMAT_SIGNED_16;
esd_channels = fmt & ESD_MASK_CHAN;
}
if (ai->format == -1)
ai->format = esd_format;
else if (!(ai->format & esd_format))
{
fprintf(stderr, "audio: Unsupported audio format: %d\n", ai->format);
errno = EINVAL;
return -1;
}
if (ai->format & AUDIO_FORMAT_SIGNED_16)
format |= ESD_BITS16;
else if (ai->format & AUDIO_FORMAT_UNSIGNED_8)
format |= ESD_BITS8;
else
assert(0);
if (ai->channels == -1)
ai->channels = 2;
else if (ai->channels <= 0 || ai->channels > esd_channels)
{
fprintf(stderr, "audio: Unsupported no of channels: %d\n", ai->channels);
errno = EINVAL;
return -1;
}
if (ai->channels == 1)
format |= ESD_MONO;
else if (ai->channels == 2)
format |= ESD_STEREO;
else
assert(0);
if (ai->rate == -1)
ai->rate = esd_rate;
else if (ai->rate > esd_rate)
return -1;
ai->fn = esd_play_stream_fallback(format, ai->rate, param.esdserver, "mpg123");
return (ai->fn);
}
