static int nas_init(void) { TRACE("NAS INIT\n"); if (!(AuServ = AuOpenServer(NULL, 0, NULL, 0, NULL, NULL))) return 0; return 1; }
static int init(struct audio_init *init) { char const *servername; char *message; servername = init->path; if (servername && *servername == 0) servername = 0; server = AuOpenServer(servername, 0, 0, 0, 0, &message); if (server == 0) { audio_error = message ? message : _("AuOpenServer() failed"); /* N.B. AuFree(message) never called */ return -1; } flow = AuCreateFlow(server, 0); if (flow == 0) { AuCloseServer(server); audio_error = _("could not create flow"); return -1; } return 0; }
int audio_init(int argc,char *argv[]) { int rate_set = samp_rate; int vol = 0; argc = getargs("Nas",argc, argv, "r", "%d", &rate_set, "Sample rate Hz", "V", "%d", &vol, "Volume 0 .. 1.0", "a", "", &audioserver,"Name of server", NULL); if (help_only) return argc; if ((aud = AuOpenServer(audioserver, 0, NULL, 0, NULL, NULL)) == (AuServer *) 0) perror(audioserver); if (rate_set && rate_set != samp_rate) samp_rate = rate_set; if (vol) volume = vol; return argc; }
static int Audio_Available(void) { AuServer *aud = AuOpenServer("", 0, NULL, 0, NULL, NULL); if (!aud) return 0; AuCloseServer(aud); return 1; }
int init_audio(void) { #ifdef USE_SOUND int type; if(!sm->usesound) return -1; #if defined(HP_LINEAR) if(read_data(AUDIOPATH,AUDIO_8UL) ) audio = open("/dev/audioBL",O_WRONLY|BLOCKDEVICE); /* test */ if(audio == -1) sm->usesound = 0; #elif defined(SIMPLE_AUDIO) if(read_data(AUDIOPATH,AUDIO_8ULAW) ) audio = open("/dev/audio",O_WRONLY|BLOCKDEVICE); if(audio == -1) sm->usesound = 0; #elif defined(SS10_AUDIO) if(read_data(AUDIOPATH,AUDIO_16SL) ) { audio = open("/dev/audio",O_WRONLY|BLOCKDEVICE); if(ioctl(audio, AUDIO_GETDEV, &type)) audio = -1; if(type == AUDIO_DEV_UNKNOWN || type == AUDIO_DEV_AMD) audio = -1; AUDIO_INITINFO(&ainfo); ainfo.play.encoding = AUDIO_ENCODING_LINEAR; ainfo.play.channels = 1; /* 8000, 9600, 11025, 16000, 18900, 22050, 32000, 37800, 44100, 48000 */ ainfo.play.sample_rate = 22050; /* 44100 */ ainfo.play.precision = 16; if(ioctl(audio, AUDIO_SETINFO, &ainfo)) audio = -1; ioctl(audio, AUDIO_GETINFO, &ainfo); printf("rate: %d\n",ainfo.play.sample_rate); printf("channels: %d\n",ainfo.play.channels); printf("precision: %d\n",ainfo.play.precision); printf("encoding: %d\n",ainfo.play.encoding); } if(audio == -1) sm->usesound = 0; #elif defined(NCD_AUDIO) audio = -1; aud = AuOpenServer(auservername, 0, NULL, 0, NULL, NULL); if (!aud) { fprintf(stderr, "Can't connect to audio server\n"); sm->usesound = 0; } #endif fprintf(stderr,"audioopen: %d\n",audio); #endif return audio; }
int ao_plugin_test() { AuServer* aud = 0; aud = AuOpenServer(0, 0, 0, 0, 0, 0); if (!aud) return 0; else { AuCloseServer(aud); return 1; } }
/* returning -1 on error, 0 on success... */ static int open_nas(out123_handle *ao) { if(!ao) return -1; if (!(info.aud = AuOpenServer(ao->device, 0, NULL, 0, NULL, NULL))) { if (ao->device==NULL) { error("could not open default NAS server"); } else { error1("could not open NAS server %s\n", ao->device); } return -1; } info.buf_size = 0; return 0; }
static AuServer * nas_try_connection(char *server) { AuServer *result = NULL; char *err_message = NULL; /* open server */ NAS_DEBUG_C("trying to contact NAS server: %s\n", server); message(GETTEXT("trying to contact NAS server at %s..."), server); result = AuOpenServer(server, 0, NULL, 0, NULL, &err_message); if (!result) { NAS_DEBUG_C("cannot contact NAS server: %s\n", (err_message ? err_message : ":(")); } return result; }
static gboolean gst_nas_sink_open (GstAudioSink * asink) { GstNasSink *sink = GST_NAS_SINK (asink); GST_DEBUG_OBJECT (sink, "opening, host = '%s'", GST_STR_NULL (sink->host)); /* Open Server */ sink->audio = AuOpenServer (sink->host, 0, NULL, 0, NULL, NULL); if (sink->audio == NULL) { GST_DEBUG_OBJECT (sink, "opening failed"); return FALSE; } sink->flow = AuNone; sink->need_data = 0; /* Start a flow */ GST_DEBUG_OBJECT (asink, "opened audio device"); return TRUE; }
static int NAS_OpenAudio(_THIS, SDL_AudioSpec *spec) { AuElement elms[3]; int buffer_size; Uint16 test_format, format; this->hidden->mixbuf = NULL; /* Try for a closest match on audio format */ format = 0; for ( test_format = SDL_FirstAudioFormat(spec->format); ! format && test_format; ) { format = sdlformat_to_auformat(test_format); if (format == AuNone) { test_format = SDL_NextAudioFormat(); } } if ( format == 0 ) { SDL_SetError("Couldn't find any hardware audio formats"); return(-1); } spec->format = test_format; this->hidden->aud = AuOpenServer("", 0, NULL, 0, NULL, NULL); if (this->hidden->aud == 0) { SDL_SetError("Couldn't open connection to NAS server"); return (-1); } this->hidden->dev = find_device(this, spec->channels); if ((this->hidden->dev == AuNone) || (!(this->hidden->flow = AuCreateFlow(this->hidden->aud, NULL)))) { AuCloseServer(this->hidden->aud); this->hidden->aud = 0; SDL_SetError("Couldn't find a fitting playback device on NAS server"); return (-1); } buffer_size = spec->freq; if (buffer_size < 4096) buffer_size = 4096; if (buffer_size > 32768) buffer_size = 32768; /* So that the buffer won't get unmanageably big. */ /* Calculate the final parameters for this audio specification */ SDL_CalculateAudioSpec(spec); this2 = this->hidden; AuMakeElementImportClient(elms, spec->freq, format, spec->channels, AuTrue, buffer_size, buffer_size / 4, 0, NULL); AuMakeElementExportDevice(elms+1, 0, this->hidden->dev, spec->freq, AuUnlimitedSamples, 0, NULL); AuSetElements(this->hidden->aud, this->hidden->flow, AuTrue, 2, elms, NULL); AuRegisterEventHandler(this->hidden->aud, AuEventHandlerIDMask, 0, this->hidden->flow, event_handler, (AuPointer) NULL); AuStartFlow(this->hidden->aud, this->hidden->flow, NULL); /* Allocate mixing buffer */ this->hidden->mixlen = spec->size; this->hidden->mixbuf = (Uint8 *)SDL_AllocAudioMem(this->hidden->mixlen); if ( this->hidden->mixbuf == NULL ) { return(-1); } memset(this->hidden->mixbuf, spec->silence, spec->size); /* Get the parent process id (we're the parent of the audio thread) */ this->hidden->parent = getpid(); /* We're ready to rock and roll. :-) */ return(0); }
static int init(struct xmp_context *ctx) { struct xmp_options *o = &ctx->o; int channels, rate, format, buf_samples; int duration, gain, watermark; char *server; AuDeviceID device = AuNone; AuElement element[2]; char *token, **parm; int i; duration = 2; gain = 100; server = NULL; watermark = 10; channels = 2; rate = o->freq; parm_init(); chkparm1("duration", duration = atoi(token)); chkparm1("gain", gain = atoi(token)); chkparm1("server", server = token); chkparm1("watermark", watermark = atoi(token)); parm_end(); if (o->resol == 8) { format = o->outfmt & XMP_FMT_UNS ? AuFormatLinearUnsigned8 : AuFormatLinearSigned8; } else { if (o->big_endian) { format = o->outfmt & XMP_FMT_UNS ? AuFormatLinearUnsigned16MSB : AuFormatLinearSigned16MSB; } else { format = o-> outfmt & XMP_FMT_UNS ? AuFormatLinearUnsigned16LSB : AuFormatLinearSigned16LSB; } } if (o->outfmt & XMP_FMT_MONO) channels = 1; info.aud = AuOpenServer(server, 0, NULL, 0, NULL, NULL); if (!info.aud) { fprintf(stderr, "xmp: drv_nas: can't connect to server %s\n", server ? server : ""); return XMP_ERR_DINIT; } for (i = 0; i < AuServerNumDevices(info.aud); i++) { if (((AuDeviceKind(AuServerDevice(info.aud, i)) == AuComponentKindPhysicalOutput) && AuDeviceNumTracks(AuServerDevice(info.aud, i)) == channels)) { device = AuDeviceIdentifier(AuServerDevice(info.aud, i)); break; } } info.da = AuGetDeviceAttributes(info.aud, device, NULL); if (!info.da) { fprintf(stderr, "xmp: drv_nas: can't get device attributes\n"); AuCloseServer(info.aud); return XMP_ERR_DINIT; } AuDeviceGain(info.da) = AuFixedPointFromSum(gain, 0); AuSetDeviceAttributes(info.aud, AuDeviceIdentifier(info.da), AuCompDeviceGainMask, info.da, NULL); info.flow = AuCreateFlow(info.aud, NULL); if (!info.flow) { fprintf(stderr, "xmp: drv_nas: can't create flow\n"); AuCloseServer(info.aud); return XMP_ERR_DINIT; } buf_samples = rate * duration; AuMakeElementImportClient(&element[0], rate, format, channels, AuTrue, buf_samples, (AuUint32) (buf_samples * watermark / 100), 0, NULL); AuMakeElementExportDevice(&element[1], 0, device, rate, AuUnlimitedSamples, 0, NULL); AuSetElements(info.aud, info.flow, AuTrue, 2, element, NULL); AuRegisterEventHandler(info.aud, AuEventHandlerIDMask, 0, info.flow, nas_event, (AuPointer) & info); info.buf_size = buf_samples * channels * AuSizeofFormat(format); info.buf = (char *)malloc(info.buf_size); info.buf_cnt = 0; info.data_sent = AuFalse; info.finished = AuFalse; AuStartFlow(info.aud, info.flow, NULL); return xmp_smix_on(ctx); }
/* StartRecording: open the device for recording. XXX this routine is almost identical to snd_Start(). The two should be factored into a single function! */ static int sound_StartRecording(int desiredSamplesPerSec, int stereo0, int semaIndex0) { AuElement elements[2]; /* elements for the NAS flow to assemble: element 0 = physical input element 1 = client export */ AuDeviceID device; /* physical device ID to use */ DPRINTF("StartRecording\n"); sound_Stop(); DPRINTF("opening server\n"); server = AuOpenServer(NULL, 0, NULL, 0, NULL, NULL); if(server == NULL) { DPRINTF("failed to open audio server\n"); return false; } /* XXX check protocol version of the server */ semaIndex= semaIndex0; stereo= stereo0; sampleRate= desiredSamplesPerSec; device= choose_nas_device(server, desiredSamplesPerSec, stereo, 1); if(device == AuNone) { DPRINTF("no available device on the server!\n"); AuCloseServer(server); server = NULL; return false; } /* record format info */ fmtBytes=2; fmtSigned=1; fmtStereo=stereo; fmtIsBigendian=0; recording=1; /* create a flow to read from */ DPRINTF("creating flow\n"); flow = AuCreateFlow(server, NULL); /* create client and device elements to record with */ DPRINTF("creating elements\n"); AuMakeElementImportDevice(&elements[0], desiredSamplesPerSec, /* XXX should use the actual sampling rate of device */ device, AuUnlimitedSamples, 0, NULL); AuMakeElementExportClient(&elements[1], 0, desiredSamplesPerSec, AuFormatLinearSigned16LSB, /* XXX this should be chosen based on the platform */ stereo ? 2 : 1, AuTrue, 1000000, /* was AuUnlimitedSamples */ 1000, /* water mark: go ahead and send frequently! */ 0, NULL); /* set up the flow with these elements */ AuSetElements(server, flow, AuTrue, 2, elements, NULL); /* start her up */ DPRINTF("starting flow\n"); AuStartFlow(server, flow, NULL); AuFlush(server); /* initialize the space indication */ bytesAvail = 0; /* arrange to be informed when events come in from the server */ aioEnable(AuServerConnectionNumber(server), NULL, AIO_EXT); aioHandle(AuServerConnectionNumber(server), handleAudioEvents, AIO_W); return true; }
static int sound_Start(int frameCount, int samplesPerSec, int stereo0, int semaIndex0) { AuElement elements[2]; /* first is a client element, second is a device output element */ AuDeviceID device; /* ID of the device to play to */ /* open the server */ DPRINTF("opening server\n"); server = AuOpenServer(NULL, 0, NULL, 0, NULL, NULL); if(server == NULL) { DPRINTF("failed to open audio server\n"); return false; } /* XXX should check the protocol version! */ /* record requested info */ semaIndex = semaIndex0; stereo = stereo0; sampleRate= samplesPerSec; /* pick a device to play to */ device = choose_nas_device(server, samplesPerSec, stereo, 0); if(device == AuNone) { DPRINTF("no available device on the server!\n"); AuCloseServer(server); server = NULL; return false; } /* set up output parameters */ fmtBytes=2; fmtSigned=1; fmtStereo=stereo; fmtIsBigendian=0; recording=0; /* create a flow to write on */ DPRINTF("creating flow\n"); flow = AuCreateFlow(server, NULL); /* create client and device elements to play with */ DPRINTF("creating elements(%d,%d)\n", frameCount, frameCount / 4); AuMakeElementImportClient(&elements[0], samplesPerSec, AuFormatLinearSigned16LSB, /* XXX this should be chosen based on the platform */ stereo ? 2 : 1, AuTrue, 2*frameCount, /* max: 2 buffers */ frameCount, /* low */ 0, NULL); AuMakeElementExportDevice(&elements[1], 0, device, samplesPerSec, AuUnlimitedSamples, 0, NULL); /* set up the flow with these elements */ AuSetElements(server, flow, AuTrue, 2, elements, NULL); /* start her up */ DPRINTF("starting flow\n"); AuStartFlow(server, flow, NULL); AuFlush(server); /* initialize the space indication */ bytesAvail = 0; /* arrange to be informed when events come in from the server */ aioEnable(AuServerConnectionNumber(server), 0, AIO_EXT); aioHandle(AuServerConnectionNumber(server), handleAudioEvents, AIO_R); return true; }
int ao_plugin_open(ao_device *device, ao_sample_format *format) { ao_nas_internal *internal = (ao_nas_internal *) device->internal; unsigned char nas_format; AuElement elms[2]; /* get format */ switch (format->bits) { case 8 : nas_format = AuFormatLinearUnsigned8; break; case 16 : if (device->machine_byte_format == AO_FMT_BIG) nas_format = AuFormatLinearSigned16MSB; else nas_format = AuFormatLinearSigned16LSB; break; default : return 0; } /* open server */ internal->aud = AuOpenServer(internal->host, 0, 0, 0, 0, 0); if (!internal->aud) return 0; /* Could not contact NAS server */ /* find physical output device */ { int i; for (i = 0; i < AuServerNumDevices(internal->aud); i++) if ((AuDeviceKind(AuServerDevice(internal->aud, i)) == AuComponentKindPhysicalOutput) && (AuDeviceNumTracks(AuServerDevice(internal->aud, i)) == device->output_channels)) break; if ((i == AuServerNumDevices(internal->aud)) || (!(internal->flow = AuCreateFlow(internal->aud, 0)))) { /* No physical output device found or flow creation failed. */ AuCloseServer(internal->aud); return 0; } internal->dev = AuDeviceIdentifier(AuServerDevice(internal->aud, i)); } /* set up flow */ AuMakeElementImportClient(&elms[0], format->rate, nas_format, device->output_channels, AuTrue, internal->buf_size, internal->buf_size / 2, 0, 0); AuMakeElementExportDevice(&elms[1], 0, internal->dev, format->rate, AuUnlimitedSamples, 0, 0); AuSetElements(internal->aud, internal->flow, AuTrue, 2, elms, 0); AuStartFlow(internal->aud, internal->flow, 0); device->driver_byte_format = AO_FMT_NATIVE; if(!device->inter_matrix) { /* set up out matrix such that users are warned about > stereo playback */ if(device->output_channels<=2) device->inter_matrix=strdup("L,R"); //else no matrix, which results in a warning } return 1; }