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); }