// -------------------------------------------------------------------------- // StopProduction(): see wxSoundStream // -------------------------------------------------------------------------- bool wxSoundStreamESD::StopProduction() { #ifndef HAVE_ESD_H m_snderror = wxSOUND_INVDEV; return false; #else if (m_esd_stop) return false; if (m_fd_input != -1) { esd_close(m_fd_input); #ifdef __WXGTK__ gdk_input_remove(m_tag_input); #endif } if (m_fd_output != -1) { esd_close(m_fd_output); #ifdef __WXGTK__ gdk_input_remove(m_tag_output); #endif } m_fd_input = -1; m_fd_output= -1; m_esd_stop = true; m_q_filled = true; return true; #endif // defined HAVE_ESD_H }
int AudioESound::close_all() { if(device->r || device->d) { close(esd_in_fd); esd_close(esd_in); } if(device->w || device->d) { close(esd_out_fd); esd_close(esd_out); } }
void X11Audio::close(void) { if ( isinit() ) { esd_close(m_esd_connection); } }
int ao_plugin_close(ao_device *device) { ao_esd_internal *internal = (ao_esd_internal *) device->internal; if(internal->bugfill && internal->sock != -1){ if(internal->bugfill<4096){ switch(internal->bits){ case 8: memset(internal->bugbuffer + internal->bugfill, 128, 4096-internal->bugfill); break; default: memset(internal->bugbuffer + internal->bugfill, 0, 4096-internal->bugfill); break; } } write4096(internal->sock,internal->bugbuffer); internal->bugfill = 0; } if(internal->sock != -1) esd_close(internal->sock); internal->sock=-1; return 1; }
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; }
CSndserv::~CSndserv() { #ifdef G_OS_WIN32 #else if (fd>=0) esd_close(fd); #endif }
void __rouexit() { #ifdef CHECK_STACK unsigned t; long maxFrames = 0; while (cstkszv[ELG_MY_THREAD] > 0) { elg_ui4 rid=ELG_NO_ID; long frame = --cstkszv[ELG_MY_THREAD]; if (frame < EpkMaxFrames) rid=cstackv[ELG_MY_THREAD][frame]; elg_warning("Missed exit for frame %d (rid=%d)", frame, rid); /* esd_exit(rid); */ } for (t=0; t<ELG_NUM_THREADS; t++) { if (cstackv[t]) free(cstackv[t]); if (cstkmxv[t] > maxFrames) maxFrames = cstkmxv[t]; } if (cstackv) free(cstackv); if (cstkszv) free(cstkszv); if (cstkmxv) free(cstkmxv); elg_cntl_msg("Freed %d-depth callstacks (max=%d) for %d threads", EpkMaxFrames, maxFrames, ELG_NUM_THREADS); if (maxFrames > EpkMaxFrames) elg_warning("Depth %d callstacks truncated by ESD_FRAMES=%d", maxFrames, EpkMaxFrames); #endif /* set after measurement to be reported during finalization */ epk_comp_status = &epk_filter_status; /* close measurement */ esd_close(); }
//_______________________________________________ // // //_______________________________________________ uint8_t esdAudioDevice::stop(void) { if (esdDevice > 0) { esd_close(esdDevice); esdDevice = 0; } return 1; }
/* * close audio device */ static void uninit(int immed) { if (esd_play_fd >= 0) { esd_close(esd_play_fd); esd_play_fd = -1; } if (esd_svinfo) { esd_free_server_info(esd_svinfo); esd_svinfo = NULL; } if (esd_fd >= 0) { esd_close(esd_fd); esd_fd = -1; } }
int AudioStopPlayback (int flush_output) { if (audio.playsock != -1) { esd_close(audio.playsock); audio.playsock = -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 int finish(struct audio_finish *finish) { if (esd_close(esd) < 0) { audio_error = ":esd_close"; return -1; } return 0; }
static void ao_esd_exit(ao_driver_t *this_gen) { esd_driver_t *this = (esd_driver_t *) this_gen; if (this->audio_fd != -1) esd_close(this->audio_fd); free(this->pname); free (this); }
static void close_esd(void * data) { esd_t * e = data; esd_close(e->esd_socket); gavl_audio_frame_destroy(e->f); if(e->src) { gavl_audio_source_destroy(e->src); e->src = NULL; } }
static gboolean gst_esdsink_close (GstAudioSink * asink) { GstEsdSink *esdsink = GST_ESDSINK (asink); GST_DEBUG_OBJECT (esdsink, "close"); gst_caps_replace (&esdsink->cur_caps, NULL); esd_close (esdsink->ctrl_fd); esdsink->ctrl_fd = -1; return TRUE; }
void release_esd(void *handle) { esd_openal_info_t *eh; if(handle == NULL) { return; } eh = (esd_openal_info_t *) handle; esd_close(eh->esdhandle); return; }
static vmResult esd_term(void) { if (server_fd > 0) { esd_close(server_fd); server_fd = 0; } if (sound_fd > 0) { esd_close(sound_fd); sound_fd = 0; } /* if (server_fd > 0) { close(server_fd); server_fd = 0; } if (sound_fd > 0) { close(sound_fd); sound_fd = 0; } */ return vmOk; }
int X11Audio::play(int1 * p_sample, uint4 p_samplesize, uint p_rate) { if ( isinit() ) { uint t_func = ESD_PLAY | ESD_STREAM | m_flags; int chan ; chan = esd_play_stream(t_func, p_rate, NULL, NULL); uint t_bytes_written ; t_bytes_written = write(chan, p_sample, p_samplesize); esd_close(chan); return t_bytes_written ; } }
void TrashAudio(void) { #ifndef NO_SOUND int Error; // Sound off, pause off SndRate = 0; AudioPaused = 0; #ifdef __PLAYBOOK__ SDL_CloseAudio(); #else // Wait for audio thread to finish if(Thr) pthread_join(Thr,0); #endif // Sound trashed #ifndef __PLAYBOOK__ // If audio was initialized... if(SoundFD>=0) { #if defined(PULSE_AUDIO) if(SoundFD) pa_simple_free(SoundFD); #elif defined(ESD_AUDIO) esd_close(SoundFD); #elif defined(SUN_AUDIO) close(SoundFD); #else ioctl(SoundFD,SNDCTL_DSP_RESET); close(SoundFD); #endif } SoundFD = -1; Thr = 0; #endif // If buffers were allocated... if(SndData) free(SndData); SndData = 0; SndSize = 0; RPtr = 0; WPtr = 0; #endif }
wxSoundStreamESD::wxSoundStreamESD(const wxString& hostname) { #ifndef HAVE_ESD_H m_snderror = wxSOUND_INVDEV; return; #else wxSoundFormatPcm pcm_default; // First, we make some basic test: is there ESD on this computer ? m_esd_ok = false; if (hostname.IsNull()) m_fd_output = esd_play_stream(ESD_PLAY | ESD_STREAM, 22050, hostname.mb_str(), MY_ESD_NAME); else m_fd_output = esd_play_stream(ESD_PLAY | ESD_STREAM, 22050, NULL, MY_ESD_NAME); if (m_fd_output == -1) { // Answer: no. We return with an error. m_snderror = wxSOUND_INVDEV; return; } // Close this unuseful stream. esd_close(m_fd_output); m_hostname = hostname; // Set the default audio format SetSoundFormat(pcm_default); // Initialize some variable m_snderror = wxSOUND_NOERROR; m_esd_stop = true; m_q_filled = true; m_esd_ok = true; m_fd_output= -1; m_fd_input = -1; #endif // defined HAVE_ESD_H }
static int config(struct audio_config *config) { unsigned int bitdepth; esd_format_t format = ESD_STREAM | ESD_PLAY; extern char const *argv0; int result = 0; bitdepth = config->precision & ~7; if (bitdepth == 0 || bitdepth > 16) bitdepth = 16; switch (config->precision = bitdepth) { case 8: audio_pcm = audio_pcm_u8; format |= ESD_BITS8; break; case 16: audio_pcm = audio_pcm_s16; format |= ESD_BITS16; break; } format |= (config->channels == 2) ? ESD_STEREO : ESD_MONO; if (esd_close(esd) < 0) { audio_error = ":esd_close"; result = -1; } esd = esd_play_stream_fallback(format, config->speed, host, argv0); if (esd < 0 && result == 0) { audio_error = ":esd_play_stream_fallback"; result = -1; } return result; }
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); }
int main( int argc, char ** argv) { int fd; int count; SoundSample * ss; int buf_len; int l; int r; int ml = 1; int mr = 1; int x; int i; char VU[16]; char packet[128]; float xf; struct sockaddr_in si_other; int s; int slen=sizeof(si_other); int rc; char * srv_ip; srv_ip = argv[1]; slen = sizeof(si_other); if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1) { printf("failed to make the socket\n"); exit(1); } memset((char *) &si_other, 0, sizeof(si_other)); si_other.sin_family = AF_INET; si_other.sin_port = htons(PORT); if (inet_aton(srv_ip, &si_other.sin_addr)==0) { fprintf(stderr, "inet_aton() failed\n"); exit(1); } memset(VU, '\0', 16); memset(packet, '\0', 128); fd = esd_monitor_stream( SOUND_FORMAT, SAMPLE_RATE, NULL, "gkrellmss"); if (fd < 0) { printf("vouldnt open it succa\n"); esd_close(fd); return; } signal(2, cnt_c); count = 1024; ss = (SoundSample *) calloc(sizeof(SoundSample), count); while(!g_done) { buf_len = sizeof(SoundSample) * count; count = read(fd, ss, buf_len); if (count < 0) { goto err; } l = abs(ss[0].left); r = abs(ss[0].right); l = l * 707 / 1000; r = r * 707 / 1000; if(l > ml) ml = l; if(r > mr) mr = r; /* printf("%f %f \r", (float)l/ml, (float)r/mr); */ memset(VU, ' ', 15); xf = 10.0 * (float)l/(float)ml; x = (int)xf; if (xf - (float)x > 0.5) { x++; } x--; for(i = 0; i < x; i++) { VU[i] = 'F'; } printf("%s\r", VU); buf_len = strlen(packet); sprintf(packet, "uid 0FFFFFFFFF 0%s", VU); rc = sendto(s, packet, buf_len, 0, &si_other, slen); if(rc < 0) { printf("failed to send a packet"); exit(3); } sprintf(packet, "cab 0FFFFFFFFF 0%s", VU); rc = sendto(s, packet, buf_len, 0, &si_other, slen); if(rc < 0) { printf("failed to send a packet"); exit(3); } usleep(10); } close(s); esd_close(fd); printf("\n"); printf("done\n"); return 0; err: esd_close(fd); return 1; }
static void stop_esd(void * p) { esd_t * e = p; esd_close(e->esd_socket); }
/* * connect to esd */ static int ao_esd_open(ao_driver_t *this_gen, uint32_t bits, uint32_t rate, int mode) { esd_driver_t *this = (esd_driver_t *) this_gen; esd_format_t format; xprintf (this->xine, XINE_VERBOSITY_DEBUG, "audio_esd_out: ao_open bits=%d rate=%d, mode=%d\n", bits, rate, mode); if ( (mode & this->capabilities) == 0 ) { xprintf (this->xine, XINE_VERBOSITY_DEBUG, "audio_esd_out: unsupported mode %08x\n", mode); return 0; } if (this->audio_fd>=0) { if ( (mode == this->mode) && (rate == this->input_sample_rate) ) return this->output_sample_rate; esd_close (this->audio_fd); } this->mode = mode; this->input_sample_rate = rate; this->output_sample_rate = rate; this->bytes_in_buffer = 0; this->start_time.tv_sec = 0; /* * open stream to ESD server */ format = ESD_STREAM | ESD_PLAY | ESD_BITS16; switch (mode) { case AO_CAP_MODE_MONO: format |= ESD_MONO; this->num_channels = 1; break; case AO_CAP_MODE_STEREO: format |= ESD_STEREO; this->num_channels = 2; break; } xprintf (this->xine, XINE_VERBOSITY_DEBUG, "audio_esd_out: %d channels output\n",this->num_channels); this->bytes_per_frame=(bits*this->num_channels)/8; #if ESD_RESAMPLE /* esd resamples (only for sample rates < the esd server's sample rate) */ if (this->output_sample_rate > this->server_sample_rate) this->output_sample_rate = this->server_sample_rate; #else /* use xine's resample code */ this->output_sample_rate = this->server_sample_rate; #endif this->output_sample_k_rate = this->output_sample_rate / 1000; this->audio_fd = esd_play_stream(format, this->output_sample_rate, NULL, this->pname); if (this->audio_fd < 0) { char *server = getenv("ESPEAKER"); xprintf(this->xine, XINE_VERBOSITY_LOG, _("audio_esd_out: connecting to ESD server %s: %s\n"), server ? server : "<default>", strerror(errno)); return 0; } return this->output_sample_rate; }
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); }
static void ao_esd_close(ao_driver_t *this_gen) { esd_driver_t *this = (esd_driver_t *) this_gen; esd_close(this->audio_fd); this->audio_fd = -1; }
void cyg_profile_finalize () { esd_close(); }