diff options
Diffstat (limited to 'third_party/resample/sndlib-20/audio.c')
| -rw-r--r-- | third_party/resample/sndlib-20/audio.c | 9867 |
1 files changed, 9867 insertions, 0 deletions
diff --git a/third_party/resample/sndlib-20/audio.c b/third_party/resample/sndlib-20/audio.c new file mode 100644 index 00000000..32649bb3 --- /dev/null +++ b/third_party/resample/sndlib-20/audio.c @@ -0,0 +1,9867 @@ +/* Audio hardware handlers (SGI, OSS, ALSA, Sun, Windows, Mac OSX, Jack, ESD, HPUX, NetBSD) */ + +/* + * layout of this file: + * error handlers + * SGI new and old audio library + * OSS (with Sam 9407 support) + * ALSA + * Sun (has switches for OpenBSD, but they're untested) + * Windows 95/98 + * OSX + * ESD + * JACK + * HPUX + * NetBSD + * audio describers + */ + +/* + * void mus_audio_describe(void) describes the audio hardware state. + * char *mus_audio_report(void) returns the same information as a string. + * + * int mus_audio_open_output(int dev, int srate, int chans, int format, int size) + * int mus_audio_open_input(int dev, int srate, int chans, int format, int size) + * int mus_audio_write(int line, char *buf, int bytes) + * int mus_audio_close(int line) + * int mus_audio_read(int line, char *buf, int bytes) + * + * int mus_audio_mixer_read(int dev, int field, int chan, float *val) + * int mus_audio_mixer_write(int dev, int field, int chan, float *val) + * int mus_audio_initialize(void) does whatever is needed to get set up + * int mus_audio_systems(void) returns number of separate complete audio systems (soundcards essentially) + * AUDIO_SYSTEM(n) selects the nth card (counting from 0), AUDIO_SYSTEM(0) is always the default + * char *mus_audio_system_name(int system) returns some user-recognizable (?) name for the given card (don't free) + * char *mus_audio_moniker(void) returns some brief description of the overall audio setup (don't free return string). + */ + +/* error handling is tricky here -- higher levels are using many calls as probes, so + * the "error" is a sign of non-existence, not a true error. So, for nearly all + * cases, I'll use mus_print, not mus_error. + */ + +#include <mus-config.h> + +#if USE_SND && MUS_MAC_OSX && USE_MOTIF + #undef USE_MOTIF + #define USE_NO_GUI 1 + /* Xt's Boolean (/usr/include/X11/Intrinsic.h = char) collides with MacTypes.h Boolean, (actually, + * unsigned char in /Developer/SDKs/MacOSX10.4u.sdk/System/Library/Frameworks/CoreFoundation.framework/Versions/A/Headers/CFBase.h) + * but we want snd.h for other stuff, so, if Motif is in use, don't load its headers at this time + * perhaps we could use the -funsigned-char switch in gcc + */ +#endif + +#if USE_SND && MUS_MAC_OSX && HAVE_RUBY + /* if using Ruby, OpenTransport.h T_* definitions collide with Ruby's -- it isn't needed here, so... */ + #define REDEFINE_HAVE_RUBY 1 + #undef HAVE_RUBY +#endif + +#if USE_SND + #include "snd.h" +#else + #define PRINT_BUFFER_SIZE 512 + #define LABEL_BUFFER_SIZE 64 +#endif + +#if USE_SND && MUS_MAC_OSX + #define USE_MOTIF 1 + #undef USE_NO_GUI + #if REDEFINE_HAVE_RUBY + #define HAVE_RUBY 1 + #endif +#endif + +#include <math.h> +#include <stdio.h> +#if HAVE_FCNTL_H + #include <fcntl.h> +#endif +#include <errno.h> +#include <stdlib.h> +#if (defined(HAVE_LIBC_H) && (!defined(HAVE_UNISTD_H))) + #include <libc.h> +#else + #if (!(defined(_MSC_VER))) + #include <unistd.h> + #endif +#endif +#if HAVE_STRING_H + #include <string.h> +#endif + +#if HAVE_SAM_9407 + #include <sys/sam9407.h> +#endif + +#ifdef MUS_MAC_OSX +#include <CoreServices/CoreServices.h> +#include <CoreAudio/CoreAudio.h> +/* these pull in stdbool.h apparently, so they have to precede sndlib.h */ +#endif + +#include "_sndlib.h" +#include "sndlib-strings.h" + +#if (!HAVE_STRERROR) +char *strerror(int errnum) +{ + char *strerrbuf; + strerrbuf = (char *)CALLOC(LABEL_BUFFER_SIZE, sizeof(char)); + mus_snprintf(strerrbuf, LABEL_BUFFER_SIZE, "io err %d", errnum); + return(strerrbuf); +} +#endif + +#define MUS_STANDARD_ERROR(Error_Type, Error_Message) \ + mus_print("%s\n [%s[%d] %s]", Error_Message, __FILE__, __LINE__, c__FUNCTION__) + +#define MUS_STANDARD_IO_ERROR(Error_Type, IO_Func, IO_Name) \ + mus_print("%s %s: %s\n [%s[%d] %s]", IO_Func, IO_Name, strerror(errno), __FILE__, __LINE__, c__FUNCTION__) + + +static char *version_name = NULL; +static bool audio_initialized = false; + +static const char *mus_audio_device_names[] = { + S_mus_audio_default, S_mus_audio_duplex_default, S_mus_audio_adat_in, S_mus_audio_aes_in, S_mus_audio_line_out, + S_mus_audio_line_in, S_mus_audio_microphone, S_mus_audio_speakers, S_mus_audio_digital_in, S_mus_audio_digital_out, + S_mus_audio_dac_out, S_mus_audio_adat_out, S_mus_audio_aes_out, S_mus_audio_dac_filter, S_mus_audio_mixer, + S_mus_audio_line1, S_mus_audio_line2, S_mus_audio_line3, S_mus_audio_aux_input, S_mus_audio_cd, + S_mus_audio_aux_output, S_mus_audio_spdif_in, S_mus_audio_spdif_out, S_mus_audio_amp, S_mus_audio_srate, + S_mus_audio_channel, S_mus_audio_format, S_mus_audio_imix, S_mus_audio_igain, S_mus_audio_reclev, + S_mus_audio_pcm, S_mus_audio_pcm2, S_mus_audio_ogain, S_mus_audio_line, S_mus_audio_synth, + S_mus_audio_bass, S_mus_audio_treble, S_mus_audio_port, S_mus_audio_samples_per_channel, + S_mus_audio_direction +}; + +static const char *mus_audio_device_name(int dev) +{ + if (MUS_AUDIO_DEVICE_OK(dev)) + return(mus_audio_device_names[dev]); + return("invalid device"); +} + +#if (!HAVE_OSS) || (HAVE_ALSA) +static const char *mus_audio_format_names[] = { + "unknown", S_mus_bshort, S_mus_mulaw, S_mus_byte, S_mus_bfloat, S_mus_bint, S_mus_alaw, S_mus_ubyte, S_mus_b24int, + S_mus_bdouble, S_mus_lshort, S_mus_lint, S_mus_lfloat, S_mus_ldouble, S_mus_ubshort, S_mus_ulshort, S_mus_l24int, + S_mus_bintn, S_mus_lintn +}; + +static const char *mus_audio_format_name(int fr) +{ + if (MUS_DATA_FORMAT_OK(fr)) + return(mus_audio_format_names[fr]); + return("invalid format"); +} +#endif + +static char *audio_strbuf = NULL; /* previous name "strbuf" collides with Mac OSX global! */ +static void pprint(char *str); + +int device_channels(int dev); +int device_gains(int dev); + +int device_channels(int dev) +{ + float val[4]; +#if USE_SND && MUS_DEBUGGING + XEN res; + res = XEN_EVAL_C_STRING("(if (defined? 'debugging-device-channels) debugging-device-channels 0)"); + if (XEN_INTEGER_P(res)) + { + int chans; + chans = XEN_TO_C_INT(res); + if (chans > 0) return(chans); + } +#endif + mus_audio_mixer_read(dev, MUS_AUDIO_CHANNEL, 0, val); + return((int)val[0]); +} + +int device_gains(int ur_dev) +{ + float val[4]; + int err; + int dev; + dev = MUS_AUDIO_DEVICE(ur_dev); + /* to get hardware gains, read device amp_field and error = none */ + if ((dev == MUS_AUDIO_DAC_FILTER) || (dev == MUS_AUDIO_MIXER)) + { + err = mus_audio_mixer_read(ur_dev, MUS_AUDIO_CHANNEL, 0, val); +#ifdef HAVE_ALSA + if (err != MUS_NO_ERROR) return(0); +#endif + return((int)val[0]); + } + err = mus_audio_mixer_read(ur_dev, MUS_AUDIO_AMP, 0, val); + if (err != MUS_NO_ERROR) return(0); + return(device_channels(ur_dev)); +} + + + +/* ------------------------------- SGI ----------------------------------------- */ + +#ifdef MUS_SGI +#define AUDIO_OK + +#include <audio.h> + +int mus_audio_systems(void) {return(1);} /* I think more than 1 is possible, but don't have a case to test with */ + +char *mus_audio_system_name(int system) {return("SGI");} + +char *mus_audio_moniker(void) +{ +#ifdef AL_RESOURCE + return("New SGI audio"); +#else + return("Old SGI audio"); +#endif +} + +#ifndef AL_RESOURCE +static char *alGetErrorString(int err) +{ + switch (err) + { + case AL_BAD_NOT_IMPLEMENTED: return("not implemented yet"); break; + case AL_BAD_PORT: return("tried to use an invalid port"); break; + case AL_BAD_CONFIG: return("tried to use an invalid configuration"); break; + case AL_BAD_DEVICE: return("tried to use an invalid device"); break; + case AL_BAD_DEVICE_ACCESS: return("unable to access the device"); break; + case AL_BAD_DIRECTION: return("invalid direction given for port"); break; + case AL_BAD_OUT_OF_MEM: return("operation has run out of memory"); break; + case AL_BAD_NO_PORTS: return("not able to allocate a port"); break; + case AL_BAD_WIDTH: return("invalid sample width given"); break; + case AL_BAD_ILLEGAL_STATE: return("an invalid state has occurred"); break; + case AL_BAD_QSIZE: return("attempt to set an invalid queue size"); break; + case AL_BAD_FILLPOINT: return("attempt to set an invalid fillpoint"); break; + case AL_BAD_BUFFER_NULL: return("null buffer pointer"); break; + case AL_BAD_COUNT_NEG: return("negative count"); break; + case AL_BAD_PVBUFFER: return("param/val buffer doesn't make sense"); break; + case AL_BAD_BUFFERLENGTH_NEG: return("negative buffer length"); break; + case AL_BAD_BUFFERLENGTH_ODD: return("odd length parameter/value buffer"); break; + case AL_BAD_CHANNELS: return("invalid channel specifier"); break; + case AL_BAD_PARAM: return("invalid parameter"); break; + case AL_BAD_SAMPFMT: return("attempt to set invalid sample format"); break; + case AL_BAD_RATE: return("invalid sample rate token"); break; + case AL_BAD_TRANSFER_SIZE: return("invalid size for sample read/write"); break; + case AL_BAD_FLOATMAX: return("invalid size for floatmax"); break; + case AL_BAD_PORTSTYLE: return("invalid port style"); break; + default: return(""); + } +} +#endif + +static char *sgi_err_buf = NULL; +static mus_print_handler_t *old_handler = NULL; + +static void sgi_mus_print(char *msg) +{ + int oserr = oserror(); + if (oserr) + { + if (sgi_err_buf == NULL) sgi_err_buf = (char *)CALLOC(PRINT_BUFFER_SIZE, sizeof(char)); + mus_snprintf(sgi_err_buf, PRINT_BUFFER_SIZE, "%s [%s]", msg, alGetErrorString(oserr)); + (*old_handler)(sgi_err_buf); + } + else (*old_handler)(msg); +} + +static void start_sgi_print(void) +{ + if (old_handler != sgi_mus_print) + old_handler = mus_print_set_handler(sgi_mus_print); +} + +static void end_sgi_print(void) +{ + if (old_handler != sgi_mus_print) + mus_print_set_handler(old_handler); + else mus_print_set_handler(NULL); +} + + +#if AL_RESOURCE + #define al_free(Line) alFreeConfig(config[Line]) + #define al_newconfig() alNewConfig() + #define al_setsampfmt(Line, Format) alSetSampFmt(Line, Format) + #define al_setchannels(Line, Chans) alSetChannels(Line, Chans) + #define al_setwidth(Line, Width) alSetWidth(Line, Width) + #define al_setqueuesize(Line, Size) alSetQueueSize(Line, Size) + #define al_openport(Name, Flag, Line) alOpenPort(Name, Flag, Line) + #define al_getfilled(Port) alGetFilled(Port) + #define al_closeport(Port) alClosePort(Port) + #define al_freeconfig(Config) alFreeConfig(Config) +#else + #define al_free(Line) ALfreeconfig(config[Line]); + #define al_newconfig() ALnewconfig() + #define al_setsampfmt(Line, Format) ALsetsampfmt(Line, Format) + #define al_setchannels(Line, Chans) ALsetchannels(Line, Chans) + #define al_setwidth(Line, Width) ALsetwidth(Line, Width) + #define al_setqueuesize(Line, Size) ALsetqueuesize(Line, Size) + #define al_openport(Name, Flag, Line) ALopenport(Name, Flag, Line) + #define al_getfilled(Port) ALgetfilled(Port) + #define al_closeport(Port) ALcloseport(Port) + #define al_freeconfig(Config) ALfreeconfig(Config) +#endif + + +#define RETURN_ERROR_EXIT(Error_Type, Audio_Line, Ur_Error_Message) \ + do { \ + char *Error_Message; Error_Message = Ur_Error_Message; \ + if (Audio_Line != -1) al_free(Audio_Line); \ + if (Error_Message) \ + { \ + MUS_STANDARD_ERROR(Error_Type, Error_Message); FREE(Error_Message); \ + } \ + else MUS_STANDARD_ERROR(Error_Type, mus_error_type_to_string(Error_Type)); \ + end_sgi_print(); \ + return(MUS_ERROR); \ + } while (false) + + +#ifdef AL_RESOURCE + +static int check_queue_size(int size, int chans) +{ + if (size > chans * 1024) + return(size); + else return(chans * 1024); +} + +#else + +#define STEREO_QUEUE_MIN_SIZE 1024 +#define STEREO_QUEUE_MIN_CHOICE 1024 +/* docs say 510 or 512, but they die with "File size limit exceeded" %$@#!(& */ +#define MONO_QUEUE_MIN_SIZE 1019 +#define MONO_QUEUE_MIN_CHOICE 1024 +#define STEREO_QUEUE_MAX_SIZE 131069 +#define STEREO_QUEUE_MAX_CHOICE 65536 +#define MONO_QUEUE_MAX_SIZE 262139 +#define MONO_QUEUE_MAX_CHOICE 131072 +/* if these limits are not followed, the damned thing dumps core and dies */ + +static int check_queue_size(int size, int chans) +{ + if ((chans == 1) && (size > MONO_QUEUE_MAX_SIZE)) return(MONO_QUEUE_MAX_CHOICE); + if ((chans == 1) && (size < MONO_QUEUE_MIN_SIZE)) return(MONO_QUEUE_MIN_CHOICE); + if ((chans > 1) && (size > STEREO_QUEUE_MAX_SIZE)) return(STEREO_QUEUE_MAX_CHOICE); + if ((chans > 1) && (size < STEREO_QUEUE_MIN_SIZE)) return(STEREO_QUEUE_MIN_CHOICE); + return(size); +} + +static void check_quad(int device, int channels) +{ + long sr[2]; + /* if quad, make sure we are set up for it, else make sure we aren't (perhaps the latter is unnecessary) */ + /* in 4 channel mode, stereo mic and line-in are 4 inputs, headphones/speakers and stereo line-out are the 4 outputs */ + sr[0] = AL_CHANNEL_MODE; + ALgetparams(device, sr, 2); + if ((channels == 4) && (sr[1] != AL_4CHANNEL)) + { + sr[1] = AL_4CHANNEL; + ALsetparams(device, sr, 2); + } + else + { + if ((channels != 4) && (sr[1] != AL_STEREO)) + { + sr[1] = AL_STEREO; + ALsetparams(device, sr, 2); + } + } +} +#endif + +#define IO_LINES 8 +static ALconfig *config = NULL; +static ALport *port = NULL; +static int *line_in_use = NULL; +static int *channels = NULL; +static long *device = NULL; +static int *datum_size = NULL; +static int *line_out = NULL; + +int mus_audio_initialize(void) +{ + if (!audio_initialized) + { + audio_initialized = true; + config = (ALconfig *)CALLOC(IO_LINES, sizeof(ALconfig)); + port = (ALport *)CALLOC(IO_LINES, sizeof(ALport)); + line_in_use = (int *)CALLOC(IO_LINES, sizeof(int)); + channels = (int *)CALLOC(IO_LINES, sizeof(int)); + device = (long *)CALLOC(IO_LINES, sizeof(long)); + datum_size = (int *)CALLOC(IO_LINES, sizeof(int)); + line_out = (int *)CALLOC(IO_LINES, sizeof(int)); + } + return(MUS_NO_ERROR); +} + +#ifdef AL_RESOURCE +static int to_al_interface_or_device(int dev, int which) +{ + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DUPLEX_DEFAULT: return(AL_DEFAULT_OUTPUT); break; + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: return(alGetResourceByName(AL_SYSTEM, "Analog Out", which)); break; + case MUS_AUDIO_MICROPHONE: return(alGetResourceByName(AL_SYSTEM, "Microphone", which)); break; + case MUS_AUDIO_ADAT_IN: return(alGetResourceByName(AL_SYSTEM, "ADAT In", which)); break; + case MUS_AUDIO_AES_IN: return(alGetResourceByName(AL_SYSTEM, "AES In", which)); break; + case MUS_AUDIO_ADAT_OUT: return(alGetResourceByName(AL_SYSTEM, "ADAT Out", which)); break; + case MUS_AUDIO_DIGITAL_OUT: + case MUS_AUDIO_AES_OUT: return(alGetResourceByName(AL_SYSTEM, "AES Out", which)); break; + case MUS_AUDIO_LINE_IN: return(alGetResourceByName(AL_SYSTEM, "Line In", which)); break; + case MUS_AUDIO_LINE_OUT: return(alGetResourceByName(AL_SYSTEM, "Line Out2", which)); break; /* ?? */ + /* case MUS_AUDIO_DIGITAL_IN: return(alGetResourceByName(AL_SYSTEM, "DAC2 In", which)); break; */ /* this is analog in ?? */ + } + return(MUS_ERROR); +} + +static int to_al_device(int dev) +{ + return(to_al_interface_or_device(dev, AL_DEVICE_TYPE)); +} + +static int to_al_interface(int dev) +{ + return(to_al_interface_or_device(dev, AL_INTERFACE_TYPE)); +} +#endif + +#include <stdio.h> + +/* just a placeholder for now */ +int find_audio_output(int chans) +{ +#ifdef AL_RESOURCE + ALvalue x[32]; + ALpv y; + int n, i; + y.param = AL_INTERFACE; + y.value.i = AL_DIGITAL_IF_TYPE; + n = alQueryValues(AL_SYSTEM, AL_DEFAULT_OUTPUT, x, 32, &y, 1); + for (i = 0; i < n; i++) + { + y.param = AL_CHANNELS; + alGetParams(x[i].i, &y, 1); + if (chans <= y.value.i) return(x[i].i); + } +#endif + return(MUS_ERROR); +} + +static int to_sgi_format(int frm) +{ + switch (frm) + { + case MUS_BYTE: + case MUS_BSHORT: + case MUS_B24INT: return(AL_SAMPFMT_TWOSCOMP); break; + case MUS_BFLOAT: return(AL_SAMPFMT_FLOAT); break; + case MUS_BDOUBLE: return(AL_SAMPFMT_DOUBLE); break; + } + return(MUS_ERROR); +} + +int mus_audio_open_output(int ur_dev, int srate, int chans, int format, int requested_size) +{ +#ifdef AL_RESOURCE + ALpv z[2]; +#endif + long sr[2]; + int i, line, size, width, sgi_format, dev; + start_sgi_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + line = -1; + for (i = 0; i < IO_LINES; i++) + if (line_in_use[i] == 0) + { + line = i; + break; + } + if (line == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_NO_LINES_AVAILABLE, line, + "no free audio lines?"); + channels[line] = chans; + line_out[line] = 1; + + if (requested_size == 0) + size = 1024 * chans; + else size = check_queue_size(requested_size, chans); + /* if (chans > 2) size = 65536; */ /* for temp adat code */ + + datum_size[line] = mus_bytes_per_sample(format); + if (datum_size[line] == 3) + width = AL_SAMPLE_24; + else + { + if (datum_size[line] == 1) + width = AL_SAMPLE_8; + else width = AL_SAMPLE_16; + } + sgi_format = to_sgi_format(format); + if (sgi_format == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d (%s) not supported by SGI", + format, + mus_audio_format_name(format))); +#ifdef AL_RESOURCE + if (dev == MUS_AUDIO_DEFAULT) + device[line] = AL_DEFAULT_OUTPUT; + else device[line] = to_al_device(dev); + if (!(device[line])) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, -1, + mus_format("device %d (%s) not available", + dev, + mus_audio_device_name(dev))); +#if 0 + if (device_channels(dev) < chans) /* look for some device that can play this file */ + device[line] = find_audio_output(chans); + if (device[line] == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, -1, + mus_format("can't find %d channel device", + chans)); +#endif + if ((chans == 4) && (dev == MUS_AUDIO_DAC_OUT)) + { /* kludge around a bug in the new audio library */ + sr[0] = AL_CHANNEL_MODE; + sr[1] = AL_4CHANNEL; + ALsetparams(AL_DEFAULT_DEVICE, sr, 2); + } + z[0].param = AL_RATE; + z[0].value.ll = alDoubleToFixed((double)srate); + z[1].param = AL_MASTER_CLOCK; + /* z[1].value.i = AL_CRYSTAL_MCLK_TYPE; */ + z[1].value.i = AL_MCLK_TYPE; /* was AL_CRYSTAL_MCLK_TYPE -- digital I/O perhaps needs AL_VARIABLE_MCLK_TYPE */ + if (alSetParams(device[line], z, 2) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, -1, + mus_format("can't set srate of %s to %d", + mus_audio_device_name(dev), + srate)); +#else + device[line] = AL_DEFAULT_DEVICE; + check_quad(device[line], chans); + sr[0] = AL_OUTPUT_RATE; + sr[1] = srate; + if (ALsetparams(device[line], sr, 2) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, -1, + mus_format("can't set srate of %s to %d", + mus_audio_device_name(dev), + srate)); +#endif + + config[line] = al_newconfig(); + if (!(config[line])) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, -1, + "can't allocate audio configuration?"); + if ((al_setsampfmt(config[line], sgi_format) == -1) || + (al_setwidth(config[line], width) == -1)) /* this is a no-op in the float and double cases */ + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, line, + mus_format("audio format %d (%s, SGI: %d) not available on device %d (%s)", + format, mus_audio_format_name(format), sgi_format, + dev, + mus_audio_device_name(dev))); + if (al_setchannels(config[line], chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, line, + mus_format("can't get %d channels on device %d (%s)", + chans, dev, mus_audio_device_name(dev))); + + /* set queue size probably needs a check first for legal queue sizes given the current desired device */ + /* in new AL, I'm assuming above (check_queue_size) that it needs at least 1024 per chan */ + if (al_setqueuesize(config[line], size) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SIZE_NOT_AVAILABLE, line, + mus_format("can't get queue size %d on device %d (%s) (chans: %d, requested_size: %d)", + size, dev, + mus_audio_device_name(dev), + chans, requested_size)); + +#ifdef AL_RESOURCE + if (alSetDevice(config[line], device[line]) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, line, + mus_format("can't get device %d (%s)", + dev, + mus_audio_device_name(dev))); +#endif + + port[line] = al_openport("dac", "w", config[line]); + if (!(port[line])) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, line, + mus_format("can't open output port on device %d (%s)", + dev, + mus_audio_device_name(dev))); + line_in_use[line] = 1; + end_sgi_print(); + return(line); +} + +int mus_audio_write(int line, char *buf, int bytes) +{ + start_sgi_print(); +#ifdef AL_RESOURCE + if (alWriteFrames(port[line], (short *)buf, bytes / (channels[line] * datum_size[line]))) +#else + if (ALwritesamps(port[line], (short *)buf, bytes / datum_size[line])) +#endif + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + "write error"); + end_sgi_print(); + return(MUS_NO_ERROR); +} + +int mus_audio_close(int line) +{ + int err; + start_sgi_print(); + if (line_in_use[line]) + { + if (line_out[line]) + while (al_getfilled(port[line]) > 0) + sginap(1); + err = ((al_closeport(port[line])) || + (al_freeconfig(config[line]))); + line_in_use[line] = 0; + if (err) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_CLOSE, -1, + mus_format("can't close audio port %p (line %d)", + port[line], line)); + } + end_sgi_print(); + return(MUS_NO_ERROR); +} + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int requested_size) +{ + int dev; +#ifdef AL_RESOURCE + ALpv pv; + ALpv x[2]; +#else + long sr[2]; + int resind; +#endif + int i, line, sgi_format; + start_sgi_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + line = -1; + for (i = 0; i < IO_LINES; i++) + if (line_in_use[i] == 0) + { + line = i; + break; + } + if (line == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_NO_LINES_AVAILABLE, -1, + "no free audio lines?"); + channels[line] = chans; + line_out[line] = 0; + datum_size[line] = mus_bytes_per_sample(format); +#ifdef AL_RESOURCE + if (dev == MUS_AUDIO_DEFAULT) + device[line] = AL_DEFAULT_INPUT; + else + { + int itf; + device[line] = to_al_device(dev); + itf = to_al_interface(dev); + if (itf) + { + pv.param = AL_INTERFACE; + pv.value.i = itf; + if (alSetParams(device[line], &pv, 1) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, -1, + mus_format("can't set up device %d (%s)", + dev, + mus_audio_device_name(dev))); + } + } + if (!(device[line])) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, -1, + mus_format("can't get input device %d (%s)", + dev, mus_audio_device_name(dev))); + x[0].param = AL_RATE; + x[0].value.ll = alDoubleToFixed((double)srate); + x[1].param = AL_MASTER_CLOCK; + x[1].value.i = AL_MCLK_TYPE; /* AL_CRYSTAL_MCLK_TYPE; */ + if (alSetParams(device[line], x, 2) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, -1, + mus_format("can't set srate of %s to %d", + mus_audio_device_name(dev), + srate)); +#else + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_MICROPHONE: resind = AL_INPUT_MIC; break; + case MUS_AUDIO_LINE_IN: resind = AL_INPUT_LINE; break; + case MUS_AUDIO_DIGITAL_IN: resind = AL_INPUT_DIGITAL; break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, -1, + mus_format("audio input device %d (%s) not available", + dev, + mus_audio_device_name(dev))); + break; + } + device[line] = AL_DEFAULT_DEVICE; + sr[0] = AL_INPUT_SOURCE; + sr[1] = resind; + if (ALsetparams(device[line], sr, 2) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, -1, + mus_format("can't set up input device %d (%s)", + dev, + mus_audio_device_name(dev))); + check_quad(device[line], chans); + sr[0] = AL_INPUT_RATE; + sr[1] = srate; + if (ALsetparams(device[line], sr, 2) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, -1, + mus_format("can't set srate of %s to %d", + mus_audio_device_name(dev), + srate)); +#endif + + config[line] = al_newconfig(); + if (!(config[line])) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, -1, + "can't allocate audio configuration?"); + sgi_format = to_sgi_format(format); + if (sgi_format == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d (%s) not supported by SGI", + format, + mus_audio_format_name(format))); + if ((al_setsampfmt(config[line], sgi_format) == -1) || + (al_setwidth(config[line], (datum_size[line] == 2) ? AL_SAMPLE_16 : AL_SAMPLE_8) == -1)) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, line, + mus_format("audio format %d (%s, SGI: %d) not available on device %d (%s)", + format, + mus_audio_format_name(format), sgi_format, + dev, + mus_audio_device_name(dev))); + if (al_setchannels(config[line], chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, line, + mus_format("can't get %d channels on device %d (%s)", + chans, dev, + mus_audio_device_name(dev))); + +#ifdef AL_RESOURCE + if (alSetDevice(config[line], device[line]) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, line, + mus_format("can't get device %d (%s)", + dev, + mus_audio_device_name(dev))); +#endif + + port[line] = al_openport("adc", "r", config[line]); + if (!(port[line])) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, line, + mus_format("can't open input port on device %d (%s)", + dev, + mus_audio_device_name(dev))); + line_in_use[line] = 1; + end_sgi_print(); + return(line); +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + start_sgi_print(); +#ifdef AL_RESOURCE + if (alReadFrames(port[line], (short *)buf, bytes / (channels[line] * datum_size[line]))) +#else + if (ALreadsamps(port[line], (short *)buf, bytes / datum_size[line])) +#endif + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + "read error"); + end_sgi_print(); + return(MUS_NO_ERROR); +} + + +#ifdef AL_RESOURCE +/* borrowed from /usr/share/src/dmedia/audio/printdevs.c with modifications */ + +#define MAX_CHANNELS 8 + +static float dB_to_linear(float val) +{ + if (val == 0.0) return(1.0); + return(pow(10.0, val / 20.0)); +} + +static float dB_to_normalized(float val, float lo, float hi) +{ + float linlo; + if (hi <= lo) return(1.0); + linlo = dB_to_linear(lo); + return((dB_to_linear(val) - linlo) / (dB_to_linear(hi) - linlo)); +} + +static float normalized_to_dB(float val_norm, float lo_dB, float hi_dB) +{ + if (hi_dB <= lo_dB) return(0.0); + return(lo_dB + (hi_dB - lo_dB) * val_norm); +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + ALpv x[4]; + ALparamInfo pinf; + ALfixed g[MAX_CHANNELS]; + int rv = 0, i, dev; + start_sgi_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + if (field != MUS_AUDIO_PORT) + { + rv = to_al_device(dev); + if (!rv) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, -1, + mus_format("can't read %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + } + switch (field) + { + case MUS_AUDIO_PORT: + /* in this case, chan == length of incoming val array. Number of devices is returned as val[0], + * and the rest of the available area (if needed) is filled with the device ids. + */ + i = 0; + if (alGetResourceByName(AL_SYSTEM, "Microphone", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_MICROPHONE; i++;} + if (alGetResourceByName(AL_SYSTEM, "Analog Out", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_DAC_OUT; i++;} + if (alGetResourceByName(AL_SYSTEM, "ADAT In", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_ADAT_IN; i++;} + if (alGetResourceByName(AL_SYSTEM, "AES In", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_AES_IN; i++;} + if (alGetResourceByName(AL_SYSTEM, "ADAT Out", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_ADAT_OUT; i++;} + if (alGetResourceByName(AL_SYSTEM, "AES Out", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_AES_OUT; i++;} + if (alGetResourceByName(AL_SYSTEM, "Line In", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_LINE_IN; i++;} + /* if (alGetResourceByName(AL_SYSTEM, "DAC2 In", AL_DEVICE_TYPE) != 0) {if ((i + 1) < chan) val[i + 1] = MUS_AUDIO_DIGITAL_IN; i++;} */ + val[0] = i; + break; + case MUS_AUDIO_FORMAT: + val[0] = 1; + if (chan > 1) val[1] = MUS_BSHORT; + break; + case MUS_AUDIO_CHANNEL: + x[0].param = AL_CHANNELS; + if (alGetParams(rv, x, 1) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("can't read channel setting of %s", + mus_audio_device_name(dev))); + val[0] = (float)(x[0].value.i); + break; + case MUS_AUDIO_SRATE: + x[0].param = AL_RATE; + if (alGetParams(rv, x, 1) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("can't read srate setting of %s", + mus_audio_device_name(dev))); + val[0] = (float)(x[0].value.i); + break; + case MUS_AUDIO_AMP: + if (alGetParamInfo(rv, AL_GAIN, &pinf) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("can't read gain settings of %s", + mus_audio_device_name(dev))); + if (pinf.min.ll == pinf.max.ll) + RETURN_ERROR_EXIT(MUS_AUDIO_AMP_NOT_AVAILABLE, -1, + mus_format("%s's gain apparently can't be set", + mus_audio_device_name(dev))); + /* this ridiculous thing is in dB with completely arbitrary min and max values */ + x[0].param = AL_GAIN; + x[0].value.ptr = g; + x[0].sizeIn = MAX_CHANNELS; + alGetParams(rv, x, 1); + if (x[0].sizeOut <= chan) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, -1, + mus_format("can't read gain settings of %s channel %d", + mus_audio_device_name(dev), chan)); + val[0] = dB_to_normalized(alFixedToDouble(g[chan]), + alFixedToDouble(pinf.min.ll), + alFixedToDouble(pinf.max.ll)); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, + mus_format("can't read %s setting of %s", + mus_audio_device_name(field), + mus_audio_device_name(dev))); + break; + } + end_sgi_print(); + return(MUS_NO_ERROR); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + /* each field coming in assumes 0.0 to 1.0 as the range */ + ALpv x[4]; + ALparamInfo pinf; + ALfixed g[MAX_CHANNELS]; + int rv, dev; + start_sgi_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + rv = to_al_device(dev); + if (!rv) RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, -1, + mus_format("can't write %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + switch (field) + { + case MUS_AUDIO_SRATE: + x[0].param = AL_RATE; + x[0].value.i = (int)val[0]; + x[1].param = AL_MASTER_CLOCK; + x[1].value.i = AL_CRYSTAL_MCLK_TYPE; + alSetParams(rv, x, 2); + break; + case MUS_AUDIO_AMP: + /* need to change normalized linear value into dB between (dB) lo and hi */ + if (alGetParamInfo(rv, AL_GAIN, &pinf) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("can't write gain settings of %s", + mus_audio_device_name(dev))); + /* I think we need to read all channels here, change the one we care about, then write all channels */ + x[0].param = AL_GAIN; + x[0].value.ptr = g; + x[0].sizeIn = MAX_CHANNELS; + alGetParams(rv, x, 1); + if (x[0].sizeOut <= chan) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, -1, + mus_format("can't write gain settings of %s channel %d", + mus_audio_device_name(dev), + chan)); + g[chan] = alDoubleToFixed(normalized_to_dB(val[0], + alFixedToDouble(pinf.min.ll), + alFixedToDouble(pinf.max.ll))); + if (alSetParams(rv, x, 1) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("can't write gain settings of %s", + mus_audio_device_name(dev))); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, + mus_format("can't write %s setting of %s", + mus_audio_device_name(field), + mus_audio_device_name(dev))); + break; + } + end_sgi_print(); + return(MUS_NO_ERROR); +} + +#define STRING_SIZE 32 +static void dump_resources(ALvalue *x, int rv) +{ + ALpv y[4]; + ALparamInfo pinf; + ALfixed g[MAX_CHANNELS]; + char dn[STRING_SIZE]; + char dl[STRING_SIZE]; + int i, k; + ALvalue z[16]; + int nres; + for (i = 0; i < rv; i++) + { + y[0].param = AL_LABEL; + y[0].value.ptr = dl; + y[0].sizeIn = STRING_SIZE; + y[1].param = AL_NAME; + y[1].value.ptr = dn; + y[1].sizeIn = STRING_SIZE; + y[2].param = AL_CHANNELS; + y[3].param = AL_RATE; + alGetParams(x[i].i, y, 5); + if (alIsSubtype(AL_DEVICE_TYPE, x[i].i)) + { + alGetParamInfo(x[i].i, AL_GAIN, &pinf); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "\nDevice: %s (%s), srate: %d, chans: %d", + dn, dl, + y[3].value.i, + y[2].value.i); + pprint(audio_strbuf); + if (pinf.min.ll != pinf.max.ll) + { + ALpv yy; + yy.param = AL_GAIN; + yy.value.ptr = g; + yy.sizeIn = MAX_CHANNELS; + alGetParams(x[i].i, &yy, 1); + pprint(" amps:["); + for (k = 0; k < yy.sizeOut; k++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%.2f", + dB_to_normalized(alFixedToDouble(g[k]), + alFixedToDouble(pinf.min.ll), + alFixedToDouble(pinf.max.ll))); + pprint(audio_strbuf); + if (k < (yy.sizeOut - 1)) pprint(" "); + } + pprint("]"); + } + pprint("\n"); + if ((nres= alQueryValues(x[i].i, AL_INTERFACE, z, 16, 0, 0)) >= 0) + dump_resources(z, nres); + else mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "query failed: %s\n", alGetErrorString(oserror())); + pprint(audio_strbuf); + } + else + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s (%s), chans: %d\n", dn, dl, y[2].value.i); + pprint(audio_strbuf); + } + } +} + +static void describe_audio_state_1(void) +{ + int rv; + ALvalue x[16]; + pprint("Devices and Interfaces on this system:\n"); + rv= alQueryValues(AL_SYSTEM, AL_DEVICES, x, 16, 0, 0); + if (rv > 0) + dump_resources(x, rv); +} + + +#else + +/* old audio library */ + +#define MAX_VOLUME 255 + +static int decode_field(int dev, int field, int chan) +{ + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_SPEAKERS: + switch (field) + { + case MUS_AUDIO_AMP: + return((chan == 0) ? AL_LEFT_SPEAKER_GAIN : AL_RIGHT_SPEAKER_GAIN); + break; + case MUS_AUDIO_SRATE: + return(AL_OUTPUT_RATE); + break; + } + break; + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_SRATE: + return(AL_OUTPUT_RATE); /* ? */ + break; + } + break; + case MUS_AUDIO_DIGITAL_OUT: + if (field == MUS_AUDIO_SRATE) + return(AL_OUTPUT_RATE); + break; + case MUS_AUDIO_DIGITAL_IN: + if (field == MUS_AUDIO_SRATE) + return(AL_INPUT_RATE); + break; + case MUS_AUDIO_LINE_IN: + if (field == MUS_AUDIO_AMP) + return((chan == 0) ? AL_LEFT_INPUT_ATTEN : AL_RIGHT_INPUT_ATTEN); + else + if (field == MUS_AUDIO_SRATE) + return(AL_INPUT_RATE); + break; + case MUS_AUDIO_MICROPHONE: + if (field == MUS_AUDIO_AMP) + return((chan == 0) ? AL_LEFT2_INPUT_ATTEN : AL_RIGHT2_INPUT_ATTEN); + else + if (field == MUS_AUDIO_SRATE) + return(AL_INPUT_RATE); + break; + } + return(MUS_ERROR); +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + long pb[4]; + long fld; + int dev, err = MUS_NO_ERROR; + start_sgi_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + switch (field) + { + case MUS_AUDIO_CHANNEL: + val[0] = 4; + break; + case MUS_AUDIO_FORMAT: + val[0] = 1; + if (chan > 1) val[1] = MUS_BSHORT; + break; + case MUS_AUDIO_PORT: + /* how to tell which machine we're on? */ + val[0] = 4; + if (chan > 1) val[1] = MUS_AUDIO_LINE_IN; + if (chan > 2) val[2] = MUS_AUDIO_MICROPHONE; + if (chan > 3) val[3] = MUS_AUDIO_DIGITAL_IN; + if (chan > 4) val[4] = MUS_AUDIO_DAC_OUT; + /* does this order work for digital input as well? (i.e. does it replace the microphone)? */ + break; + case MUS_AUDIO_AMP: + fld = decode_field(dev, field, chan); + if (fld != MUS_ERROR) + { + pb[0] = fld; + if (ALgetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("can't read gain settings of %s", + mus_audio_device_name(dev))); + if ((fld == AL_LEFT_SPEAKER_GAIN) || + (fld == AL_RIGHT_SPEAKER_GAIN)) + val[0] = ((float)pb[1]) / ((float)MAX_VOLUME); + else val[0] = 1.0 - ((float)pb[1]) / ((float)MAX_VOLUME); + } + else err = MUS_ERROR; + break; + case MUS_AUDIO_SRATE: + fld = decode_field(dev, field, chan); + if (fld != MUS_ERROR) + { + pb[0] = fld; + if (ALgetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("can't read srate setting of %s", + mus_audio_device_name(dev))); + val[0] = pb[1]; + } + else err = MUS_ERROR; + break; + default: + err = MUS_ERROR; + break; + } + if (err == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, + mus_format("can't read %s setting of %s", + mus_audio_device_name(field), + mus_audio_device_name(dev))); + end_sgi_print(); + return(MUS_NO_ERROR); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + long pb[4]; + long fld; + int dev, err = MUS_NO_ERROR; + start_sgi_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + switch (field) + { + case MUS_AUDIO_PORT: + if (dev == MUS_AUDIO_DEFAULT) + { + pb[0] = AL_CHANNEL_MODE; + pb[1] = ((chan == MUS_AUDIO_DIGITAL_IN) ? AL_STEREO : AL_4CHANNEL); + pb[2] = AL_INPUT_SOURCE; + pb[3] = ((chan == MUS_AUDIO_DIGITAL_IN) ? AL_INPUT_DIGITAL : AL_INPUT_MIC); + if (ALsetparams(AL_DEFAULT_DEVICE, pb, 4)) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("can't set mode and source of %s", + mus_audio_device_name(dev))); + } + else err = MUS_ERROR; + break; + case MUS_AUDIO_CHANNEL: + if (dev == MUS_AUDIO_MICROPHONE) + { + pb[0] = AL_MIC_MODE; + pb[1] = ((chan == 2) ? AL_STEREO : AL_MONO); + if (ALsetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("can't set microphone to be %s", + (chan == 2) ? "stereo" : "mono")); + } + else + { + if (dev == MUS_AUDIO_DEFAULT) + { + pb[0] = AL_CHANNEL_MODE; + pb[1] = ((chan == 4) ? AL_4CHANNEL : AL_STEREO); + if (ALsetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("can't set default device to be %s", + (chan == 4) ? "quad" : "stereo")); + } + else err = MUS_ERROR; + } + break; + case MUS_AUDIO_AMP: + fld = decode_field(dev, field, chan); + if (fld != -1) + { + pb[0] = fld; + if ((fld == AL_LEFT_SPEAKER_GAIN) || + (fld == AL_RIGHT_SPEAKER_GAIN)) + pb[1] = val[0] * MAX_VOLUME; + else pb[1] = (1.0 - val[0]) * MAX_VOLUME; + if (ALsetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("can't set gain of %s", + mus_audio_device_name(dev))); + } + else err = MUS_ERROR; + break; + case MUS_AUDIO_SRATE: + fld = decode_field(dev, field, chan); + if (fld != -1) + { + pb[0] = fld; + pb[1] = val[0]; + if (ALsetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, NULL); + if (fld == AL_INPUT_RATE) + { + pb[0] = AL_OUTPUT_RATE; + pb[1] = val[0]; + if (ALsetparams(AL_DEFAULT_DEVICE, pb, 2)) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("can't set srate of %s", + mus_audio_device_name(dev))); + } + } + else err = MUS_ERROR; + break; + default: + err = MUS_ERROR; + break; + } + if (err == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, -1, + mus_format("can't write %s setting of %s", + mus_audio_device_name(field), + mus_audio_device_name(dev))); + end_sgi_print(); + return(MUS_NO_ERROR); +} + +static void describe_audio_state_1(void) +{ + float amps[1]; + int err; + err = mus_audio_mixer_read(MUS_AUDIO_SPEAKERS, MUS_AUDIO_SRATE, 0, amps); + if (err == MUS_NO_ERROR) + {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "srate: %.2f\n", amps[0]); pprint(audio_strbuf);} + else {fprintf(stdout, "err: %d!\n", err); fflush(stdout);} + err = mus_audio_mixer_read(MUS_AUDIO_SPEAKERS, MUS_AUDIO_AMP, 0, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "speakers: %.2f", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_SPEAKERS, MUS_AUDIO_AMP, 1, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f\n", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_LINE_IN, MUS_AUDIO_AMP, 0, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "line in: %.2f", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_LINE_IN, MUS_AUDIO_AMP, 1, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f\n", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_MICROPHONE, MUS_AUDIO_AMP, 0, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "microphone: %.2f", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_MICROPHONE, MUS_AUDIO_AMP, 1, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f\n", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_LINE_OUT, MUS_AUDIO_AMP, 0, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "line out: %.2f", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_LINE_OUT, MUS_AUDIO_AMP, 1, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f\n", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_DIGITAL_OUT, MUS_AUDIO_AMP, 0, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "digital out: %.2f", amps[0]); pprint(audio_strbuf);} + err = mus_audio_mixer_read(MUS_AUDIO_DIGITAL_OUT, MUS_AUDIO_AMP, 1, amps); + if (err == MUS_NO_ERROR) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f\n", amps[0]); pprint(audio_strbuf);} +} + +#endif +/* new or old AL */ + +#endif +/* SGI */ + + + +/* ------------------------------- OSS ----------------------------------------- */ + +#if (HAVE_OSS || HAVE_ALSA || HAVE_JACK) +/* actually it's not impossible that someday we'll have ALSA but not OSS... */ +#define AUDIO_OK + +#include <sys/ioctl.h> + +/* the system version of the soundcard header file may have no relation to the current OSS actually loaded */ +/* sys/soundcard.h is usually just a pointer to linux/soundcard.h */ + +#if (MUS_HAVE_USR_LIB_OSS) + #include "/usr/lib/oss/include/sys/soundcard.h" +#else + #if (MUS_HAVE_USR_LOCAL_LIB_OSS) + #include "/usr/local/lib/oss/include/sys/soundcard.h" + #else + #if (MUS_HAVE_OPT_OSS) + #include "/opt/oss/include/sys/soundcard.h" + #else + #if (MUS_HAVE_VAR_LIB_OSS) + #include "/var/lib/oss/include/sys/soundcard.h" + #else + #if defined(HAVE_SYS_SOUNDCARD_H) || defined(MUS_LINUX) + #include <sys/soundcard.h> + #else + #if defined(HAVE_MACHINE_SOUNDCARD_H) + #include <machine/soundcard.h> + #else + #include <soundcard.h> + #endif + #endif + #endif + #endif + #endif +#endif + +#if ((SOUND_VERSION > 360) && (defined(OSS_SYSINFO))) + #define NEW_OSS 1 +#endif + +#define DAC_NAME "/dev/dsp" +#define MIXER_NAME "/dev/mixer" +#define SYNTH_NAME "/dev/music" +/* some programs use /dev/audio */ + +/* there can be more than one sound card installed, and a card can be handled through + * more than one /dev/dsp device, so we can't use a global dac device here. + * The caller has to keep track of the various cards (via AUDIO_SYSTEM) -- + * I toyed with embedding all that in mus_audio_open_output and mus_audio_write, but + * decided it's better to keep them explicit -- the caller may want entirely + * different (non-synchronous) streams going to the various cards. This same + * code (AUDIO_SYSTEM(n)->devn) should work in Windoze (see below), and + * might work on the Mac and SGI -- something for a rainy day... + */ + +#define RETURN_ERROR_EXIT(Message_Type, Audio_Line, Ur_Message) \ + do { \ + char *Message; Message = Ur_Message; \ + if (Audio_Line != -1) \ + linux_audio_close(Audio_Line); \ + if ((Message) && (strlen(Message) > 0)) \ + { \ + mus_print("%s\n [%s[%d] %s]", \ + Message, \ + __FILE__, __LINE__, c__FUNCTION__); \ + FREE(Message); \ + } \ + else mus_print("%s\n [%s[%d] %s]", \ + mus_error_type_to_string(Message_Type), \ + __FILE__, __LINE__, c__FUNCTION__); \ + return(MUS_ERROR); \ + } while (false) + +static int FRAGMENTS = 4; +static int FRAGMENT_SIZE = 12; +static bool fragments_locked = false; + +/* defaults here are FRAGMENTS 16 and FRAGMENT_SIZE 12; these values however + * cause about a .5 second delay, which is not acceptable in "real-time" situations. + * + * this changed 22-May-01: these are causing more trouble than they're worth + */ + +static void oss_mus_oss_set_buffers(int num, int size) {FRAGMENTS = num; FRAGMENT_SIZE = size; fragments_locked = true;} + +#define MAX_SOUNDCARDS 8 +#define MAX_DSPS 8 +#define MAX_MIXERS 8 +/* there can be (apparently) any number of mixers and dsps per soundcard, but 8 is enough! */ + +static int *audio_fd = NULL; +static int *audio_open_ctr = NULL; +static int *audio_dsp = NULL; +static int *audio_mixer = NULL; +static int *audio_mode = NULL; +typedef enum {NORMAL_CARD, SONORUS_STUDIO, RME_HAMMERFALL, SAM9407_DSP, DELTA_66} audio_card_t; +/* the Sonorus Studi/o card is a special case in all regards */ +static audio_card_t *audio_type = NULL; + +static int sound_cards = 0; +static int new_oss_running = 0; +static char *dev_name = NULL; + +static int oss_mus_audio_systems(void) +{ + return(sound_cards); +} + +static char *mixer_name(int sys) +{ +#if HAVE_SAM_9407 + if((sys < sound_cards) && (audio_type[sys] == SAM9407_DSP)) + { + mus_snprintf(dev_name, LABEL_BUFFER_SIZE, "/dev/sam%d_mixer", audio_mixer[sys]); + return(dev_name); + } +#endif + if (sys < sound_cards) + { + if (audio_mixer[sys] == -2) + return(MIXER_NAME); + /* if we have /dev/dsp (not /dev/dsp0), I assume the corresponding mixer is /dev/mixer (not /dev/mixer0) */ + /* but in sam9407 driver, there is no /dev/mixer, and everything goes through /dev/dsp */ + else + { + if (audio_mixer[sys] == -3) + return(DAC_NAME); + else + { + mus_snprintf(dev_name, LABEL_BUFFER_SIZE, "%s%d", MIXER_NAME, audio_mixer[sys]); + return(dev_name); + } + } + } + return(DAC_NAME); +} + +static char *oss_mus_audio_system_name(int system) +{ +#if HAVE_SAM_9407 + if((system < sound_cards) && (audio_type[system] == SAM9407_DSP)) + { + int fd; + fd = open(mixer_name(system), O_RDONLY, 0); + if(fd != -1) + { + static SamDriverInfo driverInfo; + if(ioctl(fd, SAM_IOC_DRIVER_INFO, &driverInfo) >= 0) + { + close(fd); + return(driverInfo.hardware); + } + close(fd); + } + return("sam9407"); + } +#endif +#ifdef NEW_OSS + static mixer_info mixinfo; + int status, ignored, fd; + fd = open(mixer_name(system), O_RDONLY, 0); + if (fd != -1) + { + status = ioctl(fd, OSS_GETVERSION, &ignored); + if (status == 0) + { + status = ioctl(fd, SOUND_MIXER_INFO, &mixinfo); + if (status == 0) + { + close(fd); + return(mixinfo.name); + } + } + close(fd); + } +#endif + return("OSS"); +} + +#if HAVE_SAM_9407 +static char *oss_mus_audio_moniker(void) {return("Sam 9407");} +#else +static char *oss_mus_audio_moniker(void) +{ + char version[LABEL_BUFFER_SIZE]; + if (version_name == NULL) version_name = (char *)CALLOC(LABEL_BUFFER_SIZE, sizeof(char)); + if (SOUND_VERSION < 361) + { + mus_snprintf(version, LABEL_BUFFER_SIZE, "%d", SOUND_VERSION); + mus_snprintf(version_name, LABEL_BUFFER_SIZE, "OSS %c.%c.%c", version[0], version[1], version[2]); + } + else + mus_snprintf(version_name, LABEL_BUFFER_SIZE, "OSS %x.%x.%x", + (SOUND_VERSION >> 16) & 0xff, + (SOUND_VERSION >> 8) & 0xff, + SOUND_VERSION & 0xff); + return(version_name); +} +#endif + +static char *dac_name(int sys, int offset) +{ +#if HAVE_SAM_9407 + if ((sys < sound_cards) && (audio_type[sys] == SAM9407_DSP)) + { + mus_snprintf(dev_name, LABEL_BUFFER_SIZE, "/dev/sam%d_dsp", audio_dsp[sys]); + return(dev_name); + } +#endif + if ((sys < sound_cards) && (audio_mixer[sys] >= -1)) + { + mus_snprintf(dev_name, LABEL_BUFFER_SIZE, "%s%d", DAC_NAME, audio_dsp[sys] + offset); + return(dev_name); + } + return(DAC_NAME); +} + +#define MIXER_SIZE SOUND_MIXER_NRDEVICES +static int **mixer_state = NULL; +static int *init_srate = NULL, *init_chans = NULL, *init_format = NULL; + +static int oss_mus_audio_initialize(void) +{ + /* here we need to set up the map of /dev/dsp and /dev/mixer to a given system */ + /* since this info is not passed to us by OSS, we have to work at it... */ + /* for the time being, I'll ignore auxiliary dsp and mixer ports (each is a special case) */ + int i, fd = -1, md, err = 0; + char dname[LABEL_BUFFER_SIZE]; + int amp, old_mixer_amp, old_dsp_amp, new_mixer_amp, responsive_field; + int devmask; +#ifdef NEW_OSS + int status, ignored; + oss_sysinfo sysinfo; + static mixer_info mixinfo; + int sysinfo_ok = 0; +#endif + int num_mixers, num_dsps, nmix, ndsp; + if (!audio_initialized) + { + audio_initialized = true; + audio_fd = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + audio_open_ctr = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + audio_dsp = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + audio_mixer = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + audio_type = (audio_card_t *)CALLOC(MAX_SOUNDCARDS, sizeof(audio_card_t)); + audio_mode = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + dev_name = (char *)CALLOC(LABEL_BUFFER_SIZE, sizeof(char)); + init_srate = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + init_chans = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + init_format = (int *)CALLOC(MAX_SOUNDCARDS, sizeof(int)); + mixer_state = (int **)CALLOC(MAX_SOUNDCARDS, sizeof(int *)); + for (i = 0; i < MAX_SOUNDCARDS; i++) mixer_state[i] = (int *)CALLOC(MIXER_SIZE, sizeof(int)); + for (i = 0; i < MAX_SOUNDCARDS; i++) + { + audio_fd[i] = -1; + audio_open_ctr[i] = 0; + audio_dsp[i] = -1; + audio_mixer[i] = -1; + audio_type[i] = NORMAL_CARD; + } +#if HAVE_SAM_9407 + { + SamApiInfo apiInfo; + SamDriverInfo driverInfo; + for (i = 0; i < MAX_SOUNDCARDS; i++) + { + mus_snprintf(dname, LABEL_BUFFER_SIZE, "/dev/sam%d_mixer", i); + fd = open(dname, O_WRONLY); + if (fd < 0) + break; + if ((ioctl(fd, SAM_IOC_API_INFO, &apiInfo) < 0) || + (apiInfo.apiClass!=SAM_API_CLASS_VANILLA) || + (ioctl(fd, SAM_IOC_DRIVER_INFO, &driverInfo) < 0) || + (!driverInfo.haveAudio)) + { + close(fd); + continue; + } + audio_type[sound_cards] = SAM9407_DSP; + audio_dsp[sound_cards] = i; + audio_mixer[sound_cards] = i; + sound_cards++; + close(fd); + } + if(sound_cards > 0) + return(0); + } +#endif + + num_mixers = MAX_MIXERS; + num_dsps = MAX_DSPS; +#ifdef NEW_OSS + fd = open(DAC_NAME, O_WRONLY | O_NONBLOCK, 0); + if (fd == -1) fd = open(SYNTH_NAME, O_RDONLY | O_NONBLOCK, 0); + if (fd == -1) fd = open(MIXER_NAME, O_RDONLY | O_NONBLOCK, 0); + if (fd != -1) + { + status = ioctl(fd, OSS_GETVERSION, &ignored); + new_oss_running = (status == 0); + if (new_oss_running) + { + status = ioctl(fd, OSS_SYSINFO, &sysinfo); + sysinfo_ok = (status == 0); + } + if ((new_oss_running) && (sysinfo_ok)) + { + num_mixers = sysinfo.nummixers; + num_dsps = sysinfo.numaudios; + } + close(fd); + } +#endif + + /* need to get which /dev/dsp lines match which /dev/mixer lines, + * find out how many separate systems (soundcards) are available, + * fill the audio_dsp and audio_mixer arrays with the system-related numbers, + * since we have no way to tell from OSS info which mixers/dsps are the + * main ones, we'll do some messing aound to try to deduce this info. + * for example, SB uses two dsp ports and two mixers per card, whereas + * Ensoniq uses 2 dsps and 1 mixer. + * + * the data we are gathering here: + * int audio_dsp[MAX_SOUNDCARDS] -> main_dsp_port[MUS_AUDIO_PACK_SYSTEM(n)] (-1 => no such system dsp) + * int audio_mixer[MAX_SOUNDCARDS] -> main_mixer_port[MUS_AUDIO_PACK_SYSTEM(n)] + * int sound_cards = 0 -> usable systems + * all auxiliary ports are currently ignored (SB equalizer, etc) + */ + sound_cards = 0; + ndsp = 0; + nmix = 0; + while ((nmix < num_mixers) && + (ndsp < num_dsps)) + { + /* for each mixer, find associated main dsp (assumed to be first in /dev/dsp ordering) */ + /* if mixer's dsp overlaps or we run out of dsps first, ignore it (aux mixer) */ + /* our by-guess-or-by-gosh method here is to try to open the mixer. + * if that fails, quit (if very first, try at least to get the dsp setup) + * find volume field, if none, go on, else read current volume + * open next unchecked dsp, try to set volume, read current, if different we found a match -- set and go on. + * if no change, move to next dsp and try again, if no more dsps, quit (checking for null case as before) + */ + mus_snprintf(dname, LABEL_BUFFER_SIZE, "%s%d", MIXER_NAME, nmix); + md = open(dname, O_RDWR, 0); + if (md == -1) + { + if (errno == EBUSY) + { + mus_print("%s is busy: can't access it [%s[%d] %s]", + dname, + __FILE__, __LINE__, c__FUNCTION__); + nmix++; + continue; + } + else break; + } + mus_snprintf(dname, LABEL_BUFFER_SIZE, "%s%d", DAC_NAME, ndsp); + fd = open(dname, O_RDWR | O_NONBLOCK, 0); + if (fd == -1) fd = open(dname, O_RDONLY | O_NONBLOCK, 0); + if (fd == -1) fd = open(dname, O_WRONLY | O_NONBLOCK, 0); /* some output devices need this */ + if (fd == -1) + { + close(md); + if (errno == EBUSY) /* in linux /usr/include/asm/errno.h */ + { + fprintf(stderr, "%s is busy: can't access it\n", dname); + ndsp++; + continue; + } + else + { + if ((errno != ENXIO) && (errno != ENODEV)) + fprintf(stderr, "%s: %s! ", dname, strerror(errno)); + break; + } + } +#ifdef NEW_OSS + /* can't change volume yet of Sonorus, so the method above won't work -- + * try to catch this case via the mixer's name + */ + status = ioctl(md, SOUND_MIXER_INFO, &mixinfo); + if ((status == 0) && + (mixinfo.name) && + (*(mixinfo.name)) && + (strlen(mixinfo.name) > 6)) + { + if (strncmp("STUDI/O", mixinfo.name, 7) == 0) + { + /* a special case in every regard */ + audio_type[sound_cards] = SONORUS_STUDIO; + audio_mixer[sound_cards] = nmix; + nmix++; + audio_dsp[sound_cards] = ndsp; + if (num_dsps >= 21) + { + ndsp += 21; + audio_mode[sound_cards] = 1; + } + else + { + ndsp += 9; + audio_mode[sound_cards] = 0; + } + sound_cards++; + close(fd); + close(md); + continue; + } + else + { + if (strncmp("RME Digi96", mixinfo.name, 10) == 0) + { + audio_type[sound_cards] = RME_HAMMERFALL; + audio_mixer[sound_cards] = nmix; + nmix++; + audio_dsp[sound_cards] = ndsp; + sound_cards++; + close(fd); + close(md); + continue; + } + else + { + if (strncmp("M Audio Delta", mixinfo.name, 13) == 0) + { + audio_type[sound_cards] = DELTA_66; + audio_mixer[sound_cards] = nmix; + nmix++; + ndsp += 6; /* just a guess */ + audio_dsp[sound_cards] = ndsp; + sound_cards++; + close(fd); + close(md); + continue; + } + } + } + } +#endif + err = ioctl(md, SOUND_MIXER_READ_DEVMASK, &devmask); + responsive_field = SOUND_MIXER_VOLUME; + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + if ((1 << i) & devmask) + { + responsive_field = i; + break; + } + if (!err) + { + err = ioctl(md, MIXER_READ(responsive_field), &old_mixer_amp); + if (!err) + { + err = ioctl(fd, MIXER_READ(responsive_field), &old_dsp_amp); + if ((!err) && (old_dsp_amp == old_mixer_amp)) + { + if (old_mixer_amp == 0) amp = 50; else amp = 0; /* 0..100 */ + err = ioctl(fd, MIXER_WRITE(responsive_field), &); + if (!err) + { + err = ioctl(md, MIXER_READ(responsive_field), &new_mixer_amp); + if (!err) + { + if (new_mixer_amp == amp) + { + /* found one! */ + audio_dsp[sound_cards] = ndsp; ndsp++; + audio_mixer[sound_cards] = nmix; nmix++; + audio_type[sound_cards] = NORMAL_CARD; + sound_cards++; + } + else ndsp++; + err = ioctl(fd, MIXER_WRITE(responsive_field), &old_dsp_amp); + } + else nmix++; + } + else ndsp++; + } + else ndsp++; + } + else nmix++; + } + else nmix++; + close(fd); + close(md); + } + if (sound_cards == 0) + { + fd = open(DAC_NAME, O_WRONLY | O_NONBLOCK, 0); + if (fd != -1) + { + sound_cards = 1; + audio_dsp[0] = 0; + audio_type[0] = NORMAL_CARD; + audio_mixer[0] = -2; /* hmmm -- need a way to see /dev/dsp as lonely outpost */ + close(fd); + fd = open(MIXER_NAME, O_RDONLY | O_NONBLOCK, 0); + if (fd == -1) + audio_mixer[0] = -3; + else close(fd); + } + } + } + return(MUS_NO_ERROR); +} + +int mus_audio_reinitialize(void) +{ + /* an experiment */ + audio_initialized = false; + return(mus_audio_initialize()); +} + +static int linux_audio_open(const char *pathname, int flags, mode_t mode, int system) +{ + /* sometimes this is simply searching for a device (so failure is not a mus_error) */ + if (audio_fd[system] == -1) + { + audio_fd[system] = open(pathname, flags, mode); + audio_open_ctr[system] = 0; + } + else audio_open_ctr[system]++; + return(audio_fd[system]); +} + +static int linux_audio_open_with_error(const char *pathname, int flags, mode_t mode, int system) +{ + int fd; + fd = linux_audio_open(pathname, flags, mode, system); + if (fd == -1) + MUS_STANDARD_IO_ERROR(MUS_AUDIO_CANT_OPEN, + ((mode == O_RDONLY) ? "open read" : + (mode == O_WRONLY) ? "open write" : "open read/write"), + pathname); + return(fd); +} + +static int find_system(int line) +{ + int i; + for (i = 0; i < sound_cards; i++) + if (line == audio_fd[i]) + return(i); + return(MUS_ERROR); +} + +static int linux_audio_close(int fd) +{ + if (fd != -1) + { + int err = 0, sys; + sys = find_system(fd); + if (sys != -1) + { + if (audio_open_ctr[sys] > 0) + audio_open_ctr[sys]--; + else + { + err = close(fd); + audio_open_ctr[sys] = 0; + audio_fd[sys] = -1; + } + } + else err = close(fd); + if (err) RETURN_ERROR_EXIT(MUS_AUDIO_CANT_CLOSE, -1, + mus_format("close %d failed: %s", + fd, strerror(errno))); + } + /* is this an error? */ + return(MUS_NO_ERROR); +} + +static int to_oss_format(int snd_format) +{ + switch (snd_format) + { + case MUS_BYTE: return(AFMT_S8); break; + case MUS_BSHORT: return(AFMT_S16_BE); break; + case MUS_UBYTE: return(AFMT_U8); break; + case MUS_MULAW: return(AFMT_MU_LAW); break; + case MUS_ALAW: return(AFMT_A_LAW); break; + case MUS_LSHORT: return(AFMT_S16_LE); break; + case MUS_UBSHORT: return(AFMT_U16_BE); break; + case MUS_ULSHORT: return(AFMT_U16_LE); break; +#ifdef NEW_OSS + case MUS_LINT: return(AFMT_S32_LE); break; + case MUS_BINT: return(AFMT_S32_BE); break; +#endif + } + return(MUS_ERROR); +} + +static char sonorus_buf[LABEL_BUFFER_SIZE]; +static char *sonorus_name(int sys, int offset) +{ + mus_snprintf(sonorus_buf, LABEL_BUFFER_SIZE, "/dev/dsp%d", offset + audio_dsp[sys]); + return(sonorus_buf); +} + +static bool fragment_set_failed = false; + +static int oss_mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + /* ur_dev is in general MUS_AUDIO_PACK_SYSTEM(n) | MUS_AUDIO_DEVICE */ + int oss_format, buffer_info, audio_out = -1, sys, dev; + char *dev_name; +#ifndef NEW_OSS + int stereo; +#endif + sys = MUS_AUDIO_SYSTEM(ur_dev); + dev = MUS_AUDIO_DEVICE(ur_dev); + oss_format = to_oss_format(format); + if (oss_format == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d (%s) not available", + format, + mus_data_format_name(format))); + if (audio_type[sys] == SONORUS_STUDIO) + { + /* in this case the output devices are parcelled out to the /dev/dsp locs */ + /* dev/dsp0 is always stereo */ + switch (dev) + { + case MUS_AUDIO_DEFAULT: + if (chans > 2) + audio_out = open(sonorus_name(sys, 1), O_WRONLY, 0); + else audio_out = open(sonorus_name(sys, 0), O_WRONLY, 0); + /* probably should write to both outputs */ + if (audio_out == -1) audio_out = open("/dev/dsp", O_WRONLY, 0); + break; + case MUS_AUDIO_SPEAKERS: + audio_out = open(sonorus_name(sys, 0), O_WRONLY, 0); + if (audio_out == -1) audio_out = open("/dev/dsp", O_WRONLY, 0); + break; + case MUS_AUDIO_ADAT_OUT: case MUS_AUDIO_SPDIF_OUT: + audio_out = open(sonorus_name(sys, 1), O_WRONLY, 0); + break; + case MUS_AUDIO_AES_OUT: + audio_out = open(sonorus_name(sys, 9), O_WRONLY, 0); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, audio_out, + mus_format("Sonorus device %d (%s) not available", + dev, + mus_audio_device_name(dev))); + break; + } + if (audio_out == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, audio_out, + mus_format("can't open Sonorus output device %d (%s): %s", + dev, + mus_audio_device_name(dev), strerror(errno))); +#ifdef NEW_OSS + if (ioctl(audio_out, SNDCTL_DSP_CHANNELS, &chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_out, + mus_format("can't get %d channels for Sonorus device %d (%s)", + chans, dev, + mus_audio_device_name(dev))); +#endif + return(audio_out); + } + +#if HAVE_SAM_9407 + if (audio_type[sys] == SAM9407_DSP) + { + char dname[LABEL_BUFFER_SIZE]; + mus_snprintf(dname, LABEL_BUFFER_SIZE, "/dev/sam%d_dsp", audio_dsp[sys]); + audio_out = open(dname, O_WRONLY); + if(audio_out == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, audio_out, + mus_format("can't open %s: %s", + dname, + strerror(errno))); + if ((ioctl(audio_out, SNDCTL_DSP_SETFMT, &oss_format) == -1) || + (oss_format != to_oss_format(format))) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_out, + mus_format("can't set %s format to %d (%s)", + dname, format, + mus_data_format_name(format))); + if (ioctl(audio_out, SNDCTL_DSP_CHANNELS, &chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_out, + mus_format("can't get %d channels on %s", + chans, dname)); + if (ioctl(audio_out, SNDCTL_DSP_SPEED, &srate) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, audio_out, + mus_format("can't set srate to %d on %s", + srate, dname)); + FRAGMENT_SIZE = 14; + buffer_info = (FRAGMENTS << 16) | (FRAGMENT_SIZE); + ioctl(audio_out, SNDCTL_DSP_SETFRAGMENT, &buffer_info); + return(audio_out); + } +#endif + + if (dev == MUS_AUDIO_DEFAULT) + audio_out = linux_audio_open_with_error(dev_name = dac_name(sys, 0), + O_WRONLY, 0, sys); + else audio_out = linux_audio_open_with_error(dev_name = dac_name(sys, (dev == MUS_AUDIO_AUX_OUTPUT) ? 1 : 0), + O_RDWR, 0, sys); + if (audio_out == -1) return(MUS_ERROR); + + /* ioctl(audio_out, SNDCTL_DSP_RESET, 0); */ /* causes clicks */ + if ((fragments_locked) && + (!(fragment_set_failed)) && + ((dev == MUS_AUDIO_DUPLEX_DEFAULT) || + (size != 0))) /* only set if user has previously called set_oss_buffers */ + { + buffer_info = (FRAGMENTS << 16) | (FRAGMENT_SIZE); + if (ioctl(audio_out, SNDCTL_DSP_SETFRAGMENT, &buffer_info) == -1) + { + /* older Linuces (or OSS's?) refuse to handle the fragment reset if O_RDWR used -- + * someone at OSS forgot to update the version number when this was fixed, so + * I have no way to get around this except to try and retry... + */ + linux_audio_close(audio_out); + audio_out = linux_audio_open_with_error(dev_name = dac_name(sys, (dev == MUS_AUDIO_AUX_OUTPUT) ? 1 : 0), + O_WRONLY, 0, sys); + if (audio_out == -1) return(MUS_ERROR); + buffer_info = (FRAGMENTS << 16) | (FRAGMENT_SIZE); + if (ioctl(audio_out, SNDCTL_DSP_SETFRAGMENT, &buffer_info) == -1) + { + char *tmp; + fprintf(stderr, tmp = mus_format("can't set %s fragments to: %d x %d", + dev_name, FRAGMENTS, FRAGMENT_SIZE)); /* not an error if ALSA OSS-emulation */ + fragment_set_failed = true; + FREE(tmp); + } + } + } + if ((ioctl(audio_out, SNDCTL_DSP_SETFMT, &oss_format) == -1) || + (oss_format != to_oss_format(format))) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_out, + mus_format("data format %d (%s) not available on %s", + format, + mus_data_format_name(format), + dev_name)); +#ifdef NEW_OSS + if (ioctl(audio_out, SNDCTL_DSP_CHANNELS, &chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_out, + mus_format("can't get %d channels on %s", + chans, dev_name)); +#else + if (chans == 2) stereo = 1; else stereo = 0; + if ((ioctl(audio_out, SNDCTL_DSP_STEREO, &stereo) == -1) || + ((chans == 2) && (stereo == 0))) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_out, + mus_format("can't get %d channels on %s", + chans, dev_name)); +#endif + if (ioctl(audio_out, SNDCTL_DSP_SPEED, &srate) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, audio_out, + mus_format("can't set srate of %s to %d", + dev_name, srate)); + /* http://www.4front-tech.com/pguide/audio.html says this order has to be followed */ + return(audio_out); +} + +static int oss_mus_audio_write(int line, char *buf, int bytes) +{ + int err; + if (line < 0) return(-1); + errno = 0; + err = write(line, buf, bytes); + if (err != bytes) + { + if (errno != 0) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("write error: %s", strerror(errno))); + else RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("wrote %d bytes of requested %d", err, bytes)); + } + return(MUS_NO_ERROR); +} + +static int oss_mus_audio_close(int line) +{ + return(linux_audio_close(line)); +} + +static int oss_mus_audio_read(int line, char *buf, int bytes) +{ + int err; + if (line < 0) return(-1); + errno = 0; + err = read(line, buf, bytes); + if (err != bytes) + { + if (errno != 0) + RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("read error: %s", strerror(errno))); + else RETURN_ERROR_EXIT(MUS_AUDIO_READ_ERROR, -1, + mus_format("read %d bytes of requested %d", err, bytes)); + } + return(MUS_NO_ERROR); +} + +static char *oss_unsrc(int srcbit) +{ + if (srcbit == 0) + return(strdup("none")); + else + { + bool need_and = false; + char *buf; + buf = (char *)CALLOC(PRINT_BUFFER_SIZE, sizeof(char)); + if (srcbit & SOUND_MASK_MIC) {need_and = true; strcat(buf, "mic");} + if (srcbit & SOUND_MASK_LINE) {if (need_and) strcat(buf, " and "); need_and = true; strcat(buf, "line in");} + if (srcbit & SOUND_MASK_LINE1) {if (need_and) strcat(buf, " and "); need_and = true; strcat(buf, "line1");} + if (srcbit & SOUND_MASK_LINE2) {if (need_and) strcat(buf, " and "); need_and = true; strcat(buf, "line2");} + if (srcbit & SOUND_MASK_LINE3) {if (need_and) strcat(buf, " and "); need_and = true; strcat(buf, "line3");} + if (srcbit & SOUND_MASK_CD) {if (need_and) strcat(buf, " and "); need_and = true; strcat(buf, "cd");} + return(buf); + } +} + +static int oss_mus_audio_open_input(int ur_dev, int srate, int chans, int format, int requested_size) +{ + /* dev can be MUS_AUDIO_DEFAULT or MUS_AUDIO_DUPLEX_DEFAULT as well as the obvious others */ + int audio_fd = -1, oss_format, buffer_info, sys, dev, srcbit, cursrc, err; + bool adat_mode = false; + char *dev_name; +#ifndef NEW_OSS + int stereo; +#endif + sys = MUS_AUDIO_SYSTEM(ur_dev); + dev = MUS_AUDIO_DEVICE(ur_dev); + oss_format = to_oss_format(format); + if (oss_format == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d (%s) not available", + format, + mus_data_format_name(format))); + if (audio_type[sys] == SONORUS_STUDIO) + { + adat_mode = (audio_mode[sys] == 1); + switch (dev) + { + case MUS_AUDIO_DEFAULT: + if (adat_mode) + audio_fd = open(dev_name = sonorus_name(sys, 11), O_RDONLY, 0); + else audio_fd = open(dev_name = sonorus_name(sys, 5), O_RDONLY, 0); + break; + case MUS_AUDIO_ADAT_IN: + audio_fd = open(dev_name = sonorus_name(sys, 11), O_RDONLY, 0); + break; + case MUS_AUDIO_AES_IN: + audio_fd = open(dev_name = sonorus_name(sys, 20), O_RDONLY, 0); + break; + case MUS_AUDIO_SPDIF_IN: + audio_fd = open(dev_name = sonorus_name(sys, 5), O_RDONLY, 0); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, -1, + mus_format("no %s device on Sonorus?", + mus_audio_device_name(dev))); + break; + } + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_NO_INPUT_AVAILABLE, -1, + mus_format("can't open %s (Sonorus device %s): %s", + dev_name, + mus_audio_device_name(dev), + strerror(errno))); +#ifdef NEW_OSS + if (ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("can't get %d channels on %s (Sonorus device %s)", + chans, dev_name, + mus_audio_device_name(dev))); +#endif + return(audio_fd); + } + +#if HAVE_SAM_9407 + if (audio_type[sys] == SAM9407_DSP) + { + char dname[LABEL_BUFFER_SIZE]; + mus_snprintf(dname, LABEL_BUFFER_SIZE, "/dev/sam%d_dsp", audio_dsp[sys]); + audio_fd = open(dname, O_RDONLY); + if(audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, audio_fd, + mus_format("can't open input %s: %s", + dname, + strerror(errno))); + if ((ioctl(audio_fd, SNDCTL_DSP_SETFMT, &oss_format) == -1) || + (oss_format != to_oss_format(format))) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_fd, + mus_format("can't set %s format to %d (%s)", + dname, format, + mus_data_format_name(format))); + if (ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("can't get %d channels on %s", + chans, dname)); + if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &srate) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, audio_fd, + mus_format("can't set srate to %d on %s", + srate, dname)); + FRAGMENT_SIZE = 14; + buffer_info = (FRAGMENTS << 16) | (FRAGMENT_SIZE); + ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &buffer_info); + return(audio_fd); + } +#endif + + if (((dev == MUS_AUDIO_DEFAULT) || (dev == MUS_AUDIO_DUPLEX_DEFAULT)) && (sys == 0)) + audio_fd = linux_audio_open(dev_name = dac_name(sys, 0), + O_RDWR, 0, sys); + else audio_fd = linux_audio_open(dev_name = dac_name(sys, (dev == MUS_AUDIO_AUX_INPUT) ? 1 : 0), + O_RDONLY, 0, sys); + if (audio_fd == -1) + { + if (dev == MUS_AUDIO_DUPLEX_DEFAULT) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, -1, + mus_format("can't open %s (device %s): %s", + dev_name, mus_audio_device_name(dev), strerror(errno))); + if ((audio_fd = linux_audio_open(dev_name = dac_name(sys, (dev == MUS_AUDIO_AUX_INPUT) ? 1 : 0), + O_RDONLY, 0, sys)) == -1) + { + if ((errno == EACCES) || (errno == ENOENT)) + RETURN_ERROR_EXIT(MUS_AUDIO_NO_READ_PERMISSION, -1, + mus_format("can't open %s (device %s): %s\n to get input in Linux, we need read permission on /dev/dsp", + dev_name, + mus_audio_device_name(dev), + strerror(errno))); + else RETURN_ERROR_EXIT(MUS_AUDIO_NO_INPUT_AVAILABLE, -1, + mus_format("can't open %s (device %s): %s", + dev_name, + mus_audio_device_name(dev), + strerror(errno))); + } + } +#ifdef SNDCTL_DSP_SETDUPLEX + else + ioctl(audio_fd, SNDCTL_DSP_SETDUPLEX, &err); /* not always a no-op! */ +#endif + if (audio_type[sys] == RME_HAMMERFALL) return(audio_fd); + if (audio_type[sys] == DELTA_66) return(audio_fd); + /* need to make sure the desired recording source is active -- does this actually have any effect? */ + switch (dev) + { + case MUS_AUDIO_MICROPHONE: srcbit = SOUND_MASK_MIC; break; + case MUS_AUDIO_LINE_IN: srcbit = SOUND_MASK_LINE; break; + case MUS_AUDIO_LINE1: srcbit = SOUND_MASK_LINE1; break; + case MUS_AUDIO_LINE2: srcbit = SOUND_MASK_LINE2; break; + case MUS_AUDIO_LINE3: srcbit = SOUND_MASK_LINE3; break; /* also digital1..3 */ + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_DEFAULT: srcbit = SOUND_MASK_LINE | SOUND_MASK_MIC; break; + case MUS_AUDIO_CD: srcbit = SOUND_MASK_CD; break; + default: srcbit = 0; break; + /* other possibilities: synth, radio, phonein but these apparently bypass the mixer (no gains?) */ + } + ioctl(audio_fd, MIXER_READ(SOUND_MIXER_RECSRC), &cursrc); + srcbit = (srcbit | cursrc); + ioctl(audio_fd, MIXER_WRITE(SOUND_MIXER_RECSRC), &srcbit); + ioctl(audio_fd, MIXER_READ(SOUND_MIXER_RECSRC), &cursrc); + if (cursrc != srcbit) + { + char *str1, *str2; + str1 = oss_unsrc(srcbit); + str2 = oss_unsrc(cursrc); + mus_print("weird: tried to set recorder source to %s, but got %s?", str1, str2); + FREE(str1); + FREE(str2); + } + if ((fragments_locked) && (requested_size != 0)) + { + buffer_info = (FRAGMENTS << 16) | (FRAGMENT_SIZE); + ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &buffer_info); + } + if ((ioctl(audio_fd, SNDCTL_DSP_SETFMT, &oss_format) == -1) || + (oss_format != to_oss_format(format))) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_fd, + mus_format("can't set %s format to %d (%s)", + dev_name, format, + mus_data_format_name(format))); +#ifdef NEW_OSS + if (ioctl(audio_fd, SNDCTL_DSP_CHANNELS, &chans) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("can't get %d channels on %s", + chans, dev_name)); +#else + if (chans == 2) stereo = 1; else stereo = 0; + if ((ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo) == -1) || + ((chans == 2) && (stereo == 0))) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("can't get %d channels on %s (%s)", + chans, dev_name, + mus_audio_device_name(dev))); +#endif + if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &srate) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, audio_fd, + mus_format("can't set srate to %d on %s (%s)", + srate, dev_name, + mus_audio_device_name(dev))); + return(audio_fd); +} + + +static int oss_mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + int fd, amp, channels, err = MUS_NO_ERROR, devmask, stereodevs, ind, formats, sys, dev, srate; + char *dev_name = NULL; + sys = MUS_AUDIO_SYSTEM(ur_dev); + dev = MUS_AUDIO_DEVICE(ur_dev); + if (audio_type[sys] == SONORUS_STUDIO) + { + bool adat_mode = false; + adat_mode = (audio_mode[sys] == 1); + if (dev == MUS_AUDIO_MIXER) val[0] = 0; /* no mixer */ + else + { + if (field == MUS_AUDIO_PORT) + { + if (adat_mode) + { + val[0] = 5; + val[1] = MUS_AUDIO_ADAT_IN; + val[2] = MUS_AUDIO_ADAT_OUT; + val[3] = MUS_AUDIO_SPEAKERS; + val[4] = MUS_AUDIO_AES_IN; + val[5] = MUS_AUDIO_AES_OUT; + } + else + { + val[0] = 3; + val[1] = MUS_AUDIO_SPDIF_IN; + val[2] = MUS_AUDIO_SPDIF_OUT; + val[3] = MUS_AUDIO_SPEAKERS; + } + } + else + { + if (field == MUS_AUDIO_FORMAT) + { + val[0] = 1; + val[1] = MUS_LSHORT; + } + else + { + if (field == MUS_AUDIO_CHANNEL) + { + switch (dev) + { + case MUS_AUDIO_SPEAKERS: + channels = 2; + break; + case MUS_AUDIO_ADAT_IN: case MUS_AUDIO_ADAT_OUT: + channels = 8; + break; + case MUS_AUDIO_AES_IN: case MUS_AUDIO_AES_OUT: + channels = 2; + break; + case MUS_AUDIO_SPDIF_IN: case MUS_AUDIO_SPDIF_OUT: + channels = 4; + break; + case MUS_AUDIO_DEFAULT: + if (adat_mode) + channels = 8; + else channels = 4; + break; + default: + channels = 0; + break; + } + val[0] = channels; + } + else + { + if (field == MUS_AUDIO_SRATE) + { + val[0] = 44100; + } + } + } + } + } + return(MUS_NO_ERROR); + } + +#if HAVE_SAM_9407 + if (audio_type[sys] == SAM9407_DSP) + { + switch(field) + { + case MUS_AUDIO_PORT: + val[0] = 2; + val[1] = MUS_AUDIO_SPEAKERS; + val[2] = MUS_AUDIO_LINE_IN; + break; + case MUS_AUDIO_FORMAT: + val[0] = 1; + val[1] = MUS_LSHORT; + break; + case MUS_AUDIO_CHANNEL: + val[0] = 2; + break; + case MUS_AUDIO_AMP: + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, -1, + mus_format("can't read %s's gains in Sam9407", + mus_audio_device_name(dev))); + break; + case MUS_AUDIO_SRATE: + val[0] = 44100; + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, + mus_format("can't read %s's %s in Sam9407", + mus_audio_device_name(dev), + mus_audio_device_name(field))); + break; + } + return(MUS_NO_ERROR); + } +#endif + + if (audio_type[sys] == RME_HAMMERFALL) + { + if (dev == MUS_AUDIO_MIXER) val[0] = 0; /* no mixer */ + else + { + if (field == MUS_AUDIO_PORT) + { + val[0] = 5; + val[1] = MUS_AUDIO_ADAT_IN; + val[2] = MUS_AUDIO_ADAT_OUT; + val[3] = MUS_AUDIO_SPEAKERS; + val[4] = MUS_AUDIO_AES_IN; + val[5] = MUS_AUDIO_AES_OUT; + } + else + { + if (field == MUS_AUDIO_FORMAT) + { + val[0] = 1; + val[1] = MUS_LSHORT; + } + else + { + if (field == MUS_AUDIO_CHANNEL) + { + switch (dev) + { + case MUS_AUDIO_SPEAKERS: + channels = 2; + break; + case MUS_AUDIO_ADAT_IN: case MUS_AUDIO_ADAT_OUT: + channels = 8; + break; + case MUS_AUDIO_AES_IN: case MUS_AUDIO_AES_OUT: + channels = 2; + break; + case MUS_AUDIO_SPDIF_IN: case MUS_AUDIO_SPDIF_OUT: + channels = 4; + break; + case MUS_AUDIO_DEFAULT: + channels = 8; + break; + default: + channels = 0; + break; + } + val[0] = channels; + } + else + { + if (field == MUS_AUDIO_SRATE) + { + val[0] = 44100; + } + } + } + } + } + return(MUS_NO_ERROR); + } + + fd = linux_audio_open(dev_name = mixer_name(sys), O_RDONLY | O_NONBLOCK, 0, sys); + if (fd == -1) + { + fd = linux_audio_open(DAC_NAME, O_RDONLY, 0, sys); + if (fd == -1) + { + fd = linux_audio_open(DAC_NAME, O_WRONLY, 0, sys); + if (fd == -1) + { + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, -1, + mus_format("can't open input %s or %s: %s", + dev_name, DAC_NAME, + strerror(errno))); + return(MUS_ERROR); + } + else dev_name = DAC_NAME; + } + else dev_name = DAC_NAME; + } + if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask)) + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, fd, + mus_format("can't read device info from %s", + dev_name)); + err = 0; + if ((dev == MUS_AUDIO_MIXER) || + (dev == MUS_AUDIO_DAC_FILTER)) /* these give access to all the on-board analog input gain controls */ + { + amp = 0; + ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask); + switch (field) + { + /* also DIGITAL1..3 PHONEIN PHONEOUT VIDEO RADIO MONITOR */ + /* the digital lines should get their own panes in the recorder */ + /* not clear whether the phone et al lines are routed to the ADC */ + /* also, I've never seen a card with any of these devices */ + case MUS_AUDIO_IMIX: if (SOUND_MASK_IMIX & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_IMIX), &); break; + case MUS_AUDIO_IGAIN: if (SOUND_MASK_IGAIN & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_IGAIN), &); break; + case MUS_AUDIO_RECLEV: if (SOUND_MASK_RECLEV & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_RECLEV), &); break; + case MUS_AUDIO_PCM: if (SOUND_MASK_PCM & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_PCM), &); break; + case MUS_AUDIO_PCM2: if (SOUND_MASK_ALTPCM & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_ALTPCM), &); break; + case MUS_AUDIO_OGAIN: if (SOUND_MASK_OGAIN & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_OGAIN), &); break; + case MUS_AUDIO_LINE: if (SOUND_MASK_LINE & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE), &); break; + case MUS_AUDIO_MICROPHONE: if (SOUND_MASK_MIC & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_MIC), &); break; + case MUS_AUDIO_LINE1: if (SOUND_MASK_LINE1 & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE1), &); break; + case MUS_AUDIO_LINE2: if (SOUND_MASK_LINE2 & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE2), &); break; + case MUS_AUDIO_LINE3: if (SOUND_MASK_LINE3 & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE3), &); break; + case MUS_AUDIO_SYNTH: if (SOUND_MASK_SYNTH & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_SYNTH), &); break; + case MUS_AUDIO_BASS: if (SOUND_MASK_BASS & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_BASS), &); break; + case MUS_AUDIO_TREBLE: if (SOUND_MASK_TREBLE & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_TREBLE), &); break; + case MUS_AUDIO_CD: if (SOUND_MASK_CD & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_CD), &); break; + case MUS_AUDIO_CHANNEL: + if (dev == MUS_AUDIO_MIXER) + { + channels = 0; + ioctl(fd, SOUND_MIXER_READ_STEREODEVS, &stereodevs); + if (SOUND_MASK_IMIX & devmask) {if (SOUND_MASK_IMIX & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_IGAIN & devmask) {if (SOUND_MASK_IGAIN & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_RECLEV & devmask) {if (SOUND_MASK_RECLEV & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_PCM & devmask) {if (SOUND_MASK_PCM & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_ALTPCM & devmask) {if (SOUND_MASK_ALTPCM & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_OGAIN & devmask) {if (SOUND_MASK_OGAIN & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_LINE & devmask) {if (SOUND_MASK_LINE & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_MIC & devmask) {if (SOUND_MASK_MIC & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_LINE1 & devmask) {if (SOUND_MASK_LINE1 & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_LINE2 & devmask) {if (SOUND_MASK_LINE2 & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_LINE3 & devmask) {if (SOUND_MASK_LINE3 & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_SYNTH & devmask) {if (SOUND_MASK_SYNTH & stereodevs) channels += 2; else channels += 1;} + if (SOUND_MASK_CD & devmask) {if (SOUND_MASK_CD & stereodevs) channels += 2; else channels += 1;} + } + else + if (SOUND_MASK_TREBLE & devmask) channels = 2; else channels = 0; + val[0] = channels; + linux_audio_close(fd); + return(MUS_NO_ERROR); + break; + case MUS_AUDIO_FORMAT: /* this is asking for configuration info -- we return an array with per-"device" channels */ + ioctl(fd, SOUND_MIXER_READ_STEREODEVS, &stereodevs); + for (ind = 0; ind <= MUS_AUDIO_SYNTH; ind++) {if (chan > ind) val[ind] = 0;} + if (SOUND_MASK_IMIX & devmask) {if (chan > MUS_AUDIO_IMIX) val[MUS_AUDIO_IMIX] = ((SOUND_MASK_IMIX & stereodevs) ? 2 : 1);} + if (SOUND_MASK_IGAIN & devmask) {if (chan > MUS_AUDIO_IGAIN) val[MUS_AUDIO_IGAIN] = ((SOUND_MASK_IGAIN & stereodevs) ? 2 : 1);} + if (SOUND_MASK_RECLEV & devmask) {if (chan > MUS_AUDIO_RECLEV) val[MUS_AUDIO_RECLEV] = ((SOUND_MASK_RECLEV & stereodevs) ? 2 : 1);} + if (SOUND_MASK_PCM & devmask) {if (chan > MUS_AUDIO_PCM) val[MUS_AUDIO_PCM] = ((SOUND_MASK_PCM & stereodevs) ? 2 : 1);} + if (SOUND_MASK_ALTPCM & devmask) {if (chan > MUS_AUDIO_PCM2) val[MUS_AUDIO_PCM2] = ((SOUND_MASK_ALTPCM & stereodevs) ? 2 : 1);} + if (SOUND_MASK_OGAIN & devmask) {if (chan > MUS_AUDIO_OGAIN) val[MUS_AUDIO_OGAIN] = ((SOUND_MASK_OGAIN & stereodevs) ? 2 : 1);} + if (SOUND_MASK_LINE & devmask) {if (chan > MUS_AUDIO_LINE) val[MUS_AUDIO_LINE] = ((SOUND_MASK_LINE & stereodevs) ? 2 : 1);} + if (SOUND_MASK_MIC & devmask) {if (chan > MUS_AUDIO_MICROPHONE) val[MUS_AUDIO_MICROPHONE] = ((SOUND_MASK_MIC & stereodevs) ? 2 : 1);} + if (SOUND_MASK_LINE1 & devmask) {if (chan > MUS_AUDIO_LINE1) val[MUS_AUDIO_LINE1] = ((SOUND_MASK_LINE1 & stereodevs) ? 2 : 1);} + if (SOUND_MASK_LINE2 & devmask) {if (chan > MUS_AUDIO_LINE2) val[MUS_AUDIO_LINE2] = ((SOUND_MASK_LINE2 & stereodevs) ? 2 : 1);} + if (SOUND_MASK_LINE3 & devmask) {if (chan > MUS_AUDIO_LINE3) val[MUS_AUDIO_LINE3] = ((SOUND_MASK_LINE3 & stereodevs) ? 2 : 1);} + if (SOUND_MASK_SYNTH & devmask) {if (chan > MUS_AUDIO_SYNTH) val[MUS_AUDIO_SYNTH] = ((SOUND_MASK_SYNTH & stereodevs) ? 2 : 1);} + if (SOUND_MASK_CD & devmask) {if (chan > MUS_AUDIO_CD) val[MUS_AUDIO_CD] = ((SOUND_MASK_CD & stereodevs) ? 2 : 1);} + linux_audio_close(fd); + return(MUS_NO_ERROR); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, fd, + mus_format("can't read %s's (%s) %s", + mus_audio_device_name(dev), dev_name, + mus_audio_device_name(field))); + break; + } + if (chan == 0) + val[0] = ((float)(amp & 0xff)) * 0.01; + else val[0] = (((float)((amp & 0xff00) >> 8)) * 0.01); + } + else + { + switch (field) + { + case MUS_AUDIO_PORT: + ind = 1; + val[1] = MUS_AUDIO_MIXER; + if ((SOUND_MASK_MIC | SOUND_MASK_LINE | SOUND_MASK_CD) & devmask) {ind++; if (chan > ind) val[ind] = MUS_AUDIO_LINE_IN;} + /* problem here is that microphone and line_in are mixed before the ADC */ + if (SOUND_MASK_SPEAKER & devmask) {ind++; if (chan > ind) val[ind] = MUS_AUDIO_SPEAKERS;} + if (SOUND_MASK_VOLUME & devmask) {ind++; if (chan > ind) val[ind] = MUS_AUDIO_DAC_OUT;} + if (SOUND_MASK_TREBLE & devmask) {ind++; if (chan > ind) val[ind] = MUS_AUDIO_DAC_FILTER;} + /* DIGITAL1..3 as RECSRC(?) => MUS_AUDIO_DIGITAL_IN */ + val[0] = ind; + break; +#if 1 + case MUS_AUDIO_FORMAT: + linux_audio_close(fd); + fd = open(dac_name(sys, 0), O_WRONLY, 0); + if (fd == -1) fd = open(DAC_NAME, O_WRONLY, 0); + if (fd == -1) + { + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, -1, + mus_format("can't open %s: %s", + DAC_NAME, strerror(errno))); + return(MUS_ERROR); + } + ioctl(fd, SOUND_PCM_GETFMTS, &formats); +#else + case MUS_AUDIO_FORMAT: + ioctl(fd, SOUND_PCM_GETFMTS, &formats); + /* this returns -1 and garbage?? */ + + /* from Steven Schultz: + I did discover why, in audio.c the SOUND_PCM_GETFMTS ioctl was failing. + That ioctl call can only be made against the /dev/dsp device and _not_ + the /dev/mixer device. With that change things starting working real + nice. + */ +#endif + ind = 0; + if (formats & (to_oss_format(MUS_BYTE))) {ind++; if (chan > ind) val[ind] = MUS_BYTE;} + if (formats & (to_oss_format(MUS_BSHORT))) {ind++; if (chan > ind) val[ind] = MUS_BSHORT;} + if (formats & (to_oss_format(MUS_UBYTE))) {ind++; if (chan > ind) val[ind] = MUS_UBYTE;} + if (formats & (to_oss_format(MUS_MULAW))) {ind++; if (chan > ind) val[ind] = MUS_MULAW;} + if (formats & (to_oss_format(MUS_ALAW))) {ind++; if (chan > ind) val[ind] = MUS_ALAW;} + if (formats & (to_oss_format(MUS_LSHORT))) {ind++; if (chan > ind) val[ind] = MUS_LSHORT;} + if (formats & (to_oss_format(MUS_UBSHORT))) {ind++; if (chan > ind) val[ind] = MUS_UBSHORT;} + if (formats & (to_oss_format(MUS_ULSHORT))) {ind++; if (chan > ind) val[ind] = MUS_ULSHORT;} + val[0] = ind; + break; + case MUS_AUDIO_CHANNEL: + channels = 0; + ioctl(fd, SOUND_MIXER_READ_STEREODEVS, &stereodevs); + switch (dev) + { + case MUS_AUDIO_MICROPHONE: if (SOUND_MASK_MIC & devmask) {if (SOUND_MASK_MIC & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_SPEAKERS: if (SOUND_MASK_SPEAKER & devmask) {if (SOUND_MASK_SPEAKER & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_LINE_IN: if (SOUND_MASK_LINE & devmask) {if (SOUND_MASK_LINE & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_LINE1: if (SOUND_MASK_LINE1 & devmask) {if (SOUND_MASK_LINE1 & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_LINE2: if (SOUND_MASK_LINE2 & devmask) {if (SOUND_MASK_LINE2 & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_LINE3: if (SOUND_MASK_LINE3 & devmask) {if (SOUND_MASK_LINE3 & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_DAC_OUT: if (SOUND_MASK_VOLUME & devmask) {if (SOUND_MASK_VOLUME & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_DEFAULT: if (SOUND_MASK_VOLUME & devmask) {if (SOUND_MASK_VOLUME & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_CD: if (SOUND_MASK_CD & devmask) {if (SOUND_MASK_CD & stereodevs) channels = 2; else channels = 1;} break; + case MUS_AUDIO_DUPLEX_DEFAULT: + err = ioctl(fd, SNDCTL_DSP_GETCAPS, &ind); + if (err != -1) + channels = (ind & DSP_CAP_DUPLEX); + else channels = 0; + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, fd, + mus_format("can't read channel info from %s (%s)", + mus_audio_device_name(dev), dev_name)); + break; + } + val[0] = channels; + break; + case MUS_AUDIO_AMP: + amp = 0; + switch (dev) + { + case MUS_AUDIO_MICROPHONE: if (SOUND_MASK_MIC & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_MIC), &); break; + case MUS_AUDIO_SPEAKERS: if (SOUND_MASK_SPEAKER & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_SPEAKER), &); break; + case MUS_AUDIO_LINE_IN: if (SOUND_MASK_LINE & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE), &); break; + case MUS_AUDIO_LINE1: if (SOUND_MASK_LINE1 & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE1), &); break; + case MUS_AUDIO_LINE2: if (SOUND_MASK_LINE2 & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE2), &); break; + case MUS_AUDIO_LINE3: if (SOUND_MASK_LINE3 & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_LINE3), &); break; + case MUS_AUDIO_DAC_OUT: if (SOUND_MASK_VOLUME & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_VOLUME), &); break; + case MUS_AUDIO_DEFAULT: if (SOUND_MASK_VOLUME & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_VOLUME), &); break; + case MUS_AUDIO_CD: if (SOUND_MASK_CD & devmask) err = ioctl(fd, MIXER_READ(SOUND_MIXER_CD), &); break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, fd, + mus_format("can't get gain info for %s (%s)", + mus_audio_device_name(dev), dev_name)); + break; + } + if (err) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, fd, + mus_format("can't read %s's (%s) amp info", + mus_audio_device_name(dev), dev_name)); + if (chan == 0) + val[0] = ((float)(amp & 0xff)) * 0.01; + else val[0] = (((float)((amp & 0xff00) >> 8)) * 0.01); + break; + case MUS_AUDIO_SRATE: + srate = (int)(val[0]); + if (ioctl(fd, SNDCTL_DSP_SPEED, &srate) == -1) + { + linux_audio_close(fd); + /* see comment from Steven Schultz above */ + fd = open(dac_name(sys, 0), O_WRONLY, 0); + if (fd == -1) fd = open(DAC_NAME, O_WRONLY, 0); + if (ioctl(fd, SNDCTL_DSP_SPEED, &srate) == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, fd, + mus_format("can't get %s's (%s) srate", + mus_audio_device_name(dev), dev_name)); + } + val[0] = (float)srate; + break; + case MUS_AUDIO_DIRECTION: + switch (dev) + { + case MUS_AUDIO_DIGITAL_OUT: case MUS_AUDIO_LINE_OUT: case MUS_AUDIO_DEFAULT: case MUS_AUDIO_ADAT_OUT: + case MUS_AUDIO_AES_OUT: case MUS_AUDIO_SPDIF_OUT: case MUS_AUDIO_SPEAKERS: case MUS_AUDIO_MIXER: + case MUS_AUDIO_DAC_FILTER: case MUS_AUDIO_AUX_OUTPUT: case MUS_AUDIO_DAC_OUT: + val[0] = 0.0; + break; + default: + val[0] = 1.0; + break; + } + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, fd, + mus_format("can't get %s's (%s) %s", + mus_audio_device_name(dev), dev_name, + mus_audio_device_name(field))); + break; + } + } + return(linux_audio_close(fd)); +} + +static int oss_mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + int fd, err = MUS_NO_ERROR, devmask, vol, sys, dev; + char *dev_name; + float amp[1]; + sys = MUS_AUDIO_SYSTEM(ur_dev); + dev = MUS_AUDIO_DEVICE(ur_dev); + +#if HAVE_SAM_9407 + if (audio_type[sys] == SAM9407_DSP) return(MUS_NO_ERROR); /* XXX */ +#endif + + if (audio_type[sys] == SONORUS_STUDIO) return(MUS_NO_ERROR); /* there are apparently volume controls, but they're not accessible yet */ + if (audio_type[sys] == RME_HAMMERFALL) return(MUS_NO_ERROR); + if (audio_type[sys] == DELTA_66) return(MUS_NO_ERROR); + + fd = linux_audio_open(dev_name = mixer_name(sys), O_RDWR | O_NONBLOCK, 0, sys); + if (fd == -1) + { + fd = linux_audio_open_with_error(dev_name = DAC_NAME, O_WRONLY, 0, sys); + if (fd == -1) return(MUS_ERROR); + } + if ((dev == MUS_AUDIO_MIXER) || + (dev == MUS_AUDIO_DAC_FILTER)) /* these give access to all the on-board analog input gain controls */ + { + if (mus_audio_mixer_read(ur_dev, field, (chan == 0) ? 1 : 0, amp)) + { + linux_audio_close(fd); + return(MUS_ERROR); + } + if (val[0] >= 0.99) val[0] = 0.99; + if (val[0] < 0.0) val[0] = 0.0; + if (amp[0] >= 0.99) amp[0] = 0.99; + if (chan == 0) + vol = (((int)(amp[0] * 100)) << 8) + ((int)(val[0] * 100)); + else vol = (((int)(val[0] * 100)) << 8) + ((int)(amp[0] * 100)); + ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask); + switch (field) + { + case MUS_AUDIO_IMIX: if (SOUND_MASK_IMIX & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_IMIX), &vol); break; + case MUS_AUDIO_IGAIN: if (SOUND_MASK_IGAIN & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_IGAIN), &vol); break; + case MUS_AUDIO_RECLEV: if (SOUND_MASK_RECLEV & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_RECLEV), &vol); break; + case MUS_AUDIO_PCM: if (SOUND_MASK_PCM & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_PCM), &vol); break; + case MUS_AUDIO_PCM2: if (SOUND_MASK_ALTPCM & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_ALTPCM), &vol); break; + case MUS_AUDIO_OGAIN: if (SOUND_MASK_OGAIN & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_OGAIN), &vol); break; + case MUS_AUDIO_LINE: if (SOUND_MASK_LINE & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE), &vol); break; + case MUS_AUDIO_MICROPHONE: if (SOUND_MASK_MIC & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_MIC), &vol); break; + case MUS_AUDIO_LINE1: if (SOUND_MASK_LINE1 & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE1), &vol); break; + case MUS_AUDIO_LINE2: if (SOUND_MASK_LINE2 & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE2), &vol); break; + case MUS_AUDIO_LINE3: if (SOUND_MASK_LINE3 & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE3), &vol); break; + case MUS_AUDIO_SYNTH: if (SOUND_MASK_SYNTH & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_SYNTH), &vol); break; + case MUS_AUDIO_BASS: if (SOUND_MASK_BASS & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_BASS), &vol); break; + case MUS_AUDIO_TREBLE: if (SOUND_MASK_TREBLE & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_TREBLE), &vol); break; + case MUS_AUDIO_CD: if (SOUND_MASK_CD & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_CD), &vol); break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, fd, + mus_format("can't write %s's (%s) %s field", + mus_audio_device_name(dev), dev_name, + mus_audio_device_name(field))); + break; + } + } + else + { + switch (field) + { + case MUS_AUDIO_AMP: + /* need to read both channel amps, then change the one we're concerned with */ + mus_audio_mixer_read(ur_dev, field, (chan == 0) ? 1 : 0, amp); + if (val[0] >= 0.99) val[0] = 0.99; + if (val[0] < 0.0) val[0] = 0.0; + if (amp[0] >= 0.99) amp[0] = 0.99; + if (chan == 0) + vol = (((int)(amp[0] * 100)) << 8) + ((int)(val[0] * 100)); + else vol = (((int)(val[0] * 100)) << 8) + ((int)(amp[0] * 100)); + ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask); + switch (dev) + { + case MUS_AUDIO_MICROPHONE: if (SOUND_MASK_MIC & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_MIC), &vol); break; + case MUS_AUDIO_SPEAKERS: if (SOUND_MASK_SPEAKER & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_SPEAKER), &vol); break; + case MUS_AUDIO_LINE_IN: if (SOUND_MASK_LINE & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE), &vol); break; + case MUS_AUDIO_LINE1: if (SOUND_MASK_LINE1 & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE1), &vol); break; + case MUS_AUDIO_LINE2: if (SOUND_MASK_LINE2 & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE2), &vol); break; + case MUS_AUDIO_LINE3: if (SOUND_MASK_LINE3 & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_LINE3), &vol); break; + case MUS_AUDIO_DAC_OUT: if (SOUND_MASK_VOLUME & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_VOLUME), &vol); break; + case MUS_AUDIO_DEFAULT: if (SOUND_MASK_VOLUME & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_VOLUME), &vol); break; + case MUS_AUDIO_CD: if (SOUND_MASK_CD & devmask) err = ioctl(fd, MIXER_WRITE(SOUND_MIXER_CD), &vol); break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, fd, + mus_format("device %d (%s) not available on %s", + dev, mus_audio_device_name(dev), dev_name)); + } + break; + case MUS_AUDIO_SRATE: + vol = (int)val[0]; + linux_audio_close(fd); + /* see comment from Steven Schultz above */ + fd = open(dac_name(sys, 0), O_WRONLY | O_NONBLOCK, 0); + if (fd == -1) + { + fd = open(DAC_NAME, O_WRONLY | O_NONBLOCK, 0); + if (fd == -1) return(-1); + } + err = ioctl(fd, SNDCTL_DSP_SPEED, &vol); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, fd, + mus_format("can't write %s's (%s) %s field", + mus_audio_device_name(dev), dev_name, + mus_audio_device_name(field))); + break; + /* case MUS_AUDIO_FORMAT: to force 16-bit input or give up */ + /* case MUS_AUDIO_CHANNEL: to open as stereo if possible?? */ + /* case MUS_AUDIO_PORT: to open digital out? */ + } + } + if (err) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, fd, + mus_format("possible write problem for %s's (%s) %s field", + mus_audio_device_name(dev), dev_name, + mus_audio_device_name(field))); + return(linux_audio_close(fd)); +} + +static char *synth_names[] = + {"", + "Adlib", "SoundBlaster", "ProAudio Spectrum", "Gravis UltraSound", "MPU 401", + "SoundBlaster 16", "SoundBlaster 16 MIDI", "6850 UART", "Gravis UltraSound 16", "Microsoft", + "Personal sound system", "Ensoniq Soundscape", "Personal sound system + MPU", "Personal/Microsoft", + "Mediatrix Pro", "MAD16", "MAD16 + MPU", "CS4232", "CS4232 + MPU", "Maui", + "Pseudo-MSS", "Gravis Ultrasound PnP", "UART 401"}; + +static char *synth_name(int i) +{ +#ifdef SNDCARD_UART401 + if ((i > 0) && (i <= SNDCARD_UART401)) +#else + if ((i > 0) && (i <= 26)) +#endif + return(synth_names[i]); + return("unknown"); +} + +static char *device_types[] = {"FM", "Sampling", "MIDI"}; + +static char *device_type(int i) +{ + if ((i >= 0) && (i <= 2)) + return(device_types[i]); + return("unknown"); +} + +static void yes_no(int condition) +{ + if (condition) + pprint(" yes "); + else pprint(" no "); +} + +static int set_dsp(int fd, int channels, int bits, int *rate) +{ + int val; + val = channels; + ioctl(fd, SOUND_PCM_WRITE_CHANNELS, &val); + if (val != channels) return(MUS_ERROR); + val = bits; + ioctl(fd, SOUND_PCM_WRITE_BITS, &val); + if (val != bits) return(MUS_ERROR); + ioctl(fd, SOUND_PCM_WRITE_RATE, rate); + return(MUS_NO_ERROR); +} + +static void oss_describe_audio_state_1(void) +{ + /* this code taken largely from "Linux Multimedia Guide" by Jeff Tranter, O'Reilly & Associates, Inc 1996 */ + /* it is explicitly released under the GPL, so I think I can use it here without elaborate disguises */ + int fd; + int status = 0, level, i, recsrc, devmask, recmask, stereodevs, caps; + int numdevs = 0, rate = 0, channels = 0, bits = 0, blocksize = 0, formats = 0, deffmt = 0, min_rate = 0, max_rate = 0; + struct synth_info sinfo; + struct midi_info minfo; + const char *sound_device_names[] = SOUND_DEVICE_LABELS; + char dsp_name[LABEL_BUFFER_SIZE]; + char version[LABEL_BUFFER_SIZE]; + int dsp_num = 0; +#ifdef NEW_OSS + mixer_info mixinfo; + oss_sysinfo sysinfo; +#endif + + if (sound_cards <= 0) mus_audio_initialize(); + memset((void *)dsp_name, 0, LABEL_BUFFER_SIZE); + memset((void *)version, 0, LABEL_BUFFER_SIZE); + +#ifdef NEW_OSS + fd = open(DAC_NAME, O_WRONLY, 0); + if (fd == -1) fd = open(SYNTH_NAME, O_RDONLY, 0); + if (fd == -1) fd = open(MIXER_NAME, O_RDONLY, 0); + if (fd != -1) + { + status = ioctl(fd, OSS_GETVERSION, &level); + new_oss_running = (status == 0); + status = ioctl(fd, OSS_SYSINFO, &sysinfo); + close(fd); + } +#endif + + if (new_oss_running) + { +#ifdef NEW_OSS + if (status == 0) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "OSS version: %s\n", sysinfo.version); + pprint(audio_strbuf); + } + else + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "OSS version: %x.%x.%x\n", (level >> 16) & 0xff, (level >> 8) & 0xff, level & 0xff); + pprint(audio_strbuf); + } +#else + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "OSS version: %x.%x.%x\n", (level >> 16) & 0xff, (level >> 8) & 0xff, level & 0xff); + pprint(audio_strbuf); +#endif + } + else + { + /* refers to the version upon compilation */ + mus_snprintf(version, LABEL_BUFFER_SIZE, "%d", SOUND_VERSION); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "OSS version: %c.%c.%c\n", version[0], version[1], version[2]); + pprint(audio_strbuf); + } + + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%d card%s found", sound_cards, (sound_cards != 1) ? "s" : ""); pprint(audio_strbuf); + if (sound_cards > 1) + { + pprint(": "); + for (i = 0; i < sound_cards; i++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "/dev/dsp%d with /dev/mixer%d%s", + audio_dsp[i], + audio_mixer[i], + (i < (sound_cards - 1)) ? ", " : ""); + pprint(audio_strbuf); + } + } + pprint("\n\n"); + + fd = open(SYNTH_NAME, O_RDWR, 0); + if (fd == -1) fd = open(SYNTH_NAME, O_RDONLY, 0); + if (fd == -1) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s: %s\n", SYNTH_NAME, strerror(errno)); pprint(audio_strbuf); + pprint("no synth found\n"); + } + else + { + status = ioctl(fd, SNDCTL_SEQ_NRSYNTHS, &numdevs); + if (status == -1) + { + close(fd); fd = -1; + pprint("no sequencer?"); + } + else + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "/dev/sequencer: %d device%s installed\n", numdevs, (numdevs == 1) ? "" : "s"); + pprint(audio_strbuf); + for (i = 0; i < numdevs; i++) + { + sinfo.device = i; + status = ioctl(fd, SNDCTL_SYNTH_INFO, &sinfo); + if (status != -1) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " device: %d: %s, %s, %d voices\n", i, sinfo.name, device_type(sinfo.synth_type), sinfo.nr_voices); + pprint(audio_strbuf); + } + } + status = ioctl(fd, SNDCTL_SEQ_NRMIDIS, &numdevs); + if (status == -1) + { + close(fd); fd = -1; + pprint("no midi"); + } + else + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %d midi device%s installed\n", numdevs, (numdevs == 1) ? "" : "s"); + pprint(audio_strbuf); + for (i = 0; i < numdevs; i++) + { + minfo.device = i; + status = ioctl(fd, SNDCTL_MIDI_INFO, &minfo); + if (status != -1) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " device %d: %s, %s\n", i, minfo.name, synth_name(minfo.dev_type)); + pprint(audio_strbuf); + } + } + } + } + } + if (fd != -1) close(fd); + pprint("--------------------------------\n"); + +MIXER_INFO: + mus_snprintf(dsp_name, LABEL_BUFFER_SIZE, "%s%d", MIXER_NAME, dsp_num); + fd = linux_audio_open(dsp_name, O_RDWR, 0, 0); + if (fd == -1) + { + /* maybe output only */ + fd = linux_audio_open(dsp_name, O_WRONLY, 0, 0); + if (fd == -1) + { + if (dsp_num == 0) + { + mus_snprintf(dsp_name, LABEL_BUFFER_SIZE, "%s", DAC_NAME); + fd = linux_audio_open(DAC_NAME, O_RDWR, 0, 0); + if (fd == -1) + { + /* maybe output only */ + fd = linux_audio_open(DAC_NAME, O_WRONLY, 0, 0); + if (fd == -1) + { + pprint("no audio device found\n"); + return; + } + } + } + else goto AUDIO_INFO; /* no /dev/mixern */ + } + else pprint("no audio input enabled\n"); + } + if (fd == -1) goto AUDIO_INFO; + +#ifdef NEW_OSS + if (new_oss_running) status = ioctl(fd, SOUND_MIXER_INFO, &mixinfo); +#endif + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s", dsp_name); + pprint(audio_strbuf); +#ifdef NEW_OSS + if ((new_oss_running) && (status == 0)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " (%s", mixinfo.name); + pprint(audio_strbuf); + for (i = 0; i < sound_cards; i++) + { + if ((audio_mixer[i] == dsp_num) && (audio_type[i] == SONORUS_STUDIO)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " in mode %d", audio_mode[i]); + pprint(audio_strbuf); + break; + } + } + pprint(")"); + } +#endif + status = ioctl(fd, SOUND_MIXER_READ_RECSRC, &recsrc); + if (status == -1) + { + linux_audio_close(fd); + fd = -1; + pprint(" no recsrc\n"); + } + else + { + status = ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask); + if ((status == -1) || (devmask == 0)) + { + linux_audio_close(fd); + fd = -1; + if (status == -1) pprint(" no devmask\n"); else pprint(" (no reported devices)"); + } + else + { + status = ioctl(fd, SOUND_MIXER_READ_RECMASK, &recmask); + if (status == -1) + { + pprint(" no recmask\n"); + recmask = 0; + } + status = ioctl(fd, SOUND_MIXER_READ_STEREODEVS, &stereodevs); + if (status == -1) + { + pprint(" no stereodevs\n"); + stereodevs = 0; + } + status = ioctl(fd, SOUND_MIXER_READ_CAPS, &caps); + if (status == -1) + { + pprint(" no caps\n"); + caps = 0; + } + pprint(":\n\n" + " mixer recording active stereo current\n" + " channel source source device level\n" + " -------- -------- -------- -------- -------- \n"); + for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) + { + if ((1<<i) & devmask) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %-10s", sound_device_names[i]); + pprint(audio_strbuf); + yes_no((1 << i) & recmask); + yes_no((1 << i) & recsrc); + yes_no((1 << i) & stereodevs); + status = ioctl(fd, MIXER_READ(i), &level); + if (status != -1) + { + if ((1<<i) & stereodevs) + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f %.2f", (float)(level & 0xff) * 0.01, (float)((level & 0xff00) >> 8) * 0.01); + else mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.2f", (float)(level & 0xff) * 0.01); + /* can't use %% here because subsequent fprintf in pprint evaluates the %! #$@$! */ + pprint(audio_strbuf); + } + pprint("\n"); + } + } + pprint("--------------------------------\n"); + } + } + +AUDIO_INFO: + if (fd != -1) {linux_audio_close(fd); fd = -1;} + mus_snprintf(dsp_name, LABEL_BUFFER_SIZE, "%s%d", DAC_NAME, dsp_num); + fd = linux_audio_open(dsp_name, O_RDWR, 0, 0); + if ((fd == -1) && (dsp_num == 0)) fd = linux_audio_open(DAC_NAME, O_WRONLY, 0, 0); + if (fd == -1) return; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s:\n\n", dsp_name); pprint(audio_strbuf); + if ((ioctl(fd, SOUND_PCM_READ_RATE, &rate) != -1) && + (ioctl(fd, SOUND_PCM_READ_CHANNELS, &channels) != -1) && + (ioctl(fd, SOUND_PCM_READ_BITS, &bits) != -1) && + (ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &blocksize) != -1)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + " defaults:\n sampling rate: %d, chans: %d, sample size: %d bits, block size: %d bytes", + rate, channels, bits, blocksize); + pprint(audio_strbuf); + +#ifdef SNDCTL_DSP_GETOSPACE + { + audio_buf_info abi; + ioctl(fd, SNDCTL_DSP_GETOSPACE, &abi); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " (%d fragments)\n", abi.fragments); + pprint(audio_strbuf); + } +#else + pprint("\n"); +#endif + + deffmt = AFMT_QUERY; + if ((ioctl(fd, SOUND_PCM_SETFMT, &deffmt) != -1) && + (ioctl(fd, SOUND_PCM_GETFMTS, &formats) != -1)) + { + pprint(" supported formats:\n"); + if (formats & AFMT_MU_LAW) {pprint(" mulaw"); if (deffmt == AFMT_MU_LAW) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_A_LAW) {pprint(" alaw"); if (deffmt == AFMT_A_LAW) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_IMA_ADPCM) {pprint(" adpcm"); if (deffmt == AFMT_IMA_ADPCM) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_U8) {pprint(" unsigned byte"); if (deffmt == AFMT_U8) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_S16_LE) {pprint(" signed little-endian short"); if (deffmt == AFMT_S16_LE) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_S16_BE) {pprint(" signed big-endian short"); if (deffmt == AFMT_S16_BE) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_S8) {pprint(" signed byte"); if (deffmt == AFMT_S8) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_U16_LE) {pprint(" unsigned little-endian short"); if (deffmt == AFMT_U16_LE) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_U16_BE) {pprint(" unsigned big-endian short"); if (deffmt == AFMT_U16_BE) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_MPEG) {pprint(" mpeg 2"); if (deffmt == AFMT_MPEG) pprint(" (default)"); pprint("\n");} +#ifdef NEW_OSS + if (formats & AFMT_S32_LE) {pprint(" signed little-endian int"); if (deffmt == AFMT_S32_LE) pprint(" (default)"); pprint("\n");} + if (formats & AFMT_S32_BE) {pprint(" signed big-endian int"); if (deffmt == AFMT_S32_BE) pprint(" (default)"); pprint("\n");} +#endif + status = ioctl(fd, SNDCTL_DSP_GETCAPS, &caps); + if (status != -1) + { + if (caps & DSP_CAP_DUPLEX) pprint(" full duplex\n"); + pprint(" sample srate\n channels size min max\n"); + for (channels = 1; channels <= 2; channels++) + { + for (bits = 8; bits <= 16; bits += 8) + { + min_rate = 1; + if (set_dsp(fd, channels, bits, &min_rate) == -1) continue; + max_rate = 100000; + if (set_dsp(fd, channels, bits, &max_rate) == -1) continue; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %4d %8d %8d %8d\n", channels, bits, min_rate, max_rate); + pprint(audio_strbuf); + } + } + } + } + } + pprint("--------------------------------\n"); + linux_audio_close(fd); + fd = -1; + dsp_num++; + if (dsp_num < 16) + { + mus_snprintf(dsp_name, LABEL_BUFFER_SIZE, "%s%d", MIXER_NAME, dsp_num); + goto MIXER_INFO; + } +} + +/* ------------------------------- ALSA, OSS, Jack ----------------------------------- */ +/* API being used */ + +static int api = ALSA_API; +int mus_audio_api(void) {return(api);} + +/* hopefully first call to sndlib will be this... */ +static int probe_api(void); +static int (*vect_mus_audio_initialize)(void); + +/* FIXME: add a suitable default for all other vectors + so that a call happening before mus_audio_initialize + can be detected */ +/* I don't think this is necessary -- documentation discusses this + * (mus_sound_initialize calls mus_audio_initialize) + */ + +/* vectors for the rest of the sndlib api */ +static void (*vect_mus_oss_set_buffers)(int num, int size); +static int (*vect_mus_audio_systems)(void); +static char* (*vect_mus_audio_system_name)(int system); +static char* (*vect_mus_audio_moniker)(void); +static int (*vect_mus_audio_open_output)(int ur_dev, int srate, int chans, int format, int size); +static int (*vect_mus_audio_open_input)(int ur_dev, int srate, int chans, int format, int requested_size); +static int (*vect_mus_audio_write)(int id, char *buf, int bytes); +static int (*vect_mus_audio_read)(int id, char *buf, int bytes); +static int (*vect_mus_audio_close)(int id); +static int (*vect_mus_audio_mixer_read)(int ur_dev, int field, int chan, float *val); +static int (*vect_mus_audio_mixer_write)(int ur_dev, int field, int chan, float *val); +static void (*vect_describe_audio_state_1)(void); + +/* vectors for the rest of the sndlib api */ +int mus_audio_initialize(void) +{ + return(probe_api()); +} + +void mus_oss_set_buffers(int num, int size) +{ + vect_mus_oss_set_buffers(num, size); +} + +int mus_audio_systems(void) +{ + return(vect_mus_audio_systems()); +} + +char* mus_audio_system_name(int system) +{ + return(vect_mus_audio_system_name(system)); +} + +#if HAVE_ALSA +static char* alsa_mus_audio_moniker(void); +#endif + +char* mus_audio_moniker(void) +{ +#if (HAVE_OSS && HAVE_ALSA) + char *both_names; + both_names = (char *)CALLOC(PRINT_BUFFER_SIZE, sizeof(char)); + /* need to be careful here since these use the same constant buffer */ + strcpy(both_names, oss_mus_audio_moniker()); + strcat(both_names, ", "); + strcat(both_names, alsa_mus_audio_moniker()); + return(both_names); /* tiny memory leak ... */ +#else + return(vect_mus_audio_moniker()); +#endif +} + +int mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + return(vect_mus_audio_open_output(ur_dev, srate, chans, format, size)); +} + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int requested_size) +{ + return(vect_mus_audio_open_input(ur_dev, srate, chans, format, requested_size)); +} + +int mus_audio_write(int id, char *buf, int bytes) +{ + return(vect_mus_audio_write(id, buf, bytes)); +} + +int mus_audio_read(int id, char *buf, int bytes) +{ + return(vect_mus_audio_read(id, buf, bytes)); +} + +int mus_audio_close(int id) +{ + return(vect_mus_audio_close(id)); +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + return(vect_mus_audio_mixer_read(ur_dev, field, chan, val)); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + return(vect_mus_audio_mixer_write(ur_dev, field, chan, val)); +} + +static void describe_audio_state_1(void) +{ + vect_describe_audio_state_1(); +} + +#if HAVE_JACK + static int jack_mus_audio_initialize(void); +#endif + +#if (!HAVE_ALSA) +static int probe_api(void) +{ +#if HAVE_JACK + { + int jackprobe = jack_mus_audio_initialize(); + if (jackprobe == MUS_ERROR) + { +#endif + /* go for the oss api */ + api = OSS_API; + vect_mus_audio_initialize = oss_mus_audio_initialize; + vect_mus_oss_set_buffers = oss_mus_oss_set_buffers; + vect_mus_audio_systems = oss_mus_audio_systems; + vect_mus_audio_system_name = oss_mus_audio_system_name; + vect_mus_audio_moniker = oss_mus_audio_moniker; + vect_mus_audio_open_output = oss_mus_audio_open_output; + vect_mus_audio_open_input = oss_mus_audio_open_input; + vect_mus_audio_write = oss_mus_audio_write; + vect_mus_audio_read = oss_mus_audio_read; + vect_mus_audio_close = oss_mus_audio_close; + vect_mus_audio_mixer_read = oss_mus_audio_mixer_read; + vect_mus_audio_mixer_write = oss_mus_audio_mixer_write; + vect_describe_audio_state_1 = oss_describe_audio_state_1; + return(vect_mus_audio_initialize()); +#if HAVE_JACK + } + return(jackprobe); + } +#endif +} +#endif + +#endif + + +/* ------------------------------- ALSA ----------------------------------------- */ +/* + * added HAVE_NEW_ALSA, and changed various calls to reflect the new calling sequences (all under HAVE_NEW_ALSA) + * also scheme/ruby tie-ins, and other such changes. Changed the names of the environment variables to use MUS, not SNDLIB. + * reformatted and reorganized to be like the rest of the code + * changed default device to "default" + * -- Bill 3-Feb-06 + * + * error handling (mus_error) changed by Bill 14-Nov-02 + * 0.5 support removed by Bill 24-Mar-02 + * + * changed for 0.9.x api by Fernando Lopez-Lezcano <nando@ccrma.stanford.edu> + * + * sndlib "exports" only one soundcard with two directions (if they are available), + * and only deals with the alsa library pcm's. It does not scan for available + * cards and devices at the hardware level. Which device it uses can be defined by: + * + * - setting variables in the environment (searched for in the following order): + * MUS_ALSA_PLAYBACK_DEVICE + * defines the name of the playback device + * MUS_ALSA_CAPTURE_DEVICE + * defines the name of the capture device + * MUS_ALSA_DEVICE + * defines the name of the playback and capture device + * use the first two if the playback and capture devices are different or the + * third if they are the same. + * - if no variables are found in the environment sndlib tries to probe for a + * default device named "sndlib" (in alsa 0.9 devices are configured in + * /usr/share/alsa/alsa.conf or in ~/.asoundrc) + * - if "sndlib" is not a valid device "hw:0,0" was used [but now it looks for "default"] (which by default should + * point to the first device of the first card + * + * Some default settings are controllable through the environment as well: + * MUS_ALSA_BUFFER_SIZE = size of each buffer in frames + * MUS_ALSA_BUFFERS = number of buffers + * + * changed 18-Sep-00 by Bill: new error handling: old mus_audio_error folded into + * mus_error; mus_error itself should be used only for "real" errors -- things + * that can cause a throw (a kind of global jump elsewhere); use mus_print for informational + * stuff -- in Snd, mus_print will also save everything printed in the error dialog. + * In a few cases, I tried to fix the code to unwind before mus_error, and in others + * I've changed mus_error to mus_print, but some of these may be mistaken. + * Look for ?? below for areas where I'm not sure I rewrote code correctly. + * + * changed for 0.6.x api by Paul Barton-Davis, pbd@op.net + * + * changed for 0.5.x api by Fernando Lopez-Lezcano, nando@ccrma.stanford.edu + * 04-10-2000: + * based on original 0.4.x code by Paul Barton-Davis (not much left of it :-) + * also Bill's code and Jaroslav Kysela (aplay.c and friends) + * + * Changes: + * 04/25/2000: finished major rework, snd-dac now automatically decides which + * device or devices it uses for playback. Multiple device use is + * for now restricted to only two at most (more changes in Bill's + * needed to be able to support more). Four channel playback in + * Ensoniq AudioPCI and relatives possible (with proper settings + * of the mixer) as well as using two separate cards. + * 04/11/2000: added reporting of alsa sound formats +*/ + +#if HAVE_ALSA + +#if (!HAVE_OSS) +#define AUDIO_OK +#endif + +#include <sys/ioctl.h> + +#if (!HAVE_NEW_ALSA) + #define ALSA_PCM_OLD_HW_PARAMS_API + #define ALSA_PCM_OLD_SW_PARAMS_API +#endif + +#if HAVE_ALSA_ASOUNDLIB_H + #include <alsa/asoundlib.h> +#else + #include <sys/asoundlib.h> +#endif + +#if SND_LIB_VERSION < ((0<<16)|(6<<8)|(0)) + #error ALSA version is too old -- audio.c needs 0.9 or later +#endif + +/* prototypes for the alsa sndlib functions */ +static int alsa_mus_audio_initialize(void); +static void alsa_mus_oss_set_buffers(int num, int size); +static int alsa_mus_audio_systems(void); +static char* alsa_mus_audio_system_name(int system); +static int alsa_mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size); +static int alsa_mus_audio_open_input(int ur_dev, int srate, int chans, int format, int requested_size); +static int alsa_mus_audio_write(int id, char *buf, int bytes); +static int alsa_mus_audio_read(int id, char *buf, int bytes); +static int alsa_mus_audio_close(int id); +static int alsa_mus_audio_mixer_read(int ur_dev, int field, int chan, float *val); +static int alsa_mus_audio_mixer_write(int ur_dev, int field, int chan, float *val); +static void alsa_describe_audio_state_1(void); + +/* decide which api to activate */ + +static int probe_api(void) +{ +#if HAVE_JACK + int jackprobe; + jackprobe = jack_mus_audio_initialize(); + if (jackprobe == MUS_ERROR) + { +#endif + int card = -1; + if ((snd_card_next(&card) >= 0) && (card >= 0)) + { + /* the alsa library has detected one or more cards */ + api = ALSA_API; + vect_mus_audio_initialize = alsa_mus_audio_initialize; + vect_mus_oss_set_buffers = alsa_mus_oss_set_buffers; + vect_mus_audio_systems = alsa_mus_audio_systems; + vect_mus_audio_system_name = alsa_mus_audio_system_name; + vect_mus_audio_moniker = alsa_mus_audio_moniker; + vect_mus_audio_open_output = alsa_mus_audio_open_output; + vect_mus_audio_open_input = alsa_mus_audio_open_input; + vect_mus_audio_write = alsa_mus_audio_write; + vect_mus_audio_read = alsa_mus_audio_read; + vect_mus_audio_close = alsa_mus_audio_close; + vect_mus_audio_mixer_read = alsa_mus_audio_mixer_read; + vect_mus_audio_mixer_write = alsa_mus_audio_mixer_write; + vect_describe_audio_state_1 = alsa_describe_audio_state_1; + } + else + { + /* go for the oss api */ + api = OSS_API; + vect_mus_audio_initialize = oss_mus_audio_initialize; + vect_mus_oss_set_buffers = oss_mus_oss_set_buffers; + vect_mus_audio_systems = oss_mus_audio_systems; + vect_mus_audio_system_name = oss_mus_audio_system_name; + vect_mus_audio_moniker = oss_mus_audio_moniker; + vect_mus_audio_open_output = oss_mus_audio_open_output; + vect_mus_audio_open_input = oss_mus_audio_open_input; + vect_mus_audio_write = oss_mus_audio_write; + vect_mus_audio_read = oss_mus_audio_read; + vect_mus_audio_close = oss_mus_audio_close; + vect_mus_audio_mixer_read = oss_mus_audio_mixer_read; + vect_mus_audio_mixer_write = oss_mus_audio_mixer_write; + vect_describe_audio_state_1 = oss_describe_audio_state_1; + } + /* will the _real_ mus_audio_initialize please stand up? */ + return(vect_mus_audio_initialize()); +#if HAVE_JACK + } + return(jackprobe); +#endif +} + +/* convert a sndlib sample format to an alsa sample format */ + +static snd_pcm_format_t to_alsa_format(int snd_format) +{ + switch (snd_format) + { + case MUS_BYTE: return(SND_PCM_FORMAT_S8); + case MUS_UBYTE: return(SND_PCM_FORMAT_U8); + case MUS_MULAW: return(SND_PCM_FORMAT_MU_LAW); + case MUS_ALAW: return(SND_PCM_FORMAT_A_LAW); + case MUS_BSHORT: return(SND_PCM_FORMAT_S16_BE); + case MUS_LSHORT: return(SND_PCM_FORMAT_S16_LE); + case MUS_UBSHORT: return(SND_PCM_FORMAT_U16_BE); + case MUS_ULSHORT: return(SND_PCM_FORMAT_U16_LE); + case MUS_B24INT: return(SND_PCM_FORMAT_S24_BE); + case MUS_L24INT: return(SND_PCM_FORMAT_S24_LE); + case MUS_BINT: return(SND_PCM_FORMAT_S32_BE); + case MUS_LINT: return(SND_PCM_FORMAT_S32_LE); + case MUS_BINTN: return(SND_PCM_FORMAT_S32_BE); + case MUS_LINTN: return(SND_PCM_FORMAT_S32_LE); + case MUS_BFLOAT: return(SND_PCM_FORMAT_FLOAT_BE); + case MUS_LFLOAT: return(SND_PCM_FORMAT_FLOAT_LE); + case MUS_BDOUBLE: return(SND_PCM_FORMAT_FLOAT64_BE); + case MUS_LDOUBLE: return(SND_PCM_FORMAT_FLOAT64_LE); + } + return((snd_pcm_format_t)MUS_ERROR); +} + +/* FIXME: this is not taking yet into account the + * number of bits that a given alsa format is actually + * using... + */ + +static int to_mus_format(int alsa_format) +{ + /* alsa format definitions from asoundlib.h (0.9 cvs 6/27/2001) */ + switch (alsa_format) + { + case SND_PCM_FORMAT_S8: return(MUS_BYTE); + case SND_PCM_FORMAT_U8: return(MUS_UBYTE); + case SND_PCM_FORMAT_S16_LE: return(MUS_LSHORT); + case SND_PCM_FORMAT_S16_BE: return(MUS_BSHORT); + case SND_PCM_FORMAT_U16_LE: return(MUS_ULSHORT); + case SND_PCM_FORMAT_U16_BE: return(MUS_UBSHORT); + case SND_PCM_FORMAT_S24_LE: return(MUS_L24INT); + case SND_PCM_FORMAT_S24_BE: return(MUS_B24INT); + case SND_PCM_FORMAT_S32_LE: return(MUS_LINTN); /* 32bit normalized plays 24bit and 16bit files with same amplitude bound (for 24 bit cards) */ + case SND_PCM_FORMAT_S32_BE: return(MUS_BINTN); + case SND_PCM_FORMAT_FLOAT_LE: return(MUS_LFLOAT); + case SND_PCM_FORMAT_FLOAT_BE: return(MUS_BFLOAT); + case SND_PCM_FORMAT_FLOAT64_LE: return(MUS_LDOUBLE); + case SND_PCM_FORMAT_FLOAT64_BE: return(MUS_BDOUBLE); + case SND_PCM_FORMAT_MU_LAW: return(MUS_MULAW); + case SND_PCM_FORMAT_A_LAW: return(MUS_ALAW); + /* formats with no translation in snd */ + case SND_PCM_FORMAT_U24_LE: + case SND_PCM_FORMAT_U24_BE: + case SND_PCM_FORMAT_U32_LE: + case SND_PCM_FORMAT_U32_BE: + case SND_PCM_FORMAT_IEC958_SUBFRAME_LE: + case SND_PCM_FORMAT_IEC958_SUBFRAME_BE: + case SND_PCM_FORMAT_IMA_ADPCM: + case SND_PCM_FORMAT_MPEG: + case SND_PCM_FORMAT_GSM: + case SND_PCM_FORMAT_SPECIAL: + default: + return(MUS_ERROR); + } +} + +/* convert a sndlib device into an alsa device number and channel + * [has to be coordinated with following function!] + */ + +/* very simplistic approach, device mapping should also depend + * on which card we're dealing with, digital i/o devices should + * be identified as such and so on + */ + +/* NOTE: in the Delta1010 digital i/o is just a pair of channels + * in the 10 channel playback frame or 12 channel capture frame, + * how do we specify that??? + */ + +static int to_alsa_device(int dev, int *adev, snd_pcm_stream_t *achan) +{ + switch(dev) + { + /* default values are a problem because the concept does + * not imply a direction (playback or capture). This works + * fine as long as both directions of a device are symetric, + * the Midiman 1010, for example, has 10 channel frames for + * playback and 12 channel frames for capture and breaks + * the recorder (probes the default, defaults to output, + * uses the values for input). + */ + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_LINE_OUT: + /* analog output */ + (*adev) = 0; + (*achan) = SND_PCM_STREAM_PLAYBACK; + break; + case MUS_AUDIO_AUX_OUTPUT: + /* extra analog output */ + (*adev) = 1; + (*achan) = SND_PCM_STREAM_PLAYBACK; + break; + case MUS_AUDIO_DAC_OUT: + /* analog outputs */ + (*adev) = 2; + (*achan) = SND_PCM_STREAM_PLAYBACK; + break; + case MUS_AUDIO_MICROPHONE: + case MUS_AUDIO_LINE_IN: + /* analog input */ + (*adev) = 0; + (*achan) = SND_PCM_STREAM_CAPTURE; + break; + case MUS_AUDIO_AUX_INPUT: + /* extra analog input */ + (*adev) = 1; + (*achan) = SND_PCM_STREAM_CAPTURE; + break; + case MUS_AUDIO_DIGITAL_OUT: + case MUS_AUDIO_SPDIF_OUT: + case MUS_AUDIO_AES_OUT: + case MUS_AUDIO_ADAT_OUT: + case MUS_AUDIO_DIGITAL_IN: + case MUS_AUDIO_SPDIF_IN: + case MUS_AUDIO_AES_IN: + case MUS_AUDIO_ADAT_IN: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_DAC_FILTER: + case MUS_AUDIO_MIXER: + case MUS_AUDIO_LINE1: + case MUS_AUDIO_LINE2: + case MUS_AUDIO_LINE3: + case MUS_AUDIO_CD: + default: + return(MUS_ERROR); + break; + } + return(0); +} + +/* convert an alsa device into a sndlib device + * [has to be coordinated with previous function!] + * + * naming here is pretty much arbitrary. We have to have + * a bidirectional mapping between sndlib devices and + * alsa devices and that's just not possible (I think). + * This stopgap mapping ignores digital input and output + * devices - how to differentiate them in alsa? + */ + +static int to_sndlib_device(int dev, int channel) +{ + switch (channel) + { + case SND_PCM_STREAM_PLAYBACK: + switch (dev) + { + /* works only for the first three outputs */ + case 0: return(MUS_AUDIO_LINE_OUT); + case 1: return(MUS_AUDIO_AUX_OUTPUT); + case 2: return(MUS_AUDIO_DAC_OUT); + default: + return(MUS_ERROR); + } + case SND_PCM_STREAM_CAPTURE: + switch (dev) + { + case 0: return(MUS_AUDIO_LINE_IN); + case 1: return(MUS_AUDIO_AUX_INPUT); + default: + return(MUS_ERROR); + } + break; + } + return(MUS_ERROR); +} + + +static int alsa_mus_error(int type, char *message) +{ + if (message) + { + mus_print(message); + FREE(message); + } + return(MUS_ERROR); +} + +#if 0 +static void alsa_dump_hardware_params(snd_pcm_hw_params_t *params, const char *msg) +{ + snd_output_t *out; + snd_output_stdio_attach(&out, stderr, 0); + fprintf(stderr, "%s\n", msg); + snd_pcm_hw_params_dump(params, out); +} + +static void alsa_dump_software_params(snd_pcm_sw_params_t *params, const char *msg) +{ + snd_output_t *out; + snd_output_stdio_attach(&out, stderr, 0); + fprintf(stderr, "%s\n", msg); + snd_pcm_sw_params_dump(params, out); +} +#endif + + +/* dump current hardware and software configuration */ + +static void alsa_dump_configuration(char *name, snd_pcm_hw_params_t *hw_params, snd_pcm_sw_params_t *sw_params) +{ + int err; + char *str; + size_t len; + snd_output_t *buf; + +#if (SND_LIB_MAJOR == 0) || ((SND_LIB_MAJOR == 1) && (SND_LIB_MINOR == 0) && (SND_LIB_SUBMINOR < 8)) + return; /* avoid Alsa bug */ +#endif + + err = snd_output_buffer_open(&buf); + if (err < 0) + { + mus_print("could not open dump buffer: %s", snd_strerror(err)); + } + else + { + if (hw_params) + { + snd_output_puts(buf, "hw_params status of "); + snd_output_puts(buf, name); + snd_output_puts(buf, "\n"); + err = snd_pcm_hw_params_dump(hw_params, buf); + if (err < 0) + mus_print("snd_pcm_hw_params_dump: %s", snd_strerror(err)); + } + if (sw_params) + { + snd_output_puts(buf, "sw_params status of "); + snd_output_puts(buf, name); + snd_output_puts(buf, "\n"); + err = snd_pcm_sw_params_dump(sw_params, buf); + if (err < 0) + mus_print("snd_pcm_hw_params_dump: %s", snd_strerror(err)); + } + snd_output_putc(buf, '\0'); + len = snd_output_buffer_string(buf, &str); + if (len > 1) + mus_print("status of %s\n%s", name, str); + snd_output_close(buf); + } +} + +/* get hardware params for a pcm */ + +static snd_pcm_hw_params_t *alsa_get_hardware_params(const char *name, snd_pcm_stream_t stream, int mode) +{ + int err; + snd_pcm_t *handle; + if ((err = snd_pcm_open(&handle, name, stream, mode | SND_PCM_NONBLOCK)) != 0) + { + alsa_mus_error(MUS_AUDIO_CANT_OPEN, + mus_format("open pcm %s for stream %d: %s", + name, stream, snd_strerror(err))); + return(NULL); + } + else + { + snd_pcm_hw_params_t *params; + params = (snd_pcm_hw_params_t *)calloc(1, snd_pcm_hw_params_sizeof()); + if (params == NULL) + { + snd_pcm_close(handle); + alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("could not allocate memory for hardware params")); + } + else + { + err = snd_pcm_hw_params_any(handle, params); + if (err < 0) + { + snd_pcm_close(handle); + alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("snd_pcm_hw_params_any: pcm %s, stream %d, error: %s", + name, stream, snd_strerror(err))); + } + else + { + snd_pcm_close(handle); + return(params); + } + } + } + return(NULL); +} + +/* allocate software params structure */ + +static snd_pcm_sw_params_t *alsa_get_software_params(void) +{ + snd_pcm_sw_params_t *params = NULL; + params = (snd_pcm_sw_params_t *)calloc(1, snd_pcm_sw_params_sizeof()); + if (params == NULL) + { + alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("could not allocate memory for software params")); + } + return(params); +} + +/* probe a device name against the list of available pcm devices */ + +#ifndef SND_CONFIG_GET_ID_ARGS + #define SND_CONFIG_GET_ID_ARGS 1 +#endif + +static bool alsa_probe_device_name(const char *name) +{ + snd_config_t *conf; + snd_config_iterator_t pos, next; + int err; + + err = snd_config_update(); + if (err < 0) + { + mus_print("snd_config_update: %s", snd_strerror(err)); + return(false); + } + + err = snd_config_search(snd_config, "pcm", &conf); + if (err < 0) + { + mus_print("snd_config_search: %s", snd_strerror(err)); + return(false); + } + + snd_config_for_each(pos, next, conf) + { + snd_config_t *c = snd_config_iterator_entry(pos); +#if (SND_CONFIG_GET_ID_ARGS == 2) + const char *id; + int err = snd_config_get_id(c, &id); + if (err == 0) { + int result = strncmp(name, id, strlen(id)); + if (result == 0 && + (name[strlen(id)] == '\0' || name[strlen(id)] == ':')) + { + return(true); + } + } +#else + const char *id = snd_config_get_id(c); + int result = strncmp(name, id, strlen(id)); + if (result == 0 && + (name[strlen(id)] == '\0' || name[strlen(id)] == ':')) + { + return(true); + } +#endif + } + return(false); +} + +/* check a device name against the list of available pcm devices */ + +static int alsa_check_device_name(const char *name) +{ + if (!alsa_probe_device_name(name)) + { + return(alsa_mus_error(MUS_AUDIO_CANT_READ, + mus_format("alsa could not find device \"%s\" in configuration", + name))); + } + return(MUS_NO_ERROR); +} + + +/* set scheduling priority to SCHED_FIFO + * this will only work if the program that uses sndlib is run as root or is suid root + */ + +/* whether we want to trace calls + * + * set to "1" to print function trace information in the + * snd error window + */ + +static int alsa_trace = 0; + +/* this should go away as it is oss specific */ + +static int fragment_size = 512; +static int fragments = 4; + +static void alsa_mus_oss_set_buffers(int num, int size) +{ + fragments = num; + fragment_size = size; +#if MUS_DEBUGGING + mus_print("set_oss_buffers: %d fragments or size %d", num, size); +#endif +} + +/* total number of soundcards in our setup, set by initialize_audio */ + +/* static int sound_cards = 0; */ + +/* return the number of cards that are available */ + +static int alsa_mus_audio_systems(void) +{ + return(sound_cards); +} + +/* return the type of driver we're dealing with */ + +static char *alsa_mus_audio_moniker(void) +{ + if (version_name == NULL) version_name = (char *)CALLOC(LABEL_BUFFER_SIZE, sizeof(char)); + mus_snprintf(version_name, LABEL_BUFFER_SIZE, "ALSA %s", SND_LIB_VERSION_STR); + return(version_name); +} + +/* handles for both directions of the virtual device */ + +static snd_pcm_t *handles[2] = {NULL, NULL}; + +/* hardware and software parameter sctructure pointers */ + +static snd_pcm_hw_params_t *alsa_hw_params[2] = {NULL, NULL}; /* avoid bogus free */ +static snd_pcm_sw_params_t *alsa_sw_params[2] = {NULL, NULL}; + +/* some defaults */ + +static int alsa_open_mode = SND_PCM_ASYNC; +static int alsa_buffers = 3; +/* size of buffer in number of samples per channel, + * at 44100 approximately 5.9mSecs + */ +static int alsa_samples_per_channel = 1024; +static snd_pcm_access_t alsa_interleave = SND_PCM_ACCESS_RW_INTERLEAVED; +static int alsa_max_capture_channels = 32; + +/* first default name for pcm configuration */ + +static char *alsa_sndlib_device_name = "sndlib"; + +/* second default for playback and capture: hardware pcm, first card, first device */ +/* pcms used by sndlib, playback and capture */ + +static char *alsa_playback_device_name = NULL; +static char *alsa_capture_device_name = NULL; + + +/* -------- tie these names into scheme/ruby -------- */ + +static int alsa_get_max_buffers(void) +{ + unsigned int max_periods = 0, max_rec_periods = 0; + int dir = 0; +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_periods_max(alsa_hw_params[SND_PCM_STREAM_PLAYBACK], &max_periods, &dir); +#else + max_periods = snd_pcm_hw_params_get_periods_max(alsa_hw_params[SND_PCM_STREAM_PLAYBACK], &dir); +#endif + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) + { +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_periods_max(alsa_hw_params[SND_PCM_STREAM_CAPTURE], &max_rec_periods, &dir); +#else + max_rec_periods = snd_pcm_hw_params_get_periods_max(alsa_hw_params[SND_PCM_STREAM_CAPTURE], &dir); +#endif + if (max_periods > max_rec_periods) + max_periods = max_rec_periods; + } + return(max_periods); +} + +static int alsa_get_min_buffers(void) +{ + unsigned int min_periods = 0, min_rec_periods = 0; + int dir = 0; +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_periods_min(alsa_hw_params[SND_PCM_STREAM_PLAYBACK], &min_periods, &dir); +#else + min_periods = snd_pcm_hw_params_get_periods_min(alsa_hw_params[SND_PCM_STREAM_PLAYBACK], &dir); +#endif + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) + { +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_periods_min(alsa_hw_params[SND_PCM_STREAM_CAPTURE], &min_rec_periods, &dir); +#else + min_rec_periods = snd_pcm_hw_params_get_periods_min(alsa_hw_params[SND_PCM_STREAM_CAPTURE], &dir); +#endif + if (min_periods < min_rec_periods) + min_periods = min_rec_periods; + } + return(min_periods); +} + +static int alsa_clamp_buffers(int bufs) +{ + int minb, maxb; + minb = alsa_get_min_buffers(); + maxb = alsa_get_max_buffers(); + if (bufs > maxb) + bufs = maxb; + if (bufs < minb) + bufs = minb; + return(bufs); +} + +static snd_pcm_uframes_t alsa_get_min_buffer_size(void) +{ + snd_pcm_uframes_t min_buffer_size = 0, min_rec_buffer_size = 0; +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_buffer_size_min(alsa_hw_params[SND_PCM_STREAM_PLAYBACK], &min_buffer_size); +#else + min_buffer_size = snd_pcm_hw_params_get_buffer_size_min(alsa_hw_params[SND_PCM_STREAM_PLAYBACK]); +#endif + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) + { +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_buffer_size_min(alsa_hw_params[SND_PCM_STREAM_CAPTURE], &min_rec_buffer_size); +#else + min_rec_buffer_size = snd_pcm_hw_params_get_buffer_size_min(alsa_hw_params[SND_PCM_STREAM_CAPTURE]); +#endif + + if (min_buffer_size < min_rec_buffer_size) + min_buffer_size = min_rec_buffer_size; + } + return(min_buffer_size); +} + +static snd_pcm_uframes_t alsa_get_max_buffer_size(void) +{ + snd_pcm_uframes_t max_buffer_size = 0, max_rec_buffer_size = 0; +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_buffer_size_max(alsa_hw_params[SND_PCM_STREAM_PLAYBACK], &max_buffer_size); +#else + max_buffer_size = snd_pcm_hw_params_get_buffer_size_max(alsa_hw_params[SND_PCM_STREAM_PLAYBACK]); +#endif + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) + { +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_buffer_size_max(alsa_hw_params[SND_PCM_STREAM_CAPTURE], &max_rec_buffer_size); +#else + max_rec_buffer_size = snd_pcm_hw_params_get_buffer_size_max(alsa_hw_params[SND_PCM_STREAM_CAPTURE]); +#endif + if (max_buffer_size > max_rec_buffer_size) + max_buffer_size = max_rec_buffer_size; + } + return(max_buffer_size); +} + +static int alsa_clamp_buffer_size(int buf_size) +{ + int minb, maxb; + minb = alsa_get_min_buffer_size(); + maxb = alsa_get_max_buffer_size(); + if (buf_size > maxb) + buf_size = maxb; + if (buf_size < minb) + buf_size = minb; + return(buf_size); +} + +static bool alsa_set_playback_parameters(void) +{ + /* playback stream parameters */ + if (alsa_hw_params[SND_PCM_STREAM_PLAYBACK]) free(alsa_hw_params[SND_PCM_STREAM_PLAYBACK]); + alsa_hw_params[SND_PCM_STREAM_PLAYBACK] = alsa_get_hardware_params(alsa_playback_device_name, SND_PCM_STREAM_PLAYBACK, alsa_open_mode); + if (alsa_hw_params[SND_PCM_STREAM_PLAYBACK]) + { + snd_pcm_uframes_t size; + int old_buffers; + old_buffers = alsa_buffers; + if (alsa_sw_params[SND_PCM_STREAM_PLAYBACK]) free(alsa_sw_params[SND_PCM_STREAM_PLAYBACK]); + alsa_sw_params[SND_PCM_STREAM_PLAYBACK] = alsa_get_software_params(); + sound_cards = 1; + alsa_buffers = alsa_clamp_buffers(alsa_buffers); + if (alsa_buffers <= 0) + { + alsa_buffers = old_buffers; + return(false); + } + size = alsa_clamp_buffer_size(alsa_samples_per_channel * alsa_buffers); + if (size <= 0) return(false); + alsa_samples_per_channel = size / alsa_buffers; + } + return(alsa_hw_params[SND_PCM_STREAM_PLAYBACK] && alsa_sw_params[SND_PCM_STREAM_PLAYBACK]); +} + +static bool alsa_set_capture_parameters(void) +{ + /* capture stream parameters */ + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) free(alsa_hw_params[SND_PCM_STREAM_CAPTURE]); + alsa_hw_params[SND_PCM_STREAM_CAPTURE] = alsa_get_hardware_params(alsa_capture_device_name, SND_PCM_STREAM_CAPTURE, alsa_open_mode); + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) + { + snd_pcm_uframes_t size; + int old_buffers; + old_buffers = alsa_buffers; + if (alsa_sw_params[SND_PCM_STREAM_CAPTURE]) free(alsa_sw_params[SND_PCM_STREAM_CAPTURE]); + alsa_sw_params[SND_PCM_STREAM_CAPTURE] = alsa_get_software_params(); + sound_cards = 1; + alsa_buffers = alsa_clamp_buffers(alsa_buffers); + if (alsa_buffers <= 0) + { + alsa_buffers = old_buffers; + return(false); + } + size = alsa_clamp_buffer_size(alsa_samples_per_channel * alsa_buffers); + if (size <= 0) return(false); + alsa_samples_per_channel = size / alsa_buffers; + } + return(alsa_hw_params[SND_PCM_STREAM_CAPTURE] && alsa_sw_params[SND_PCM_STREAM_CAPTURE]); +} + + +char *mus_alsa_playback_device(void) {return(alsa_playback_device_name);} +char *mus_alsa_set_playback_device(const char *name) +{ + if (alsa_check_device_name(name) == MUS_NO_ERROR) + { + char *old_name = alsa_playback_device_name; + alsa_playback_device_name = strdup(name); + if (!alsa_set_playback_parameters()) + { + alsa_playback_device_name = old_name; /* try to back out of the mistake */ + alsa_set_playback_parameters(); + } + } + return(alsa_playback_device_name); +} + +char *mus_alsa_capture_device(void) {return(alsa_capture_device_name);} +char *mus_alsa_set_capture_device(const char *name) +{ + if (alsa_check_device_name(name) == MUS_NO_ERROR) + { + char *old_name = alsa_capture_device_name; + alsa_capture_device_name = strdup(name); + if (!alsa_set_capture_parameters()) + { + alsa_capture_device_name = old_name; + alsa_set_capture_parameters(); + } + } + return(alsa_capture_device_name); +} + +char *mus_alsa_device(void) {return(alsa_sndlib_device_name);} +char *mus_alsa_set_device(const char *name) +{ + if (alsa_check_device_name(name) == MUS_NO_ERROR) + { + alsa_sndlib_device_name = strdup(name); + mus_alsa_set_playback_device(name); + mus_alsa_set_capture_device(name); + } + return(alsa_sndlib_device_name); +} + +int mus_alsa_buffer_size(void) {return(alsa_samples_per_channel);} +int mus_alsa_set_buffer_size(int size) +{ + snd_pcm_uframes_t bsize; + if (alsa_buffers == 0) alsa_buffers = 1; + if (size > 0) + { + bsize = alsa_clamp_buffer_size(size * alsa_buffers); + alsa_samples_per_channel = bsize / alsa_buffers; + } + return(alsa_samples_per_channel); +} + +int mus_alsa_buffers(void) {return(alsa_buffers);} +int mus_alsa_set_buffers(int num) +{ + snd_pcm_uframes_t size; + if (num > 0) + { + alsa_buffers = alsa_clamp_buffers(num); + if (alsa_buffers > 0) + { + size = alsa_clamp_buffer_size(alsa_samples_per_channel * alsa_buffers); + alsa_samples_per_channel = size / alsa_buffers; + } + } + return(alsa_buffers); +} + +static bool alsa_squelch_warning = false; +bool mus_alsa_squelch_warning(void) {return(alsa_squelch_warning);} +bool mus_alsa_set_squelch_warning(bool val) +{ + alsa_squelch_warning = val; + return(val); +} + + + + +/* return the name of a given system */ + +static char *alsa_mus_audio_system_name(int system) +{ + return(alsa_playback_device_name); +} + +/* get a device name from the environment */ + +static char *alsa_get_device_from_env(const char *name) +{ + char *string = getenv(name); + if (string) + if (alsa_check_device_name(string) == MUS_NO_ERROR) + return(string); + return(NULL); +} + +/* get an integer from the environment */ + +static int alsa_get_int_from_env(const char *name, int *value, int min, int max) +{ + char *string = getenv(name); + if (string) + { + char *end; + long int result = strtol(string, &end, 10); + if (((min != -1) && (max != -1)) && + (result < min || result > max)) + { + return(alsa_mus_error(MUS_AUDIO_CANT_READ, + mus_format("%s ignored: out of range, value=%d, min=%d, max=%d", + name, (int)result, min, max))); + } + else + { + if (errno == ERANGE) + { + return(alsa_mus_error(MUS_AUDIO_CANT_READ, + mus_format("%s ignored: strlol conversion out of range", + name))); + } + else + { + if ((*string != '\0') && (*end == '\0')) + { + *value = (int)result; + return(MUS_NO_ERROR); + } + else + { + return(alsa_mus_error(MUS_AUDIO_CANT_READ, + mus_format("%s ignored: value is \"%s\", not an integer", + name, string))); + } + } + } + } + return(MUS_ERROR); +} + +/* initialize the audio subsystem */ + +/* define environment variable names */ +#define MUS_ALSA_PLAYBACK_DEVICE_ENV_NAME "MUS_ALSA_PLAYBACK_DEVICE" +#define MUS_ALSA_CAPTURE_DEVICE_ENV_NAME "MUS_ALSA_CAPTURE_DEVICE" +#define MUS_ALSA_DEVICE_ENV_NAME "MUS_ALSA_DEVICE" +#define MUS_ALSA_BUFFERS_ENV_NAME "MUS_ALSA_BUFFERS" +#define MUS_ALSA_BUFFER_SIZE_ENV_NAME "MUS_ALSA_BUFFER_SIZE" +#define MUS_ALSA_TRACE_ENV_NAME "MUS_ALSA_TRACE" + +static int alsa_mus_audio_initialize(void) +{ + char *name = NULL; + char *pname; + char *cname; + int value = 0, alsa_buffer_size = 0; + + if (audio_initialized) + return(0); + + sound_cards = 0; + + /* get trace flag from environment */ + if (alsa_get_int_from_env(MUS_ALSA_TRACE_ENV_NAME, &value, 0, 1) == MUS_NO_ERROR) + alsa_trace = value; + + /* try to get device names from environment */ + pname = alsa_get_device_from_env(MUS_ALSA_PLAYBACK_DEVICE_ENV_NAME); + if ((pname) && (alsa_probe_device_name(pname))) + alsa_playback_device_name = pname; + + cname = alsa_get_device_from_env(MUS_ALSA_CAPTURE_DEVICE_ENV_NAME); + if ((cname) && (alsa_probe_device_name(cname))) + alsa_capture_device_name = cname; + + name = alsa_get_device_from_env(MUS_ALSA_DEVICE_ENV_NAME); + if ((name) && (alsa_probe_device_name(name))) + { + if (!alsa_playback_device_name) + alsa_playback_device_name = name; + + if (!alsa_capture_device_name) + alsa_capture_device_name = name; + + alsa_sndlib_device_name = name; + } + + /* now check that we have a plausible name */ + if (!alsa_probe_device_name(alsa_sndlib_device_name)) + { + alsa_sndlib_device_name = "default"; + if (!alsa_probe_device_name(alsa_sndlib_device_name)) + { + alsa_sndlib_device_name = "plughw:0"; + if (!alsa_probe_device_name(alsa_sndlib_device_name)) + alsa_sndlib_device_name = "hw:0"; + } + } + + /* if no device name set yet, try for special sndlib name first */ + if (!alsa_playback_device_name) + { + if (alsa_probe_device_name(alsa_sndlib_device_name)) + alsa_playback_device_name = alsa_sndlib_device_name; + else alsa_playback_device_name = "hw:0"; + } + + if (!alsa_capture_device_name) + { + if (alsa_probe_device_name(alsa_sndlib_device_name)) + alsa_capture_device_name = alsa_sndlib_device_name; + else alsa_capture_device_name = "hw:0"; + } + + alsa_get_int_from_env(MUS_ALSA_BUFFERS_ENV_NAME, &alsa_buffers, -1, -1); + alsa_get_int_from_env(MUS_ALSA_BUFFER_SIZE_ENV_NAME, &alsa_buffer_size, -1, -1); + + if ((alsa_buffer_size > 0) && (alsa_buffers > 0)) + alsa_samples_per_channel = alsa_buffer_size / alsa_buffers; + + if (!alsa_set_playback_parameters()) + { + /* somehow we got a device that passed muster with alsa_probe_device_name, but doesn't return hw params! */ + alsa_playback_device_name = "plughw:0"; + if (!alsa_set_playback_parameters()) + { + alsa_playback_device_name = "hw:0"; + if (!alsa_set_playback_parameters()) + return(MUS_ERROR); + } + } + + if (!alsa_set_capture_parameters()) + { + alsa_capture_device_name = "plughw:0"; + if (!alsa_set_capture_parameters()) + { + alsa_capture_device_name = "hw:0"; + if (!alsa_set_capture_parameters()) + return(MUS_ERROR); + } + } + + if ((!alsa_hw_params[SND_PCM_STREAM_CAPTURE]) || + (!alsa_hw_params[SND_PCM_STREAM_PLAYBACK])) + return(MUS_ERROR); + + audio_initialized = true; + return(0); +} + +/* open an input or output stream */ + +static int alsa_audio_open(int ur_dev, int srate, int chans, int format, int size) +{ + int card, device, alsa_device; + snd_pcm_format_t alsa_format; + snd_pcm_stream_t alsa_stream; + char *alsa_name; + int frames, periods; + int err; + unsigned int r; + snd_pcm_t *handle; + snd_pcm_hw_params_t *hw_params = NULL; + snd_pcm_sw_params_t *sw_params = NULL; + + if ((!audio_initialized) && + (mus_audio_initialize() != MUS_NO_ERROR)) + return(MUS_ERROR); + if (chans <= 0) return(MUS_ERROR); + + if (alsa_trace) + mus_print("%s: %x rate=%d, chans=%d, format=%d:%s, size=%d", + c__FUNCTION__, ur_dev, srate, chans, format, + mus_audio_format_name(format), size); + + card = MUS_AUDIO_SYSTEM(ur_dev); + device = MUS_AUDIO_DEVICE(ur_dev); + + if ((err = to_alsa_device(device, &alsa_device, &alsa_stream)) < 0) + { + return(alsa_mus_error(MUS_AUDIO_DEVICE_NOT_AVAILABLE, + mus_format("%s: cannot translate device %s<%d> to alsa", + snd_strerror(err), mus_audio_device_name(device), device))); + } + if ((alsa_format = to_alsa_format(format)) == (snd_pcm_format_t)MUS_ERROR) + { + return(alsa_mus_error(MUS_AUDIO_FORMAT_NOT_AVAILABLE, + mus_format("could not change %s<%d> to alsa format", + mus_audio_format_name(format), format))); + } + + alsa_name = (alsa_stream == SND_PCM_STREAM_PLAYBACK) ? alsa_playback_device_name : alsa_capture_device_name; + if ((err = snd_pcm_open(&handle, alsa_name, alsa_stream, alsa_open_mode)) != 0) + { + snd_pcm_close(handle); + return(alsa_mus_error(MUS_AUDIO_CANT_OPEN, + mus_format("open pcm %s (%s) stream %s: %s", + mus_audio_device_name(device), alsa_name, snd_pcm_stream_name(alsa_stream), + snd_strerror(err)))); + } + handles[alsa_stream] = handle; + hw_params = alsa_hw_params[alsa_stream]; + sw_params = alsa_sw_params[alsa_stream]; + if ((err = snd_pcm_hw_params_any(handle, hw_params)) < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: no parameter configurations available for %s", + snd_strerror(err), alsa_name))); + } + + err = snd_pcm_hw_params_set_access(handle, hw_params, alsa_interleave); + if (err < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: access type %s not available", + snd_strerror(err), alsa_name, snd_pcm_access_name(alsa_interleave)))); + } + + periods = alsa_buffers; + err = snd_pcm_hw_params_set_periods(handle, hw_params, periods, 0); + if (err < 0) + { + unsigned int minp, maxp; + int dir; +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_periods_min(hw_params, &minp, &dir); + snd_pcm_hw_params_get_periods_max(hw_params, &maxp, &dir); +#else + minp = snd_pcm_hw_params_get_periods_min(hw_params, &dir); + maxp = snd_pcm_hw_params_get_periods_max(hw_params, &dir); +#endif + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: cannot set number of periods to %d, min is %d, max is %d", + snd_strerror(err), alsa_name, periods, (int)minp, (int)maxp))); + } + + frames = size / chans / mus_bytes_per_sample(format); + + err = snd_pcm_hw_params_set_buffer_size(handle, hw_params, frames * periods); + if (err < 0) + { + snd_pcm_uframes_t minp, maxp; +#if HAVE_NEW_ALSA + snd_pcm_hw_params_get_buffer_size_min(hw_params, &minp); + snd_pcm_hw_params_get_buffer_size_max(hw_params, &maxp); +#else + minp = snd_pcm_hw_params_get_buffer_size_min(hw_params); + maxp = snd_pcm_hw_params_get_buffer_size_max(hw_params); +#endif + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: cannot set buffer size to %d periods of %d frames; \ +total requested buffer size is %d frames, minimum allowed is %d, maximum is %d", + snd_strerror(err), alsa_name, periods, frames, periods * frames, (int)minp, (int)maxp))); + } + + err = snd_pcm_hw_params_set_format(handle, hw_params, alsa_format); + if (err < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: cannot set format to %s", + snd_strerror(err), alsa_name, snd_pcm_format_name(alsa_format)))); + } + + err = snd_pcm_hw_params_set_channels(handle, hw_params, chans); + if (err < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: cannot set channels to %d", + snd_strerror(err), alsa_name, chans))); + } +#if HAVE_NEW_ALSA + { + unsigned int new_rate; + new_rate = srate; + r = snd_pcm_hw_params_set_rate_near(handle, hw_params, &new_rate, 0); + if (r < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: cannot set sampling rate near %d", + snd_strerror(r), alsa_name, srate))); + } + else + { + if ((new_rate != srate) && (!alsa_squelch_warning)) + { + mus_print("%s: could not set rate to exactly %d, set to %d instead", + alsa_name, srate, new_rate); + } + } + } +#else + r = snd_pcm_hw_params_set_rate_near(handle, hw_params, srate, 0); + if (r < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: %s: cannot set sampling rate near %d", + snd_strerror(r), alsa_name, srate))); + } + else + { + if (r != srate) + { + mus_print("%s: could not set rate to exactly %d, set to %d instead", + alsa_name, srate, r); + } + } +#endif + + err = snd_pcm_hw_params(handle, hw_params); + if (err < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: cannot set hardware parameters for %s", + snd_strerror(err), alsa_name))); + } + + snd_pcm_sw_params_current(handle, sw_params); + err = snd_pcm_sw_params(handle, sw_params); + if (err < 0) + { + snd_pcm_close(handle); + handles[alsa_stream] = NULL; + alsa_dump_configuration(alsa_name, hw_params, sw_params); + return(alsa_mus_error(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("%s: cannot set software parameters for %s", + snd_strerror(err), alsa_name))); + } + + /* for now the id for the stream is the direction identifier, that is + not a problem because we only advertise one card with two devices */ + return(alsa_stream); +} + +/* sndlib support for opening output devices */ + +static int alsa_mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + return(alsa_audio_open(ur_dev, srate, chans, format, size)); +} + +/* sndlib support for opening input devices */ + +static int alsa_mus_audio_open_input(int ur_dev, int srate, int chans, int format, int size) +{ + return(alsa_audio_open(ur_dev, srate, chans, format, size)); +} + +/* sndlib support for closing a device */ + +/* to force it to stop, snd_pcm_drop */ + +static bool xrun_warned = false; + +static int alsa_mus_audio_close(int id) +{ + int err = 0; + xrun_warned = false; + if (alsa_trace) mus_print( "%s: %d", c__FUNCTION__, id); + if (handles[id]) + { + err = snd_pcm_drain(handles[id]); + if (err != 0) + mus_print("snd_pcm_drain: %s", snd_strerror(err)); + + err = snd_pcm_close(handles[id]); + if (err != 0) + return(alsa_mus_error(MUS_AUDIO_CANT_CLOSE, + mus_format("snd_pcm_close: %s", + snd_strerror(err)))); + handles[id] = NULL; + } + return(MUS_NO_ERROR); +} + +/* recover from underruns or overruns */ + +static int recover_from_xrun(int id) +{ + int err; + snd_pcm_status_t *status; + snd_pcm_state_t state; + snd_pcm_status_alloca(&status); + err = snd_pcm_status(handles[id], status); + if (err < 0) + { + mus_print("%s: snd_pcm_status: %s", c__FUNCTION__, snd_strerror(err)); + return(MUS_ERROR); + } + state = snd_pcm_status_get_state(status); + if (state == SND_PCM_STATE_XRUN) + { + if (!xrun_warned) + { + xrun_warned = true; + mus_print("[under|over]run detected"); + } + err = snd_pcm_prepare(handles[id]); + if (err < 0) + mus_print("snd_pcm_prepare: %s", snd_strerror(err)); + else return(MUS_NO_ERROR); + } + else mus_print("%s: error, current state is %s", c__FUNCTION__, snd_pcm_state_name(state)); + return(MUS_ERROR); +} + +/* sndlib support for writing a buffer to an output device */ + +static int alsa_mus_audio_write(int id, char *buf, int bytes) +{ + snd_pcm_sframes_t status; + ssize_t frames; + frames = snd_pcm_bytes_to_frames(handles[id], bytes); +#if MUS_DEBUGGING + if ((frames <= 0) || (frames > bytes)) + { + /* pcm->frame_bits not correct? */ + mus_print("audio write %d frames (%d bytes)?", bytes, frames); + abort(); + return(MUS_ERROR); + } +#endif + status = snd_pcm_writei(handles[id], buf, frames); + if ((status == -EAGAIN) || + ((status >= 0) && (status < frames))) + snd_pcm_wait(handles[id], 1000); + else + { + if (status == -EPIPE) + return(recover_from_xrun(id)); + else + { + if (status < 0) + { + mus_print("snd_pcm_writei: %s", snd_strerror(status)); + return(MUS_ERROR); + } + } + } + return(MUS_NO_ERROR); +} + +/* sndlib support for reading a buffer from an input device */ + +static int alsa_mus_audio_read(int id, char *buf, int bytes) +{ + snd_pcm_sframes_t status; + ssize_t frames; + frames = snd_pcm_bytes_to_frames(handles[id], bytes); +#if MUS_DEBUGGING + if ((frames <= 0) || (frames > bytes)) + { + mus_print("audio read %d frames (%d bytes)?", frames, bytes); + abort(); + return(MUS_ERROR); + } +#endif + status = snd_pcm_readi(handles[id], buf, frames); + if ((status == -EAGAIN) || + ((status >= 0) && (status < frames))) + snd_pcm_wait(handles[id], 1000); + else + { + if (status == -EPIPE) + return(recover_from_xrun(id)); + else + { + if (status < 0) + { + mus_print("snd_pcm_readi: %s", snd_strerror(status)); + return(MUS_ERROR); + } + } + } + return(MUS_NO_ERROR); +} + +/* read state of the audio hardware */ + +static int alsa_mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + int card; + int device; + int alsa_device; + snd_pcm_stream_t alsa_stream; + int f, err; + + if ((!audio_initialized) && + (mus_audio_initialize() != MUS_NO_ERROR)) + return(MUS_ERROR); + + card = MUS_AUDIO_SYSTEM(ur_dev); + device = MUS_AUDIO_DEVICE(ur_dev); + if (alsa_trace) + mus_print( "%s: card=%d, dev=%s<%d>, field=%s<%d>, chan=%d", + c__FUNCTION__, card, mus_audio_device_name(device), device, + mus_audio_device_name(field), field, + chan); + /* for now do not implement mixer interface */ + if (device == MUS_AUDIO_MIXER) + { + val[0] = 0; + return(MUS_NO_ERROR); + } + /* MUS_AUDIO_PORT probes for devices and should not depend on the + * device which was used in the ur_dev argument, we process this + * before trying to map the device to an alsa device */ + + if (field == MUS_AUDIO_PORT) + { + /* under 0.9 we only advertise at most two devices, one for playback + and another one for capture */ + /* int dev; */ + int i = 1; + if (alsa_hw_params[SND_PCM_STREAM_PLAYBACK]) + val[i++] = (float)to_sndlib_device(0, SND_PCM_STREAM_PLAYBACK); + + if (alsa_hw_params[SND_PCM_STREAM_CAPTURE]) + val[i++] = (float)to_sndlib_device(0, SND_PCM_STREAM_CAPTURE); + + val[0]=(float)(i - 1); + return(MUS_NO_ERROR); + } + /* map the mus device to an alsa device and channel */ + if ((err = to_alsa_device(device, &alsa_device, &alsa_stream)) < 0) + { + /* FIXME: snd-dac still probes some non-existing devices, specifically + * MUS_AUDIO_DAC_FILTER, do not report error till that's fixed */ + if (alsa_trace) + { + mus_print("%s: cannot translate device %s<%d> to alsa, field=%s<%d>", + snd_strerror(err), + mus_audio_device_name(device), device, + mus_audio_device_name(field), field); + } + return(MUS_ERROR); + } + if (alsa_trace) mus_print("%s: adev=%d, achan=%d", c__FUNCTION__, alsa_device, alsa_stream); + switch (field) + { + case MUS_AUDIO_AMP: + /* amplitude value */ + val[0] = 1.0; + break; + case MUS_AUDIO_SAMPLES_PER_CHANNEL: + /* samples per channel */ + if (card > 0 || alsa_device > 0) + return(alsa_mus_error(MUS_AUDIO_CANT_READ, NULL)); + else + { + val[0] = (float)alsa_samples_per_channel; + if (chan > 1) + { +#if HAVE_NEW_ALSA + snd_pcm_uframes_t tmp = 0; + snd_pcm_hw_params_get_buffer_size_min(alsa_hw_params[alsa_stream], &tmp); + val[1] = (float)tmp; + snd_pcm_hw_params_get_buffer_size_max(alsa_hw_params[alsa_stream], &tmp); + val[2] = (float)tmp; +#else + val[1] = (float)snd_pcm_hw_params_get_buffer_size_min(alsa_hw_params[alsa_stream]); + val[2] = (float)snd_pcm_hw_params_get_buffer_size_max(alsa_hw_params[alsa_stream]); +#endif + } + } + break; + case MUS_AUDIO_CHANNEL: + /* number of channels */ + if (card > 0 || alsa_device > 0) + return(alsa_mus_error(MUS_AUDIO_CANT_READ, NULL)); + else + { + + if ((alsa_stream == SND_PCM_STREAM_CAPTURE) && + (alsa_capture_device_name) && + (strcmp(alsa_capture_device_name, "default") == 0)) + { + val[0] = 2; + } + else + { + +#if HAVE_NEW_ALSA + unsigned int max_channels = 0; + snd_pcm_hw_params_get_channels_max(alsa_hw_params[alsa_stream], &max_channels); +#else + int max_channels = snd_pcm_hw_params_get_channels_max(alsa_hw_params[alsa_stream]); +#endif + if ((alsa_stream == SND_PCM_STREAM_CAPTURE) && + (max_channels > alsa_max_capture_channels)) + { + /* limit number of capture channels to a reasonable maximum, if the user + specifies a plug pcm as the capture pcm then the returned number of channels + would be MAXINT (or whatever the name is for a really big number). At this + point there is no support in the alsa api to distinguish between default + parameters or those that have been set by a user on purpose, of for querying + the hardware pcm device that is hidden by the plug device to see what is the + real number of channels for the device we are dealing with. We could also try + to flag this as an error to the user and exit the program */ + max_channels = alsa_max_capture_channels; + } + val[0] = (float)max_channels; + if (chan > 1) + { +#if HAVE_NEW_ALSA + unsigned int tmp = 0; + snd_pcm_hw_params_get_channels_min(alsa_hw_params[alsa_stream], &tmp); + val[1] = (float)tmp; +#else + val[1] = (float)snd_pcm_hw_params_get_channels_min(alsa_hw_params[alsa_stream]); +#endif + val[2] = (float)max_channels; + } + } + } + break; + case MUS_AUDIO_SRATE: + /* supported sample rates */ + if (card > 0 || alsa_device > 0) + return(alsa_mus_error(MUS_AUDIO_CANT_READ, NULL)); + else + { + int dir = 0; + val[0] = 44100; + if (chan > 1) + { +#if HAVE_NEW_ALSA + unsigned int tmp; + snd_pcm_hw_params_get_rate_min(alsa_hw_params[alsa_stream], &tmp, &dir); + val[1] = (float)tmp; + snd_pcm_hw_params_get_rate_max(alsa_hw_params[alsa_stream], &tmp, &dir); + val[2] = (float)tmp; +#else + val[1] = (float)snd_pcm_hw_params_get_rate_min(alsa_hw_params[alsa_stream], &dir); + val[2] = (float)snd_pcm_hw_params_get_rate_max(alsa_hw_params[alsa_stream], &dir); +#endif + } + } + break; + case MUS_AUDIO_FORMAT: + /* supported formats */ + if (card > 0 || alsa_device > 0) + return(alsa_mus_error(MUS_AUDIO_CANT_READ, NULL)); + else + { + int format; + snd_pcm_format_mask_t *mask; + snd_pcm_format_mask_alloca(&mask); + snd_pcm_hw_params_get_format_mask(alsa_hw_params[alsa_stream], mask); + for (format = 0, f = 1; format < SND_PCM_FORMAT_LAST; format++) + { + err = snd_pcm_format_mask_test(mask, (snd_pcm_format_t)format); + if (err > 0) + { + if ((f < chan) && + (to_mus_format(format)!=MUS_ERROR)) + val[f++] = (float)to_mus_format(format); + } + } + val[0] = f - 1; + } + break; + case MUS_AUDIO_DIRECTION: + /* direction of this device */ + if (card > 0 || alsa_device > 0) + return(alsa_mus_error(MUS_AUDIO_CANT_READ, NULL)); + else + { + /* 0-->playback, 1-->capture */ + val[0] = (float)alsa_stream; + } + break; + default: + return(alsa_mus_error(MUS_AUDIO_CANT_READ, NULL)); + break; + } + return(MUS_NO_ERROR); +} + +static int alsa_mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + return(MUS_NO_ERROR); +} + +static void alsa_describe_audio_state_1(void) +{ + int err; + char *str; + size_t len; + snd_config_t *conf; + snd_output_t *buf = NULL; +#if (SND_LIB_MAJOR == 0) || ((SND_LIB_MAJOR == 1) && (SND_LIB_MINOR == 0) && (SND_LIB_SUBMINOR < 8)) + return; /* avoid Alsa bug */ +#endif + err = snd_config_update(); + if (err < 0) + { + mus_print("snd_config_update: %s", snd_strerror(err)); + return; + } + err = snd_output_buffer_open(&buf); + if (err < 0) + mus_print("could not open dump buffer: %s", snd_strerror(err)); + else + { + err = snd_config_search(snd_config, "pcm", &conf); + if (err < 0) + { + mus_print("snd_config_search: could not find at least one pcm: %s", snd_strerror(err)); + return; + } + snd_output_puts(buf, "PCM list:\n"); + snd_config_save(conf, buf); + snd_output_putc(buf, '\0'); + len = snd_output_buffer_string(buf, &str); + if (len > 1) + pprint(str); + snd_output_close(buf); + } +} + +#endif /* HAVE_ALSA */ + + +/* -------------------------------- SUN -------------------------------- */ +/* + * Thanks to Seppo Ingalsuo for several bugfixes. + * record case improved after perusal of Snack 1.6/src/jkAudio_sun.c + */ + +/* apparently input other than 8000 is 16-bit, 8000 is (?) mulaw */ + +#if (defined(MUS_SUN) || defined(MUS_OPENBSD)) && (!(defined(AUDIO_OK))) +#define AUDIO_OK + +#include <sys/types.h> +#include <stropts.h> +#include <sys/filio.h> + +#ifdef SUNOS +#include <sun/audioio.h> +#else +#include <sys/audioio.h> +#endif +#if HAVE_SYS_MIXER_H +#include <sys/mixer.h> +#endif + +int mus_audio_initialize(void) {return(MUS_NO_ERROR);} +int mus_audio_systems(void) {return(1);} +char *mus_audio_system_name(int system) {return("Sun");} + +static int sun_default_outputs = (AUDIO_HEADPHONE | AUDIO_LINE_OUT | AUDIO_SPEAKER); + +void mus_sun_set_outputs(int speakers, int headphones, int line_out) +{ + sun_default_outputs = 0; + if (speakers) sun_default_outputs |= AUDIO_SPEAKER; + if (headphones) sun_default_outputs |= AUDIO_HEADPHONE; + if (line_out) sun_default_outputs |= AUDIO_LINE_OUT; +} + + +#ifdef MUS_OPENBSD + #define DAC_NAME "/dev/sound" +#else + #define DAC_NAME "/dev/audio" +#endif +#define AUDIODEV_ENV "AUDIODEV" + +#define RETURN_ERROR_EXIT(Error_Type, Audio_Line, Ur_Error_Message) \ + do { char *Error_Message; Error_Message = Ur_Error_Message; \ + if (Audio_Line != -1) close(Audio_Line); \ + if (Error_Message) \ + {MUS_STANDARD_ERROR(Error_Type, Error_Message); FREE(Error_Message);} \ + else MUS_STANDARD_ERROR(Error_Type, mus_error_type_to_string(Error_Type)); \ + return(MUS_ERROR); \ + } while (false) + +char *mus_audio_moniker(void) +{ +#ifndef AUDIO_DEV_AMD + struct audio_device ad; +#else + int ad; +#endif + int audio_fd, err; + char *dev_name; + if (getenv(AUDIODEV_ENV) != NULL) + dev_name = getenv(AUDIODEV_ENV); + else dev_name = DAC_NAME; + audio_fd = open(dev_name, O_RDONLY | O_NONBLOCK, 0); + if (audio_fd == -1) + { + audio_fd = open("/dev/audioctl", O_RDONLY | O_NONBLOCK, 0); + if (audio_fd == -1) return("sun probably"); + } + err = ioctl(audio_fd, AUDIO_GETDEV, &ad); + if (err == -1) + { + close(audio_fd); + return("sun?"); + } + mus_audio_close(audio_fd); +#if HAVE_SYS_MIXER_H + if (version_name == NULL) version_name = (char *)CALLOC(PRINT_BUFFER_SIZE, sizeof(char)); +#else + if (version_name == NULL) version_name = (char *)CALLOC(LABEL_BUFFER_SIZE, sizeof(char)); +#endif +#ifndef AUDIO_DEV_AMD + #if HAVE_SYS_MIXER_H + mus_snprintf(version_name, PRINT_BUFFER_SIZE, + "audio: %s (%s), %s %s %s", + ad.name, ad.version, + MIXER_NAME, MIXER_VERSION, MIXER_CONFIGURATION); + #else + mus_snprintf(version_name, LABEL_BUFFER_SIZE, "audio: %s (%s)", ad.name, ad.version); + #endif +#else + switch (ad) + { + case AUDIO_DEV_AMD: mus_snprintf(version_name, LABEL_BUFFER_SIZE, "audio: amd"); break; + #ifdef AUDIO_DEV_CS4231 + case AUDIO_DEV_CS4231: mus_snprintf(version_name, LABEL_BUFFER_SIZE, "audio: cs4231"); break; + #endif + case AUDIO_DEV_SPEAKERBOX: mus_snprintf(version_name, LABEL_BUFFER_SIZE, "audio: speakerbox"); break; + case AUDIO_DEV_CODEC: mus_snprintf(version_name, LABEL_BUFFER_SIZE, "audio: codec"); break; + default: mus_snprintf(version_name, LABEL_BUFFER_SIZE, "audio: unknown"); break; + } +#endif + return(version_name); +} + +static int to_sun_format(int format) +{ + switch (format) + { +#if MUS_LITTLE_ENDIAN + case MUS_LSHORT: /* Solaris on Intel? */ +#else + case MUS_BSHORT: +#endif +#ifdef MUS_OPENBSD + return(AUDIO_ENCODING_PCM16); +#else + return(AUDIO_ENCODING_LINEAR); +#endif + break; + case MUS_BYTE: +#if defined(AUDIO_ENCODING_LINEAR8) + return(AUDIO_ENCODING_LINEAR8); break; +#else + #ifdef MUS_OPENBSD + return(AUDIO_ENCODING_PCM8); + #else + return(AUDIO_ENCODING_LINEAR); + #endif + break; +#endif + case MUS_MULAW: return(AUDIO_ENCODING_ULAW); break; + case MUS_ALAW: return(AUDIO_ENCODING_ALAW); break; + /* there's also AUDIO_ENCODING_DVI */ + } + return(MUS_ERROR); +} + +int mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + struct audio_info info; + char *dev_name; + int encode, bits, dev; + int audio_fd, err; + dev = MUS_AUDIO_DEVICE(ur_dev); + encode = to_sun_format(format); + if (encode == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d (%s) not available", + format, + mus_data_format_name(format))); + if (getenv(AUDIODEV_ENV) != NULL) + dev_name = getenv(AUDIODEV_ENV); + else dev_name = DAC_NAME; + if (dev != MUS_AUDIO_DUPLEX_DEFAULT) + audio_fd = open(dev_name, O_WRONLY, 0); + else audio_fd = open(dev_name, O_RDWR, 0); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, -1, + mus_format("can't open output %s: %s", + dev_name, strerror(errno))); + AUDIO_INITINFO(&info); + if (dev == MUS_AUDIO_LINE_OUT) + info.play.port = AUDIO_LINE_OUT; + else + { + if (dev == MUS_AUDIO_SPEAKERS) + /* OR may not be available */ + info.play.port = AUDIO_SPEAKER | (sun_default_outputs & AUDIO_HEADPHONE); + else + info.play.port = sun_default_outputs; + } + info.play.sample_rate = srate; + info.play.channels = chans; + bits = 8 * mus_bytes_per_sample(format); + info.play.precision = bits; + info.play.encoding = encode; + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + { + ioctl(audio_fd, AUDIO_GETINFO, &info); + + if ((int)info.play.channels != chans) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("can't set output %s (%s) channels to %d", + mus_audio_device_name(dev), dev_name, chans)); + + if (((int)info.play.precision != bits) || + ((int)info.play.encoding != encode)) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_fd, + mus_format("can't set output %s (%s) format to %d bits, %d encode (%s)", + mus_audio_device_name(dev), dev_name, + bits, encode, + mus_data_format_name(format))); + + if ((int)info.play.sample_rate != srate) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("can't set output %s (%s) srate to %d", + mus_audio_device_name(dev), dev_name, srate)); + } + /* man audio sez the play.buffer_size field is not currently supported */ + /* but since the default buffer size is 8180! we need ioctl(audio_fd, I_SETSIG, ...) */ + ioctl(audio_fd, I_FLUSH, FLUSHR); + return(audio_fd); +} + +int mus_audio_write(int line, char *buf, int bytes) +{ + if (write(line, buf, bytes) != bytes) + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("write error: %s", strerror(errno))); + return(MUS_NO_ERROR); +} + +int mus_audio_close(int line) +{ + write(line, (char *)NULL, 0); + close(line); + return(MUS_NO_ERROR); +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + int total = 0; + char *curbuf; + /* ioctl(line, AUDIO_DRAIN, NULL) */ + /* this seems to return 8-12 bytes fewer than requested -- perverse! */ + /* should I buffer data internally? */ + + /* apparently we need to loop here ... */ + curbuf = buf; + while (total < bytes) + { + int bytes_available; + ioctl(line, FIONREAD, &bytes_available); + if (bytes_available > 0) + { + int bytes_read; + if ((total + bytes_available) > bytes) bytes_available = bytes - total; + bytes_read = read(line, curbuf, bytes_available); + if (bytes_read > 0) + { + total += bytes_read; + curbuf = (char *)(buf + total); + } + /* else return anyway?? */ + } + } + return(MUS_NO_ERROR); +} + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int size) +{ + struct audio_info info; + int indev, encode, bits, dev, audio_fd, err; + char *dev_name; + dev = MUS_AUDIO_DEVICE(ur_dev); + encode = to_sun_format(format); + bits = 8 * mus_bytes_per_sample(format); + if (encode == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d bits, %d encode (%s) not available", + bits, encode, + mus_data_format_name(format))); + if (getenv(AUDIODEV_ENV) != NULL) + dev_name = getenv(AUDIODEV_ENV); + else dev_name = DAC_NAME; + if (dev != MUS_AUDIO_DUPLEX_DEFAULT) + audio_fd = open(dev_name, O_RDONLY, 0); + else audio_fd = open(dev_name, O_RDWR, 0); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, -1, + mus_format("can't open input %s: %s", + dev_name, strerror(errno))); + AUDIO_INITINFO(&info); + /* ioctl(audio_fd, AUDIO_GETINFO, &info); */ + info.record.sample_rate = srate; + info.record.channels = chans; + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, audio_fd, + mus_format("can't set srate %d and chans %d for input %s (%s)", + srate, chans, + dev_name, + mus_audio_device_name(dev))); + ioctl(audio_fd, AUDIO_GETINFO, &info); + if (info.record.sample_rate != (unsigned int)srate) + mus_print("%s[%d]: sampling rate: %d != %d\n", + __FILE__, __LINE__, + info.record.sample_rate, srate); + if (info.record.channels != (unsigned int)chans) + mus_print("%s[%d]: channels: %d != %d\n", + __FILE__, __LINE__, + info.record.channels, chans); + + info.record.precision = bits; /* was play, changed 10-Jul-03 thanks to Jürgen Keil */ + info.record.encoding = encode; + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, audio_fd, + mus_format("can't set bits %d, encode %d (format %s) for input %s (%s)", + bits, encode, mus_data_format_name(format), + dev_name, + mus_audio_device_name(dev))); + ioctl(audio_fd, AUDIO_GETINFO, &info); + + /* these cannot be OR'd */ + if (dev == MUS_AUDIO_LINE_IN) + indev = AUDIO_LINE_IN; + else + { + if (dev == MUS_AUDIO_CD) + indev = AUDIO_INTERNAL_CD_IN; + else indev = AUDIO_MICROPHONE; + } + info.record.port = indev; + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't set record.port to %d for %s (%s)", + indev, dev_name, + mus_audio_device_name(dev))); + err = ioctl(audio_fd, AUDIO_GETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't getinfo on input %s (%s, line: %d)", + dev_name, + mus_audio_device_name(dev), audio_fd)); + else + { + if ((int)info.record.port != indev) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, audio_fd, + mus_format("confusion in record.port: %d != %d (%s: %s)", + (int)info.record.port, indev, + dev_name, + mus_audio_device_name(dev))); + if ((int)info.record.channels != chans) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_fd, + mus_format("confusion in record.channels: %d != %d (%s: %s)", + (int)info.record.channels, chans, + dev_name, + mus_audio_device_name(dev))); + if (((int)info.record.precision != bits) || + ((int)info.record.encoding != encode)) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_fd, + mus_format("confusion in record.precision|encoding: %d != %d or %d != %d (%s: %s)", + (int)info.record.precision, bits, + (int)info.record.encoding, encode, + dev_name, + mus_audio_device_name(dev))); + } + /* this may be a bad idea */ + info.record.buffer_size = size; + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't set buffer size to %d on input %s (%s)", + size, + dev_name, + mus_audio_device_name(dev))); + return(audio_fd); +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ +#ifndef AUDIO_DEV_AMD + struct audio_device ad; +#else + int ad; +#endif + int audio_fd, err; + struct audio_info info; + int dev, port; + char *dev_name; + dev = MUS_AUDIO_DEVICE(ur_dev); + AUDIO_INITINFO(&info); + if (getenv(AUDIODEV_ENV) != NULL) + dev_name = getenv(AUDIODEV_ENV); + else dev_name = DAC_NAME; + audio_fd = open(dev_name, O_RDONLY | O_NONBLOCK, 0); + if (audio_fd == -1) + { + audio_fd = open("/dev/audioctl", O_RDONLY | O_NONBLOCK); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, + mus_format("can't open %s or /dev/audioctl: %s", + dev_name, strerror(errno))); + else dev_name = "/dev/audioctl"; + } + err = ioctl(audio_fd, AUDIO_GETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't get %s (%s) info", + dev_name, + mus_audio_device_name(dev))); + if (field == MUS_AUDIO_PORT) + { + /* info.play|record have a field avail_ports */ + port = 1; + if ((chan > port) && + (info.record.avail_ports & AUDIO_MICROPHONE)) + { + val[port] = MUS_AUDIO_MICROPHONE; + port++; + } + if ((chan > port) && + (info.record.avail_ports & AUDIO_LINE_IN)) + { + val[port] = MUS_AUDIO_LINE_IN; + port++; + } +#ifndef AUDIO_DEV_AMD + if ((chan > port) && + (info.record.avail_ports & AUDIO_INTERNAL_CD_IN)) + { + /* this field lies -- there is no such port available on the Ultra */ + err = ioctl(audio_fd, AUDIO_GETDEV, &ad); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't get device info on %s (%s)", + dev_name, + mus_audio_device_name(dev))); + if (((ad.version) && (strcmp(ad.version, "a") == 0)) || /* is it a SparcStation? */ + ((ad.name) && (strcmp(ad.name, "SUNW,CS4231") == 0))) + { + val[port] = MUS_AUDIO_CD; + port++; + } + } +#endif + if ((chan > port) && + (info.play.avail_ports & AUDIO_SPEAKER)) + { + val[port] = MUS_AUDIO_SPEAKERS; + port++; + } + if ((chan > port) && + (info.play.avail_ports & AUDIO_LINE_OUT)) + { + val[port] = MUS_AUDIO_LINE_OUT; + port++; + } + if ((chan > port) && + (info.play.avail_ports & AUDIO_HEADPHONE)) + { + val[port] = MUS_AUDIO_DAC_OUT; + port++; + } + val[0] = port - 1; + } + else + { + if (field == MUS_AUDIO_FORMAT) /* this actually depends on the audio device */ + { + err = ioctl(audio_fd, AUDIO_GETDEV, &ad); /* SUNW, dbri|am79c30|CS4231|sbpro|sb16 */ + /* Jurgen Keil's drivers use SUNW,CS4231, but the "real" names are: + "TOOLS,sbpci" SoundBlaster PCI card + "TOOLS,EMU10Kx" SoundBlaster Live! or Audigy + "TOOLS,i810" Intel i8xx audio (and compatible) + "TOOLS,via686" VIA 686 audio + "TOOLS,via8233" VIA 8233 (and compatible) + */ + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't get data format info for %s (%s)", + dev_name, + mus_audio_device_name(dev))); + port = 1; + if ((ad.name) && + (strcmp(ad.name, "SUNW,audio810") == 0)) + { + val[0] = 1; + val[1] = MUS_MULAW; + } + else + { +#ifndef AUDIO_DEV_AMD + if ((ad.name) && + (strcmp(ad.name, "SUNW, am79c30") != 0)) +#else + if (ad == AUDIO_DEV_AMD) +#endif + { + if (chan > port) val[port++] = MUS_BSHORT; + } +#ifndef AUDIO_DEV_AMD + if ((ad.name) && + (strcmp(ad.name, "SUNW, sbpro") != 0) && + (strcmp(ad.name, "SUNW, sb16") != 0)) + { + if (chan > port) val[port++] = MUS_ALAW; + } +#endif + if (chan > port) val[port++] = MUS_MULAW; +#if MUS_LITTLE_ENDIAN + if (chan > port) val[port++] = MUS_LSHORT; +#endif + val[0] = port - 1; + } + } + else + { + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_AMP: + /* who knows how this really works? documentation is incomplete, actual behavior seems to be: */ + if (chan == 0) + { + if (info.play.balance <= (AUDIO_RIGHT_BALANCE / 2)) + val[0] = info.play.gain / (float)(AUDIO_MAX_GAIN); + else val[0] = info.play.gain * (AUDIO_RIGHT_BALANCE - info.play.balance) / (float)(AUDIO_MAX_GAIN * (AUDIO_RIGHT_BALANCE / 2)); + } + else + { + if (info.play.balance >= (AUDIO_RIGHT_BALANCE / 2)) + val[0] = info.play.gain / (float)(AUDIO_MAX_GAIN); + else val[0] = info.play.gain * info.play.balance / (float)(AUDIO_MAX_GAIN * (AUDIO_RIGHT_BALANCE / 2)); + } + break; + case MUS_AUDIO_CHANNEL: + val[0] = 2; + break; + /* appears to depend on data format (mulaw is mono) */ + case MUS_AUDIO_SRATE: + val[0] = (float)info.play.sample_rate; + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't read %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + break; + case MUS_AUDIO_MICROPHONE: + case MUS_AUDIO_LINE_IN: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_CD: + switch (field) + { + case MUS_AUDIO_AMP: + if (chan == 0) + { + if (info.record.balance <= (AUDIO_RIGHT_BALANCE / 2)) + val[0] = info.record.gain / (float)(AUDIO_MAX_GAIN); + else val[0] = info.record.gain * (AUDIO_RIGHT_BALANCE - info.record.balance) / (float)(AUDIO_MAX_GAIN * (AUDIO_RIGHT_BALANCE / 2)); + } + else + { + if (info.record.balance >= (AUDIO_RIGHT_BALANCE / 2)) + val[0] = info.record.gain / (float)(AUDIO_MAX_GAIN); + else val[0] = info.record.gain * info.record.balance / (float)(AUDIO_MAX_GAIN * (AUDIO_RIGHT_BALANCE / 2)); + } + break; + + case MUS_AUDIO_CHANNEL: + val[0] = 1; + break; + case MUS_AUDIO_SRATE: + val[0] = (float)(info.record.sample_rate); + break; + case MUS_AUDIO_IGAIN: + val[0] = (float)(info.monitor_gain) / (float)AUDIO_MAX_GAIN; + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't read %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't read %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + } + } + return(mus_audio_close(audio_fd)); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + struct audio_info info; + int dev, balance, gain; + float ratio, lc, rc; + int audio_fd, err; + char *dev_name; + dev = MUS_AUDIO_DEVICE(ur_dev); + AUDIO_INITINFO(&info); + if (getenv(AUDIODEV_ENV) != NULL) + dev_name = getenv(AUDIODEV_ENV); + else dev_name = DAC_NAME; + audio_fd = open(dev_name, O_RDWR | O_NONBLOCK, 0); + if (audio_fd == -1) + { + audio_fd = open("/dev/audioctl", O_RDWR | O_NONBLOCK); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, -1, + mus_format("can't write fields of %s (or /dev/audioctl) (%s): %s", + dev_name, + mus_audio_device_name(dev), + strerror(errno))); + else dev_name = "/dev/audioctl"; + } + err = ioctl(audio_fd, AUDIO_GETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't get %s (%s) info", + dev_name, + mus_audio_device_name(dev))); + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_AMP: + balance = info.play.balance; + gain = info.play.gain; + if (balance <= (AUDIO_RIGHT_BALANCE / 2)) + { + lc = gain; + rc = gain * balance / (float)(AUDIO_RIGHT_BALANCE / 2); + } + else + { + lc = gain * (AUDIO_RIGHT_BALANCE - balance) / (float)(AUDIO_RIGHT_BALANCE / 2); + rc = gain; + } + if (chan == 0) + lc = AUDIO_MAX_GAIN * val[0]; + else rc = AUDIO_MAX_GAIN * val[0]; + if ((rc + lc) == 0) + info.play.gain = 0; + else + { + ratio = (float)rc / (float)(rc + lc); + info.play.balance = (unsigned char)(AUDIO_RIGHT_BALANCE * ratio); + if (rc > lc) + info.play.gain = (int)rc; + else info.play.gain = (int)lc; + } + break; + case MUS_AUDIO_CHANNEL: + info.play.channels = (int)val[0]; + break; + /* amd device only mono */ + case MUS_AUDIO_SRATE: + info.play.sample_rate = (int)val[0]; + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't write %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + break; + case MUS_AUDIO_MICROPHONE: + switch (field) + { + case MUS_AUDIO_AMP: + info.record.gain = (int)(AUDIO_MAX_GAIN * val[0]); + info.record.balance = 0; + break; + case MUS_AUDIO_CHANNEL: + info.record.channels = (int)val[0]; + break; + case MUS_AUDIO_SRATE: + info.record.sample_rate = (int)val[0]; + break; + case MUS_AUDIO_IGAIN: + info.monitor_gain = (int)(AUDIO_MAX_GAIN * val[0]); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't write %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + break; + case MUS_AUDIO_LINE_IN: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_CD: + switch (field) + { + case MUS_AUDIO_AMP: + balance = info.record.balance; + gain = info.record.gain; + lc = gain * (float)(AUDIO_RIGHT_BALANCE - balance) / (float)AUDIO_RIGHT_BALANCE; + rc = gain - lc; + if (chan == 0) + lc = AUDIO_MAX_GAIN * val[0]; + else rc = AUDIO_MAX_GAIN * val[0]; + gain = (int)(rc + lc); + if (gain == 0) + info.record.gain = 0; + else + { + info.record.balance = (unsigned char)(AUDIO_RIGHT_BALANCE * ((float)rc / (float)(rc + lc))); + if (rc > lc) + info.record.gain = (int)rc; + else info.record.gain = (int)lc; + } + break; + case MUS_AUDIO_CHANNEL: + info.record.channels = (int)val[0]; + break; + case MUS_AUDIO_SRATE: + info.record.sample_rate = (int)val[0]; + break; + case MUS_AUDIO_IGAIN: + info.monitor_gain = (int)(AUDIO_MAX_GAIN * val[0]); + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't write %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + break; + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't write %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + break; + } + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't write %s field %d (%s) after explicit set", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + return(mus_audio_close(audio_fd)); +} + +/* pause can be implemented with play.pause and record.pause */ + +static char *sun_format_name(int format) +{ + switch (format) + { +#ifdef AUDIO_ENCODING_ALAW + case AUDIO_ENCODING_ALAW: return("alaw"); break; +#endif +#ifdef AUDIO_ENCODING_ULAW + case AUDIO_ENCODING_ULAW: return("ulaw"); break; +#endif +#ifdef AUDIO_ENCODING_DVI + case AUDIO_ENCODING_DVI: return("dvi adpcm"); break; +#endif +#ifdef AUDIO_ENCODING_LINEAR8 + case AUDIO_ENCODING_LINEAR8: return("linear"); break; +#else + #ifdef AUDIO_ENCODING_PCM8 + case AUDIO_ENCODING_PCM8: return("linear"); break; + #endif +#endif +#ifdef AUDIO_ENCODING_LINEAR + case AUDIO_ENCODING_LINEAR: return("linear"); break; +#else + #ifdef AUDIO_ENCODING_PCM16 + case AUDIO_ENCODING_PCM16: return("linear"); break; + #endif +#endif +#ifdef AUDIO_ENCODING_NONE + case AUDIO_ENCODING_NONE: return("not audio"); break; /* dbri interface configured for something else */ +#endif + } + return("unknown"); +} + +static char *sun_in_device_name(int dev) +{ + if (dev == AUDIO_MICROPHONE) return("microphone"); + if (dev == AUDIO_LINE_IN) return("line in"); + if (dev == AUDIO_INTERNAL_CD_IN) return("cd"); + if (dev == (AUDIO_MICROPHONE | AUDIO_LINE_IN)) return("microphone + line in"); + if (dev == (AUDIO_MICROPHONE | AUDIO_LINE_IN | AUDIO_INTERNAL_CD_IN)) return("microphone + line in + cd"); + if (dev == (AUDIO_MICROPHONE | AUDIO_INTERNAL_CD_IN)) return("microphone + cd"); + if (dev == (AUDIO_LINE_IN | AUDIO_INTERNAL_CD_IN)) return("line in + cd"); + return("unknown"); +} + +static char *sun_out_device_name(int dev) +{ + if (dev == AUDIO_SPEAKER) return("speakers"); + if (dev == AUDIO_LINE_OUT) return("line out"); + if (dev == AUDIO_HEADPHONE) return("headphones"); + if (dev == (AUDIO_SPEAKER | AUDIO_LINE_OUT)) return("speakers + line out"); + if (dev == (AUDIO_SPEAKER | AUDIO_LINE_OUT | AUDIO_HEADPHONE)) return("speakers + line out + headphones"); + if (dev == (AUDIO_SPEAKER | AUDIO_HEADPHONE)) return("speakers + headphones"); + if (dev == (AUDIO_LINE_OUT | AUDIO_HEADPHONE)) return("line out + headphones"); + return("unknown"); +} + +static char *sun_vol_name = NULL; +static char *sun_volume_name(float vol, int balance, int chans) +{ + if (sun_vol_name == NULL) sun_vol_name = (char *)CALLOC(LABEL_BUFFER_SIZE, sizeof(char)); + if (chans != 2) + mus_snprintf(sun_vol_name, LABEL_BUFFER_SIZE, "%.3f", vol); + else + { + mus_snprintf(sun_vol_name, LABEL_BUFFER_SIZE, "%.3f %.3f", + vol * (float)(AUDIO_RIGHT_BALANCE - balance) / (float)AUDIO_RIGHT_BALANCE, + vol * (float)balance / (float)AUDIO_RIGHT_BALANCE); + } + return(sun_vol_name); +} + +static void describe_audio_state_1(void) +{ + struct audio_info info; +#ifndef AUDIO_DEV_AMD + struct audio_device ad; +#else + int ad; +#endif + int audio_fd, err; + char *dev_name; + AUDIO_INITINFO(&info); + if (getenv(AUDIODEV_ENV) != NULL) + dev_name = getenv(AUDIODEV_ENV); + else dev_name = DAC_NAME; + audio_fd = open(dev_name, O_RDONLY | O_NONBLOCK, 0); + if (audio_fd == -1) + audio_fd = open("/dev/audioctl", O_RDONLY | O_NONBLOCK, 0); + if (audio_fd == -1) return; + err = ioctl(audio_fd, AUDIO_GETINFO, &info); + if (err == -1) return; + err = ioctl(audio_fd, AUDIO_GETDEV, &ad); + if (err == -1) return; + pprint(mus_audio_moniker()); + pprint("\n"); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "output: %s\n srate: %d, vol: %s, chans: %d, format %d-bit %s\n", + sun_out_device_name(info.play.port), + info.play.sample_rate, + sun_volume_name((float)info.play.gain / (float)AUDIO_MAX_GAIN, info.play.balance, 2), + info.play.channels, + info.play.precision, + sun_format_name(info.play.encoding)); + pprint(audio_strbuf); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "input: %s\n srate: %d, vol: %s, chans: %d, format %d-bit %s\n", + sun_in_device_name(info.record.port), + info.record.sample_rate, + sun_volume_name((float)info.record.gain / (float)AUDIO_MAX_GAIN, info.record.balance, 2), + info.record.channels, + info.record.precision, + sun_format_name(info.record.encoding)); + pprint(audio_strbuf); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "input->output vol: %.3f\n", (float)info.monitor_gain / (float)AUDIO_MAX_GAIN); + pprint(audio_strbuf); + if (info.play.pause) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "Playback is paused\n"); pprint(audio_strbuf);} + if (info.record.pause) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "Recording is paused\n"); pprint(audio_strbuf);} + if (info.output_muted) {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "Output is muted\n"); pprint(audio_strbuf);} +#ifdef AUDIO_HWFEATURE_DUPLEX + if (info.hw_features == AUDIO_HWFEATURE_DUPLEX) + {mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "Simultaneous play and record supported\n"); pprint(audio_strbuf);} +#endif +#if HAVE_SYS_MIXER_H + { + int i, num = 0, choice; + #define LARGE_NUMBER 100 + am_sample_rates_t *sr = NULL; + for (choice = 0; choice < 2; choice++) + { + for (num = 4; num < LARGE_NUMBER; num += 2) + { + sr = (am_sample_rates_t *) + malloc(AUDIO_MIXER_SAMP_RATES_STRUCT_SIZE(num)); + sr->num_samp_rates = num; + sr->type = (choice == 0) ? AUDIO_PLAY : AUDIO_RECORD; + err = ioctl(audio_fd, AUDIO_MIXER_GET_SAMPLE_RATES, sr); + if ((int)(sr->num_samp_rates) <= num) break; + free(sr); + sr = NULL; + } + if (sr) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s srates:", (choice == 0) ? "play" : "record"); + pprint(audio_strbuf); + if (sr->type == MIXER_SR_LIMITS) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %d to %d", sr->samp_rates[0], sr->samp_rates[sr->num_samp_rates - 1]); + pprint(audio_strbuf); + } + else + { + for (i = 0; i < (int)(sr->num_samp_rates); i++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %d", sr->samp_rates[i]); + pprint(audio_strbuf); + } + } + pprint("\n"); + } + free(sr); + sr = NULL; + } + } +#endif + mus_audio_close(audio_fd); +} + +#endif + + + +/* ------------------------------- WINDOZE ----------------------------------------- */ + +#if defined(MUS_WINDOZE) && (!(defined(__CYGWIN__))) +#define AUDIO_OK + +#include <windows.h> +#include <mmsystem.h> + +#define BUFFER_FILLED 1 +#define BUFFER_EMPTY 2 + +#define OUTPUT_LINE 1 +#define INPUT_LINE 2 + +#define SOUND_UNREADY 0 +#define SOUND_INITIALIZED 1 +#define SOUND_RUNNING 2 + +static int buffer_size = 1024; +static int db_state[2]; +static int sound_state = 0; +static int current_chans = 1; +static int current_datum_size = 2; +static int current_buf = 0; +WAVEHDR wh[2]; +HWAVEOUT fd; +HWAVEIN record_fd; +WAVEHDR rec_wh; +static int rec_state = SOUND_UNREADY; + +static MMRESULT win_in_err = 0, win_out_err = 0; +static char errstr[128], getstr[128]; + +static char *win_err_buf = NULL; +static mus_print_handler_t *old_handler; + +static void win_mus_print(char *msg) +{ + if ((win_in_err == 0) && (win_out_err == 0)) + (*old_handler)(msg); + else + { + if (win_in_err) + waveInGetErrorText(win_in_err, getstr, PRINT_BUFFER_SIZE); + else waveOutGetErrorText(win_out_err, getstr, PRINT_BUFFER_SIZE); + mus_snprintf(errstr, PRINT_BUFFER_SIZE, "%s [%s]", msg, getstr); + (*old_handler)(errstr); + } +} + +static void start_win_print(void) +{ + if (old_handler != win_mus_print) + old_handler = mus_print_set_handler(win_mus_print); +} + +static void end_win_print(void) +{ + if (old_handler == win_mus_print) + mus_print_set_handler(NULL); + else mus_print_set_handler(old_handler); +} + +#define RETURN_ERROR_EXIT(Error_Type, Ur_Error_Message) \ + do { char *Error_Message; Error_Message = Ur_Error_Message; \ + if (Error_Message) \ + {MUS_STANDARD_ERROR(Error_Type, Error_Message); FREE(Error_Message);} \ + else MUS_STANDARD_ERROR(Error_Type, mus_error_type_to_string(Error_Type)); \ + end_win_print(); \ + return(MUS_ERROR); \ + } while (false) + +int mus_audio_systems(void) +{ + /* this number is available -- see below (user mixer number as in linux)->mixerGetNumDevs */ + return(1); +} +char *mus_audio_system_name(int system) {return("Windoze");} + +DWORD CALLBACK next_buffer(HWAVEOUT w, UINT msg, DWORD user_data, DWORD p1, DWORD p2) +{ + if (msg == WOM_DONE) + { + db_state[current_buf] = BUFFER_EMPTY; + } + return(0); +} + +int mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + WAVEFORMATEX wf; + int dev; + start_win_print(); + dev = MUS_AUDIO_DEVICE(ur_dev); + wf.nChannels = chans; + current_chans = chans; + wf.wFormatTag = WAVE_FORMAT_PCM; + wf.cbSize = 0; + if (format == MUS_UBYTE) + { + wf.wBitsPerSample = 8; + current_datum_size = 1; + } + else + { + wf.wBitsPerSample = 16; + current_datum_size = 2; + } + wf.nSamplesPerSec = srate; + wf.nBlockAlign = chans * current_datum_size; + wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec; + win_out_err = waveOutOpen(&fd, WAVE_MAPPER, &wf, (DWORD)next_buffer, 0, CALLBACK_FUNCTION); /* 0 here = user_data above, other case = WAVE_FORMAT_QUERY */ + if (win_out_err) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, + mus_format("can't open %d (%s)", + dev, + mus_audio_device_name(dev))); + waveOutPause(fd); + if (size <= 0) + buffer_size = 1024; + else buffer_size = size; + wh[0].dwBufferLength = buffer_size * current_datum_size; + wh[0].dwFlags = 0; + wh[0].dwLoops = 0; + wh[0].lpData = (char *)CALLOC(wh[0].dwBufferLength, sizeof(char)); + if ((wh[0].lpData) == 0) + { + waveOutClose(fd); + RETURN_ERROR_EXIT(MUS_AUDIO_SIZE_NOT_AVAILABLE, + mus_format("can't allocate buffer size %d for output %d (%s)", + buffer_size, dev, + mus_audio_device_name(dev))); + } + win_out_err = waveOutPrepareHeader(fd, &(wh[0]), sizeof(WAVEHDR)); + if (win_out_err) + { + FREE(wh[0].lpData); + waveOutClose(fd); + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("can't setup output 'header' for %d (%s)", + dev, + mus_audio_device_name(dev))); + } + db_state[0] = BUFFER_EMPTY; + wh[1].dwBufferLength = buffer_size * current_datum_size; + wh[1].dwFlags = 0; + wh[1].dwLoops = 0; + wh[1].lpData = (char *)CALLOC(wh[0].dwBufferLength, sizeof(char)); + if ((wh[1].lpData) == 0) + { + FREE(wh[0].lpData); + waveOutClose(fd); + RETURN_ERROR_EXIT(MUS_AUDIO_SIZE_NOT_AVAILABLE, + mus_format("can't allocate buffer size %d for output %d (%s)", + buffer_size, dev, + mus_audio_device_name(dev))); + } + win_out_err = waveOutPrepareHeader(fd, &(wh[1]), sizeof(WAVEHDR)); + if (win_out_err) + { + waveOutUnprepareHeader(fd, &(wh[0]), sizeof(WAVEHDR)); + FREE(wh[0].lpData); + FREE(wh[1].lpData); + waveOutClose(fd); + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("can't setup output 'header' for %d (%s)", + dev, + mus_audio_device_name(dev))); + } + db_state[1] = BUFFER_EMPTY; + sound_state = SOUND_INITIALIZED; + current_buf = 0; + end_win_print(); + return(OUTPUT_LINE); +} + +static MMRESULT fill_buffer(int dbi, char *inbuf, int instart, int bytes) +{ + int i, j; + win_out_err = 0; + if (sound_state == SOUND_UNREADY) return(0); + for (i = instart, j = 0; j < bytes; j++, i++) + wh[dbi].lpData[j] = inbuf[i]; + wh[dbi].dwBufferLength = bytes; + db_state[dbi] = BUFFER_FILLED; + if ((sound_state == SOUND_INITIALIZED) && + (dbi == 1)) + { + sound_state = SOUND_RUNNING; + win_out_err = waveOutRestart(fd); + } + return(win_out_err); +} + +static void wait_for_empty_buffer(int buf) +{ + while (db_state[buf] != BUFFER_EMPTY) + { + Sleep(1); /* in millisecs, so even this may be too much if buf = 256 bytes */ + } +} + +int mus_audio_write(int line, char *buf, int bytes) +{ + int lim, leftover, start; + start_win_print(); + if (line != OUTPUT_LINE) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, + mus_format("write error: line %d != %d?", + line, OUTPUT_LINE)); + win_out_err = 0; + leftover = bytes; + start = 0; + if (sound_state == SOUND_UNREADY) + { + end_win_print(); + return(MUS_NO_ERROR); + } + while (leftover > 0) + { + lim = leftover; + if (lim > buffer_size) lim = buffer_size; + leftover -= lim; + wait_for_empty_buffer(current_buf); + win_out_err = fill_buffer(current_buf, buf, start, lim); + if (win_out_err) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, + mus_format("write error on %d", + line)); + win_out_err = waveOutWrite(fd, &wh[current_buf], sizeof(WAVEHDR)); + if (win_out_err) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, + mus_format("write error on %d", + line)); + start += lim; + current_buf++; + if (current_buf > 1) current_buf = 0; + } + return(MUS_NO_ERROR); +} + +static float unlog(unsigned short val) +{ + /* 1.0 linear is 0xffff, rest is said to be "logarithmic", whatever that really means here */ + if (val == 0) return(0.0); + return((float)val / 65536.0); + /* return(pow(2.0, amp) - 1.0); */ /* doc seems to be bogus */ +} + +#define SRATE_11025_BITS (WAVE_FORMAT_1S16 | WAVE_FORMAT_1S08 | WAVE_FORMAT_1M16 | WAVE_FORMAT_1M08) +#define SRATE_22050_BITS (WAVE_FORMAT_2S16 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M16 | WAVE_FORMAT_2M08) +#define SRATE_44100_BITS (WAVE_FORMAT_4S16 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M16 | WAVE_FORMAT_4M08) +#define SHORT_SAMPLE_BITS (WAVE_FORMAT_1S16 | WAVE_FORMAT_1M16 | WAVE_FORMAT_2S16 | WAVE_FORMAT_2M16 | WAVE_FORMAT_4S16 | WAVE_FORMAT_4M16) +#define BYTE_SAMPLE_BITS (WAVE_FORMAT_1S08 | WAVE_FORMAT_1M08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_2M08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_4M08) + +static char *mixer_status_name(int status) +{ + switch (status) + { + case MIXERLINE_LINEF_ACTIVE: return(", (active)"); break; + case MIXERLINE_LINEF_DISCONNECTED: return(", (disconnected)"); break; + case MIXERLINE_LINEF_SOURCE: return(", (source)"); break; + default: return(""); break; + } +} + +static char *mixer_target_name(int type) +{ + switch (type) + { + case MIXERLINE_TARGETTYPE_UNDEFINED: return("undefined"); break; + case MIXERLINE_TARGETTYPE_WAVEOUT: return("output"); break; + case MIXERLINE_TARGETTYPE_WAVEIN: return("input"); break; + case MIXERLINE_TARGETTYPE_MIDIOUT: return("midi output"); break; + case MIXERLINE_TARGETTYPE_MIDIIN: return("midi input"); break; + case MIXERLINE_TARGETTYPE_AUX: return("aux"); break; + default: return(""); break; + } +} + +static char *mixer_component_name(int type) +{ + switch (type) + { + case MIXERLINE_COMPONENTTYPE_DST_UNDEFINED: return("undefined"); break; + case MIXERLINE_COMPONENTTYPE_DST_DIGITAL: return("digital"); break; + case MIXERLINE_COMPONENTTYPE_DST_LINE: return("line"); break; + case MIXERLINE_COMPONENTTYPE_DST_MONITOR: return("monitor"); break; + case MIXERLINE_COMPONENTTYPE_DST_SPEAKERS: return("speakers"); break; + case MIXERLINE_COMPONENTTYPE_DST_HEADPHONES: return("headphones"); break; + case MIXERLINE_COMPONENTTYPE_DST_TELEPHONE: return("telephone"); break; + case MIXERLINE_COMPONENTTYPE_DST_WAVEIN: return("wave in"); break; + case MIXERLINE_COMPONENTTYPE_DST_VOICEIN: return("voice in"); break; + case MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED: return("undefined"); break; + case MIXERLINE_COMPONENTTYPE_SRC_DIGITAL: return("digital"); break; + case MIXERLINE_COMPONENTTYPE_SRC_LINE: return("line"); break; + case MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE: return("mic"); break; + case MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER: return("synth"); break; + case MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC: return("CD"); break; + case MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE: return("telephone"); break; + case MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER: return("speaker"); break; + case MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT: return("wave out"); break; + case MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY: return("aux"); break; + case MIXERLINE_COMPONENTTYPE_SRC_ANALOG: return("analog"); break; + default: return(""); break; + } +} + +#define MAX_DESCRIBE_CHANS 8 +#define MAX_DESCRIBE_CONTROLS 16 +/* these actually need to be big enough to handle whatever comes along, since we can't read partial states */ +/* or they need to be expanded as necessary */ + +char *mus_audio_moniker(void) {return("MS audio");} /* version number of some sort? */ + +static void describe_audio_state_1(void) +{ + int devs, dev, srate, chans, format, need_comma, maker; + MMRESULT err; + unsigned long val, rate, pitch, version; + WAVEOUTCAPS wocaps; + WAVEINCAPS wicaps; + AUXCAPS wacaps; + HWAVEOUT hd; + WAVEFORMATEX pwfx; +#ifdef MIXERR_BASE + MIXERCAPS wmcaps; + MIXERLINE mixline; + MIXERLINECONTROLS linecontrols; + MIXERCONTROL mc[MAX_DESCRIBE_CONTROLS]; + MIXERCONTROLDETAILS controldetails; + MIXERCONTROLDETAILS_LISTTEXT clist[MAX_DESCRIBE_CHANS]; + MIXERCONTROLDETAILS_BOOLEAN cbool[MAX_DESCRIBE_CHANS]; + MIXERCONTROLDETAILS_UNSIGNED cline[MAX_DESCRIBE_CHANS]; + MIXERCONTROLDETAILS_SIGNED csign[MAX_DESCRIBE_CHANS]; + HMIXER mfd; + int control, controls, dest, dests, source, happy, dest_time, chan, mina, maxa, ctype; +#endif + need_comma = 1; + chans = 1; + devs = waveOutGetNumDevs(); + if (devs > 0) + { + pprint("Output:\n"); + for (dev = 0; dev < devs; dev++) + { + err = waveOutGetDevCaps(dev, &wocaps, sizeof(wocaps)); + if (!err) + { + version = wocaps.vDriverVersion; + maker = wocaps.wMid; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s: version %d.%d\n", + wocaps.szPname, version >> 8, version & 0xff); + pprint(audio_strbuf); + if (wocaps.wChannels == 2) {chans = 2; pprint(" stereo");} else {chans = 1; pprint(" mono");} + if (wocaps.dwFormats & SRATE_11025_BITS) {srate = 11025; if (need_comma) pprint(", "); pprint(" 11025"); need_comma = 1;} + if (wocaps.dwFormats & SRATE_22050_BITS) {srate = 22050; if (need_comma) pprint(", "); pprint(" 22050"); need_comma = 1;} + if (wocaps.dwFormats & SRATE_44100_BITS) {srate = 44100; if (need_comma) pprint(", "); pprint(" 44100"); need_comma = 1;} + if (wocaps.dwFormats & BYTE_SAMPLE_BITS) {format = 8; if (need_comma) pprint(", "); pprint(" unsigned byte"); need_comma = 1;} + if (wocaps.dwFormats & SHORT_SAMPLE_BITS) {format = 16; if (need_comma) pprint(", "); pprint(" little-endian short"); need_comma = 1;} + if (need_comma) pprint("\n"); + need_comma = 0; + pwfx.wFormatTag = WAVE_FORMAT_PCM; + pwfx.nChannels = chans; + pwfx.nSamplesPerSec = srate; + pwfx.nAvgBytesPerSec = srate; + pwfx.nBlockAlign = 1; + pwfx.wBitsPerSample = format; + + err = waveOutOpen(&hd, dev, &pwfx, 0, 0, WAVE_FORMAT_QUERY); + + if (wocaps.dwSupport & WAVECAPS_VOLUME) + { + err = waveOutGetVolume(hd, &val); + if (!err) + { + if (wocaps.dwSupport & WAVECAPS_LRVOLUME) + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + " vol: %.3f %.3f", + unlog((unsigned short)(val >> 16)), + unlog((unsigned short)(val & 0xffff))); + else mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + " vol: %.3f", + unlog((unsigned short)(val & 0xffff))); + pprint(audio_strbuf); + need_comma = 1; + } + } + if (!err) + { + /* this is just to get the hd data for subsequent info */ + if (wocaps.dwSupport & WAVECAPS_PLAYBACKRATE) + { + err = waveOutGetPlaybackRate(hd, &rate); + if (!err) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + "%s playback rate: %.3f", + (need_comma ? ", " : ""), + (float)rate / 65536.0); + pprint(audio_strbuf); + need_comma = 1; + } + } + if (wocaps.dwSupport & WAVECAPS_PITCH) + { + err = waveOutGetPitch(hd, &pitch); + if (!err) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + "%s pitch: %.3f", + (need_comma ? ", " : ""), + (float)pitch / 65536.0); + pprint(audio_strbuf); + need_comma = 1; + } + } + waveOutClose(hd); + } + if (need_comma) {need_comma = 0; pprint("\n");} + } + } + } + devs = waveInGetNumDevs(); + if (devs > 0) + { + pprint("Input:\n"); + for (dev = 0; dev < devs; dev++) + { + err = waveInGetDevCaps(dev, &wicaps, sizeof(wicaps)); + if (!err) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s", wicaps.szPname); + pprint(audio_strbuf); + if ((wicaps.wMid != maker) || (version != wicaps.vDriverVersion)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, ": version %d.%d\n", + (wicaps.vDriverVersion >> 8), + wicaps.vDriverVersion & 0xff); + pprint(audio_strbuf); + } + else pprint("\n"); + if (wicaps.wChannels == 2) pprint(" stereo"); else pprint(" mono"); + if (wicaps.dwFormats & SRATE_11025_BITS) {pprint(", 11025"); need_comma = 1;} + if (wicaps.dwFormats & SRATE_22050_BITS) {if (need_comma) pprint(", "); pprint(" 22050"); need_comma = 1;} + if (wicaps.dwFormats & SRATE_44100_BITS) {if (need_comma) pprint(", "); pprint(" 44100"); need_comma = 1;} + if (wicaps.dwFormats & BYTE_SAMPLE_BITS) {if (need_comma) pprint(", "); pprint(" unsigned byte"); need_comma = 1;} + if (wicaps.dwFormats & SHORT_SAMPLE_BITS) {if (need_comma) pprint(", "); pprint(" little-endian short");} + pprint("\n"); + } + } + } + devs = auxGetNumDevs(); + if (devs > 0) + { + pprint("Auxiliary:\n"); + for (dev = 0; dev < devs; dev++) + { + err = auxGetDevCaps(dev, &wacaps, sizeof(wacaps)); + if (!err) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s", wacaps.szPname); + pprint(audio_strbuf); + if ((wacaps.wMid != maker) || (version != wacaps.vDriverVersion)) + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, ": version %d.%d%s", + (wacaps.vDriverVersion >> 8), wacaps.vDriverVersion & 0xff, + (wacaps.wTechnology & AUXCAPS_CDAUDIO) ? " (CD)" : ""); + else mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s\n", (wacaps.wTechnology & AUXCAPS_CDAUDIO) ? " (CD)" : ""); + pprint(audio_strbuf); + if (wacaps.dwSupport & AUXCAPS_VOLUME) + { + err = auxGetVolume(dev, &val); + if (!err) + { + if (wacaps.dwSupport & AUXCAPS_LRVOLUME) + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + " vol: %.3f %.3f\n", + unlog((unsigned short)(val >> 16)), + unlog((unsigned short)(val & 0xffff))); + else mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + " vol: %.3f\n", + unlog((unsigned short)(val & 0xffff))); + pprint(audio_strbuf); + } + } + } + } + } +#ifdef MIXERR_BASE + devs = mixerGetNumDevs(); + if (devs > 0) + { + pprint("Mixer:\n"); + for (dev = 0; dev < devs; dev++) + { + err = mixerGetDevCaps(dev, &wmcaps, sizeof(wmcaps)); + if (!err) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s", wmcaps.szPname); + pprint(audio_strbuf); + if ((wmcaps.wMid != maker) || (version != wmcaps.vDriverVersion)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + ": version %d.%d\n", + (wmcaps.vDriverVersion >> 8), + wmcaps.vDriverVersion & 0xff); + pprint(audio_strbuf); + } + else pprint("\n"); + dests = wmcaps.cDestinations; + + err = mixerOpen(&mfd, dev, 0, 0, CALLBACK_NULL); + if (!err) + { + dest = 0; + source = 0; + dest_time = 1; + happy = 1; + while (happy) + { + if (dest_time) + { + mixline.dwDestination = dest; + mixline.cbStruct = sizeof(MIXERLINE); + err = mixerGetLineInfo((HMIXEROBJ)mfd, &mixline, MIXER_GETLINEINFOF_DESTINATION); + } + else + { + mixline.dwSource = source; + mixline.cbStruct = sizeof(MIXERLINE); + err = mixerGetLineInfo((HMIXEROBJ)mfd, &mixline, MIXER_GETLINEINFOF_SOURCE); + } + if (!err) + { + if ((source == 0) && (!dest_time)) pprint(" Sources:\n"); + if ((dest == 0) && (dest_time)) pprint(" Destinations:\n"); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s: %s (%s), %d chan%s", + mixline.szName, + mixer_component_name(mixline.dwComponentType), + mixer_target_name(mixline.Target.dwType), + + mixline.cChannels, ((mixline.cChannels != 1) ? "s" : "")); + pprint(audio_strbuf); + if (mixline.cConnections > 0) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, ", %d connection%s", + mixline.cConnections, ((mixline.cConnections != 1) ? "s" : "")); + pprint(audio_strbuf); + } + if (dest_time) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s\n", mixer_status_name(mixline.fdwLine)); + pprint(audio_strbuf); + } + else pprint("\n"); + if (mixline.cControls > 0) + { + linecontrols.cbStruct = sizeof(MIXERLINECONTROLS); + linecontrols.dwLineID = mixline.dwLineID; + linecontrols.dwControlID = MIXER_GETLINECONTROLSF_ONEBYID; + if (mixline.cControls > MAX_DESCRIBE_CONTROLS) + linecontrols.cControls = MAX_DESCRIBE_CONTROLS; + else linecontrols.cControls = mixline.cControls; + linecontrols.pamxctrl = mc; + linecontrols.cbmxctrl = sizeof(MIXERCONTROL); + err = mixerGetLineControls((HMIXEROBJ)mfd, &linecontrols, MIXER_GETLINECONTROLSF_ALL); + if (!err) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, + " %d control%s:\n", + linecontrols.cControls, + (linecontrols.cControls != 1) ? "s" : ""); + pprint(audio_strbuf); + controls = linecontrols.cControls; + if (controls > MAX_DESCRIBE_CONTROLS) controls = MAX_DESCRIBE_CONTROLS; + for (control = 0; control < controls; control++) + { + + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s", mc[control].szName); + pprint(audio_strbuf); + controldetails.cbStruct = sizeof(MIXERCONTROLDETAILS); + controldetails.dwControlID = mc[control].dwControlID; + + ctype = (mc[control].dwControlType); + if ((ctype == MIXERCONTROL_CONTROLTYPE_EQUALIZER) || + (ctype == MIXERCONTROL_CONTROLTYPE_MUX) || + (ctype == MIXERCONTROL_CONTROLTYPE_MIXER) || + (ctype == MIXERCONTROL_CONTROLTYPE_SINGLESELECT) || + (ctype == MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT)) + { + controldetails.cChannels = 1; + controldetails.cMultipleItems = mc[control].cMultipleItems; + controldetails.cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT); + controldetails.paDetails = clist; + err = mixerGetControlDetails((HMIXEROBJ)mfd, &controldetails, MIXER_GETCONTROLDETAILSF_LISTTEXT); + if (!err) + { + for (chan = 0; chan < mixline.cChannels; chan++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " [%s]", clist[chan].szName); + pprint(audio_strbuf); + } + } + } + if (mixline.cChannels > MAX_DESCRIBE_CHANS) + controldetails.cChannels = MAX_DESCRIBE_CHANS; + else controldetails.cChannels = mixline.cChannels; + controldetails.cMultipleItems = 0; + err = 0; + switch (mc[control].dwControlType & MIXERCONTROL_CT_UNITS_MASK) + { + case MIXERCONTROL_CT_UNITS_BOOLEAN: + controldetails.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN); + controldetails.paDetails = cbool; + break; + case MIXERCONTROL_CT_UNITS_SIGNED: case MIXERCONTROL_CT_UNITS_DECIBELS: + controldetails.cbDetails = sizeof(MIXERCONTROLDETAILS_SIGNED); + controldetails.paDetails = csign; + break; + case MIXERCONTROL_CT_UNITS_UNSIGNED: case MIXERCONTROL_CT_UNITS_PERCENT: + controldetails.cbDetails = sizeof(MIXERCONTROLDETAILS_UNSIGNED); + controldetails.paDetails = cline; + break; + default: err = 1; break; + } + if (err) + pprint("\n"); + else + { + err = mixerGetControlDetails((HMIXEROBJ)mfd, &controldetails, MIXER_GETCONTROLDETAILSF_VALUE); + if (!err) + { + chans = controldetails.cChannels; + if (chans > MAX_DESCRIBE_CHANS) chans = MAX_DESCRIBE_CHANS; + switch (mc[control].dwControlType & MIXERCONTROL_CT_UNITS_MASK) + { + case MIXERCONTROL_CT_UNITS_BOOLEAN: + for (chan = 0; chan < chans; chan++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s", (cbool[chan].fValue) ? " on" : " off"); + pprint(audio_strbuf); + } + break; + case MIXERCONTROL_CT_UNITS_SIGNED: case MIXERCONTROL_CT_UNITS_DECIBELS: + mina = mc[control].Bounds.lMinimum; + maxa = mc[control].Bounds.lMaximum; + if (maxa > mina) + { + for (chan = 0; chan < chans; chan++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.3f", + (float)(csign[chan].lValue - mina) / (float)(maxa - mina)); + pprint(audio_strbuf); + } + } + break; + case MIXERCONTROL_CT_UNITS_UNSIGNED: case MIXERCONTROL_CT_UNITS_PERCENT: + mina = mc[control].Bounds.dwMinimum; + maxa = mc[control].Bounds.dwMaximum; + if (maxa > mina) + { + for (chan = 0; chan < chans; chan++) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %.3f", + (float)(cline[chan].dwValue - mina) / (float)(maxa - mina)); + pprint(audio_strbuf); + } + } + break; + default: break; + } + pprint("\n"); + } + else pprint("\n"); + } + } + } + } + } + else if (!dest_time) happy = 0; + if (dest_time) dest++; else source++; + if (dest == dests) dest_time = 0; + } + } + mixerClose(mfd); + } + } + } +#endif +} + +int mus_audio_initialize(void) +{ + return(MUS_NO_ERROR); +} + +int mus_audio_close(int line) +{ + int i; + win_out_err = 0; + win_in_err = 0; + if (line == OUTPUT_LINE) + { + /* fill with a few zeros, wait for empty flag */ + if (sound_state != SOUND_UNREADY) + { + wait_for_empty_buffer(current_buf); + for (i = 0; i < 128; i++) wh[current_buf].lpData[i] = 0; + wait_for_empty_buffer(current_buf); + win_out_err = waveOutClose(fd); + i = 0; + while (win_out_err == WAVERR_STILLPLAYING) + { + Sleep(1); + win_out_err = waveOutClose(fd); + i++; + if (i > 1024) break; + } + db_state[0] = BUFFER_EMPTY; + db_state[1] = BUFFER_EMPTY; + sound_state = SOUND_UNREADY; + waveOutUnprepareHeader(fd, &(wh[0]), sizeof(WAVEHDR)); + waveOutUnprepareHeader(fd, &(wh[1]), sizeof(WAVEHDR)); + FREE(wh[0].lpData); + FREE(wh[1].lpData); + if (win_out_err) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_CLOSE, + mus_format("close failed on %d", + line)); + } + } + else + { + if (line == INPUT_LINE) + { + if (rec_state != SOUND_UNREADY) + { + waveInReset(record_fd); + waveInClose(record_fd); + waveInUnprepareHeader(record_fd, &rec_wh, sizeof(WAVEHDR)); + if (rec_wh.lpData) + { + FREE(rec_wh.lpData); + rec_wh.lpData = NULL; + } + rec_state = SOUND_UNREADY; + } + } + else + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_CLOSE, + mus_format("can't close unrecognized line %d", + line)); + } + return(MUS_NO_ERROR); +} + + /* + * waveInAddBuffer sends buffer to get data + * MM_WIM_DATA lParam->WAVEHDR dwBytesRecorded =>how much data actually in buffer + */ + +static int current_record_chans = 0, current_record_datum_size = 0; + +DWORD CALLBACK next_input_buffer(HWAVEIN w, UINT msg, DWORD user_data, DWORD p1, DWORD p2) +{ + if (msg == WIM_DATA) + { + /* grab data */ + /* p1->dwBytesRecorded */ + } + return(0); +} + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int size) +{ + WAVEFORMATEX wf; + int dev; + win_in_err = 0; + dev = MUS_AUDIO_DEVICE(ur_dev); + wf.nChannels = chans; + current_record_chans = chans; + + wf.wFormatTag = WAVE_FORMAT_PCM; + wf.cbSize = 0; + if (format == MUS_UBYTE) + { + wf.wBitsPerSample = 8; + current_record_datum_size = 1; + } + else + { + wf.wBitsPerSample = 16; + current_record_datum_size = 2; + } + wf.nSamplesPerSec = srate; + wf.nBlockAlign = chans * current_datum_size; + wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec; + + rec_wh.dwBufferLength = size * current_record_datum_size; + rec_wh.dwFlags = 0; + rec_wh.dwLoops = 0; + rec_wh.lpData = (char *)CALLOC(rec_wh.dwBufferLength, sizeof(char)); + if ((rec_wh.lpData) == 0) + RETURN_ERROR_EXIT(MUS_AUDIO_SIZE_NOT_AVAILABLE, + mus_format("can't allocated %d bytes for input buffer of %d (%s)", + size, dev, mus_audio_device_name(dev))); + win_in_err = waveInOpen(&record_fd, WAVE_MAPPER, &wf, (DWORD)next_input_buffer, 0, CALLBACK_FUNCTION); + if (win_in_err) + { + FREE(rec_wh.lpData); + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, + mus_format("can't open input device %d (%s)", + dev, mus_audio_device_name(dev))); + } + win_in_err = waveInPrepareHeader(record_fd, &(rec_wh), sizeof(WAVEHDR)); + if (win_in_err) + { + FREE(rec_wh.lpData); + waveInClose(record_fd); + RETURN_ERROR_EXIT(MUS_AUDIO_CONFIGURATION_NOT_AVAILABLE, + mus_format("can't prepare input 'header' for %d (%s)", + dev, mus_audio_device_name(dev))); + } + return(MUS_NO_ERROR); +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + win_in_err = 0; + return(MUS_ERROR); +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + int dev, sys; + unsigned long lval; + MMRESULT err; + sys = MUS_AUDIO_SYSTEM(ur_dev); + dev = MUS_AUDIO_DEVICE(ur_dev); + if (field == MUS_AUDIO_AMP) + { + err = auxGetVolume(sys, &lval); + if (!err) + { + if (chan == 0) + val[0] = unlog((unsigned short)(lval >> 16)); + else val[0] = unlog((unsigned short)(lval & 0xffff)); + return(MUS_NO_ERROR); + } + } + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, + mus_format("can't read device %d (%s) field %s", + dev, mus_audio_device_name(dev), + mus_audio_device_name(field))); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + int dev, sys; + unsigned long lval; + MMRESULT err; + sys = MUS_AUDIO_SYSTEM(ur_dev); + dev = MUS_AUDIO_DEVICE(ur_dev); + if (field == MUS_AUDIO_AMP) + { + err = auxGetVolume(sys, &lval); + if (!err) + { + if (chan == 0) + lval = (unsigned long)((lval & 0xffff) | (((unsigned short)(val[0] * 65535)) << 16)); + else lval = (unsigned long)((lval & 0xffff0000) | ((unsigned short)(val[0] * 65535))); + err = auxSetVolume(sys, lval); + if (err) return(MUS_NO_ERROR); + } + } + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, + mus_format("can't set device %d (%s) field %s", + dev, mus_audio_device_name(dev), + mus_audio_device_name(field))); +} + +#endif + + + +/* ------------------------------- OSX ----------------------------------------- */ + +/* this code based primarily on the CoreAudio headers and portaudio pa_mac_core.c, + * and to a much lesser extent, coreaudio.pdf and the HAL/Daisy examples. + */ + +#ifdef MUS_MAC_OSX +#define AUDIO_OK 1 + +/* +#include <CoreServices/CoreServices.h> +#include <CoreAudio/CoreAudio.h> +*/ +/* ./System/Library/Frameworks/CoreAudio.framework/Headers/CoreAudio.h */ + +static char* osx_error(OSStatus err) +{ + if (err == noErr) return("no error"); + switch (err) + { + case kAudioHardwareNoError: return("no error"); break; + case kAudioHardwareUnspecifiedError: return("unspecified audio hardware error"); break; + case kAudioHardwareNotRunningError: return("audio hardware not running"); break; + case kAudioHardwareUnknownPropertyError: return("unknown property"); break; + case kAudioHardwareBadPropertySizeError: return("bad property"); break; + case kAudioHardwareBadDeviceError: return("bad device"); break; + case kAudioHardwareBadStreamError: return("bad stream"); break; + case kAudioHardwareIllegalOperationError: return("illegal operation"); break; + case kAudioDeviceUnsupportedFormatError: return("unsupported format"); break; + case kAudioDevicePermissionsError: return("device permissions error"); break; + } + return("unknown error"); +} + +char *device_name(AudioDeviceID deviceID, int input_case) +{ + OSStatus err = noErr; + UInt32 size = 0, msize = 0, trans = 0, trans_size = 0; + char *name = NULL, *mfg = NULL, *full_name = NULL; + err = AudioDeviceGetPropertyInfo(deviceID, 0, false, kAudioDevicePropertyDeviceName, &size, NULL); + if (err == noErr) err = AudioDeviceGetPropertyInfo(deviceID, 0, false, kAudioDevicePropertyDeviceManufacturer, &msize, NULL); + if (err == noErr) + { + name = (char *)MALLOC(size + 2); + err = AudioDeviceGetProperty(deviceID, 0, input_case, kAudioDevicePropertyDeviceName, &size, name); + mfg = (char *)MALLOC(msize + 2); + err = AudioDeviceGetProperty(deviceID, 0, input_case, kAudioDevicePropertyDeviceManufacturer, &msize, mfg); + full_name = (char *)MALLOC(size + msize + 4); +#if HAVE_KAUDIODEVICEPROPERTYTRANSPORTTYPE + trans_size = sizeof(UInt32); + err = AudioDeviceGetProperty(deviceID, 0, input_case, kAudioDevicePropertyTransportType, &trans_size, &trans); + if (err != noErr) +#endif + trans = 0; + if (trans == 0) + mus_snprintf(full_name, size + msize + 4, "\n %s: %s", mfg, name); + else mus_snprintf(full_name, size + msize + 4, "\n %s: %s ('%c%c%c%c')", + mfg, name, + (char)((trans >> 24) & 0xff), (char)((trans >> 16) & 0xff), (char)((trans >> 8) & 0xff), (char)(trans & 0xff)); + FREE(name); + FREE(mfg); + } + return(full_name); +} + +static int max_chans_via_stream_configuration(AudioDeviceID device, bool input_case) +{ + /* apparently MOTU 828 has to be different (this code from portaudio) */ + UInt32 size = 0; + Boolean writable; + OSStatus err = noErr; + err = AudioDeviceGetPropertyInfo(device, 0, input_case, kAudioDevicePropertyStreamConfiguration, &size, &writable); + if (err == noErr) + { + AudioBufferList *list; + list = (AudioBufferList *)malloc(size); + err = AudioDeviceGetProperty(device, 0, input_case, kAudioDevicePropertyStreamConfiguration, &size, list); + if (err == noErr) + { + int chans = 0, i; + for (i = 0; i < list->mNumberBuffers; i++) + chans += list->mBuffers[i].mNumberChannels; + free(list); + return(chans); + } + } + return(-1); +} + +static void describe_audio_state_1(void) +{ + OSStatus err = noErr; + UInt32 num_devices = 0, msize = 0, size = 0, buffer_size = 0, mute = 0, alive = 0; + Float32 vol; + int i, j, k; + pid_t hogger = 0; + AudioDeviceID *devices = NULL; + AudioDeviceID device, default_output, default_input; + AudioStreamBasicDescription desc; + AudioStreamBasicDescription *descs = NULL; + int formats = 0, m; + bool input_case = false; + err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &msize, NULL); + if (err != noErr) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "get property info error: %s\n", osx_error(err)); + pprint(audio_strbuf); + return; + } + num_devices = msize / sizeof(AudioDeviceID); + if (num_devices <= 0) + { + pprint("no audio devices found"); + return; + } + devices = (AudioDeviceID *)MALLOC(msize); + size = sizeof(AudioDeviceID); + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &size, &default_input); + if (err != noErr) default_input = 55555555; /* unsigned int -- I want some value that won't happen! */ + size = sizeof(AudioDeviceID); + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &default_output); + if (err != noErr) default_output = 55555555; + err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &msize, (void *)devices); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "found %d audio device%s", + (int)num_devices, (num_devices != 1) ? "s" : ""); + pprint(audio_strbuf); + for (m = 0; m < 2; m++) + { + for (i = 0; i < num_devices; i++) + { + device = devices[i]; + pprint(device_name(device, input_case)); + if (input_case) + { + if (device == default_input) + pprint(" (default input)"); + else pprint(" (input)"); + } + else + { + if (device == default_output) + pprint(" (default output)"); + else pprint(" (output)"); + } + size = sizeof(pid_t); + err = AudioDeviceGetProperty(device, 0, input_case, kAudioDevicePropertyHogMode, &size, &hogger); + if ((err == noErr) && (hogger >= 0)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " currently owned (exclusively) by process %d", (int)hogger); + pprint(audio_strbuf); + } + size = sizeof(UInt32); + err = AudioDeviceGetProperty(device, 0, input_case, kAudioDevicePropertyDeviceIsAlive, &size, &alive); + if ((err == noErr) && (alive == 0)) + pprint(" disconnected?"); + size = sizeof(UInt32); + err = AudioDeviceGetProperty(device, 0, input_case, kAudioDevicePropertyBufferSize, &size, &buffer_size); + if (err != noErr) buffer_size = 0; + size = sizeof(AudioStreamBasicDescription); + err = AudioDeviceGetProperty(device, 0, input_case, kAudioDevicePropertyStreamFormat, &size, &desc); + if (err == noErr) + { + int config_chans; + unsigned int trans; + trans = (unsigned int)(desc.mFormatID); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "\n srate: %d, chans: %d", + (int)(desc.mSampleRate), + (int)(desc.mChannelsPerFrame)); + pprint(audio_strbuf); + config_chans = max_chans_via_stream_configuration(device, input_case); + if ((config_chans > 0) && (config_chans != (int)(desc.mChannelsPerFrame))) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " (or %d?)", config_chans); + pprint(audio_strbuf); + } + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, ", bits/sample: %d, format: %c%c%c%c", + (int)(desc.mBitsPerChannel), + (trans >> 24) & 0xff, (trans >> 16) & 0xff, (trans >> 8) & 0xff, trans & 0xff); + pprint(audio_strbuf); + if (buffer_size > 0) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, ", buf: %d", (int)buffer_size); + pprint(audio_strbuf); + } + if ((int)(desc.mFormatFlags) != 0) /* assuming "PCM" here */ + { + int flags; + flags = ((int)(desc.mFormatFlags)); + pprint("\n flags: "); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s%s%s%s%s%s", + (flags & kLinearPCMFormatFlagIsFloat) ? "float " : "", + (flags & kLinearPCMFormatFlagIsBigEndian) ? "big-endian " : "", + (flags & kLinearPCMFormatFlagIsSignedInteger) ? "signed-int " : "", + (flags & kLinearPCMFormatFlagIsPacked) ? "packed " : "", + (flags & kLinearPCMFormatFlagIsAlignedHigh) ? "aligned-high " : "", +#if HAVE_KLINEARPCMFORMATFLAGISNONINTERLEAVED + (flags & kLinearPCMFormatFlagIsNonInterleaved) ? "non-interleaved " : "" +#else + "" +#endif + ); + pprint(audio_strbuf); + } + + if ((int)(desc.mChannelsPerFrame) > 0) + { + pprint("\n vols:"); + for (j = 0; j <= (int)(desc.mChannelsPerFrame); j++) + { + size = sizeof(Float32); + err = AudioDeviceGetProperty(device, j, input_case, kAudioDevicePropertyVolumeScalar, &size, &vol); + if (err == noErr) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s%.3f", + (j == 0) ? "master: " : "", + vol); + pprint(audio_strbuf); + } + + if (j > 0) + { + size = sizeof(UInt32); + err = AudioDeviceGetProperty(device, j, input_case, kAudioDevicePropertyMute, &size, &mute); + if ((err == noErr) && (mute == 1)) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " (muted)"); + pprint(audio_strbuf); + } + } + } + } + } + size = 0; + err = AudioDeviceGetPropertyInfo(device, 0, input_case, kAudioDevicePropertyStreamFormats, &size, NULL); + formats = size / sizeof(AudioStreamBasicDescription); + if (formats > 1) + { + descs = (AudioStreamBasicDescription *)CALLOC(formats, sizeof(AudioStreamBasicDescription)); + size = formats * sizeof(AudioStreamBasicDescription); + err = AudioDeviceGetProperty(device, 0, input_case, kAudioDevicePropertyStreamFormats, &size, descs); + if (err == noErr) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "\n This device supports %d formats: ", formats); + pprint(audio_strbuf); + for (k = 0; k < formats; k++) + { + unsigned int trans; + trans = (unsigned int)(descs[k].mFormatID); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "\n srate: %d, chans: %d, bits/sample: %d, format: %c%c%c%c", + (int)(descs[k].mSampleRate), + (int)(descs[k].mChannelsPerFrame), + (int)(descs[k].mBitsPerChannel), + (trans >> 24) & 0xff, (trans >> 16) & 0xff, (trans >> 8) & 0xff, trans & 0xff); + pprint(audio_strbuf); + } + } + FREE(descs); + } + pprint("\n"); + } + input_case = true; + } + if (devices) FREE(devices); +} + +#define MAX_BUFS 4 +static char **bufs = NULL; +static int in_buf = 0, out_buf = 0; + +static OSStatus writer(AudioDeviceID inDevice, + const AudioTimeStamp *inNow, + const AudioBufferList *InputData, const AudioTimeStamp *InputTime, + AudioBufferList *OutputData, const AudioTimeStamp *OutputTime, + void *appGlobals) +{ + AudioBuffer abuf; + char *aplbuf, *sndbuf; + abuf = OutputData->mBuffers[0]; + aplbuf = (char *)(abuf.mData); + sndbuf = bufs[out_buf]; + memmove((void *)aplbuf, (void *)sndbuf, abuf.mDataByteSize); + out_buf++; + if (out_buf >= MAX_BUFS) out_buf = 0; + return(noErr); +} + +static OSStatus reader(AudioDeviceID inDevice, + const AudioTimeStamp *inNow, + const AudioBufferList *InputData, const AudioTimeStamp *InputTime, + AudioBufferList *OutputData, const AudioTimeStamp *OutputTime, + void *appGlobals) +{ + AudioBuffer abuf; + char *aplbuf, *sndbuf; + abuf = InputData->mBuffers[0]; + aplbuf = (char *)(abuf.mData); + sndbuf = bufs[out_buf]; + memmove((void *)sndbuf, (void *)aplbuf, abuf.mDataByteSize); + out_buf++; + if (out_buf >= MAX_BUFS) out_buf = 0; + return(noErr); +} + + +static AudioDeviceID device = kAudioDeviceUnknown; +static bool writing = false, open_for_input = false; + +int mus_audio_close(int line) +{ + OSStatus err = noErr; + UInt32 sizeof_running; + UInt32 running; + if (open_for_input) + { + in_buf = 0; + err = AudioDeviceStop(device, (AudioDeviceIOProc)reader); + if (err == noErr) + err = AudioDeviceRemoveIOProc(device, (AudioDeviceIOProc)reader); + } + else + { + if ((in_buf > 0) && (!writing)) + { + /* short enough sound that we never got started? */ + err = AudioDeviceAddIOProc(device, (AudioDeviceIOProc)writer, NULL); + if (err == noErr) + err = AudioDeviceStart(device, (AudioDeviceIOProc)writer); /* writer will be called right away */ + if (err == noErr) + writing = true; + } + if (writing) + { + /* send out waiting buffers */ + sizeof_running = sizeof(UInt32); + while (in_buf == out_buf) + { + err = AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyDeviceIsRunning, &sizeof_running, &running); + } + while (in_buf != out_buf) + { + err = AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyDeviceIsRunning, &sizeof_running, &running); + } + in_buf = 0; + err = AudioDeviceStop(device, (AudioDeviceIOProc)writer); + if (err == noErr) + err = AudioDeviceRemoveIOProc(device, (AudioDeviceIOProc)writer); + writing = false; + } + } + device = kAudioDeviceUnknown; + if (err == noErr) + return(MUS_NO_ERROR); + return(MUS_ERROR); +} + +typedef enum {CONVERT_NOT, CONVERT_COPY, CONVERT_SKIP, CONVERT_COPY_AND_SKIP, CONVERT_SKIP_N, CONVERT_COPY_AND_SKIP_N} audio_convert_t; +static audio_convert_t conversion_choice = CONVERT_NOT; +static float conversion_multiplier = 1.0; +static int dac_out_chans, dac_out_srate; +static int incoming_out_chans = 1, incoming_out_srate = 44100; +static int fill_point = 0; +static unsigned int bufsize = 0, current_bufsize = 0; + +/* I'm getting bogus buffer sizes from the audio conversion stuff from Apple, + * and I think AudioConvert doesn't handle cases like 4->6 chans correctly + * so, I'll just do the conversions myself -- there is little need here + * for non-integer srate conversion anyway, and the rest is trivial. + */ + +int mus_audio_open_output(int dev, int srate, int chans, int format, int size) +{ + OSStatus err = noErr; + UInt32 sizeof_device, sizeof_format, sizeof_bufsize; + AudioStreamBasicDescription device_desc; + sizeof_device = sizeof(AudioDeviceID); + sizeof_bufsize = sizeof(unsigned int); + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &sizeof_device, (void *)(&device)); + bufsize = 4096; + if (err == noErr) + err = AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyBufferSize, &sizeof_bufsize, &bufsize); + if (err != noErr) + { + fprintf(stderr,"open audio output err: %d %s\n", (int)err, osx_error(err)); + return(MUS_ERROR); + } + /* now check for srate/chan mismatches and so on */ + sizeof_format = sizeof(AudioStreamBasicDescription); + err = AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyStreamFormat, &sizeof_format, &device_desc); + if (err != noErr) + { + fprintf(stderr,"open audio output (get device format) err: %d %s\n", (int)err, osx_error(err)); + return(MUS_ERROR); + } + /* current DAC state: device_desc.mChannelsPerFrame, (int)(device_desc.mSampleRate) */ + /* apparently get stream format can return noErr but chans == 0?? */ + if ((device_desc.mChannelsPerFrame != chans) || + ((int)(device_desc.mSampleRate) != srate)) + { + /* try to match DAC settings to current sound */ + device_desc.mChannelsPerFrame = chans; + device_desc.mSampleRate = srate; + device_desc.mBytesPerPacket = chans * 4; /* assume 1 frame/packet and float32 data */ + device_desc.mBytesPerFrame = chans * 4; + sizeof_format = sizeof(AudioStreamBasicDescription); + err = AudioDeviceSetProperty(device, 0, 0, false, kAudioDevicePropertyStreamFormat, sizeof_format, &device_desc); + + /* this error is bogus in some cases -- other audio systems just ignore it, + * but in my case (a standard MacIntel with no special audio hardware), if I leave + * this block out, the sound is played back at the wrong rate, and the volume + * of outa is set to 0.0?? + */ + + if (err != noErr) + { + /* it must have failed for some reason -- look for closest match available */ + /* if srate = 22050 try 44100, if chans = 1 try 2 */ + /* the "get closest match" business appears to be completely bogus... */ + device_desc.mChannelsPerFrame = (chans == 1) ? 2 : chans; + device_desc.mSampleRate = (srate == 22050) ? 44100 : srate; + device_desc.mBytesPerPacket = device_desc.mChannelsPerFrame * 4; /* assume 1 frame/packet and float32 data */ + device_desc.mBytesPerFrame = device_desc.mChannelsPerFrame * 4; + sizeof_format = sizeof(AudioStreamBasicDescription); + err = AudioDeviceSetProperty(device, 0, 0, false, kAudioDevicePropertyStreamFormat, sizeof_format, &device_desc); + if (err != noErr) + { + sizeof_format = sizeof(AudioStreamBasicDescription); + err = AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyStreamFormatMatch, &sizeof_format, &device_desc); + if (err == noErr) + { + /* match suggests: device_desc.mChannelsPerFrame, (int)(device_desc.mSampleRate) */ + /* try to set DAC to reflect that match */ + /* a bug here in emagic 2|6 -- we can get 6 channel match, but then can't set it?? */ + sizeof_format = sizeof(AudioStreamBasicDescription); + err = AudioDeviceSetProperty(device, 0, 0, false, kAudioDevicePropertyStreamFormat, sizeof_format, &device_desc); + if (err != noErr) + { + /* no luck -- get current DAC settings at least */ + sizeof_format = sizeof(AudioStreamBasicDescription); + AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyStreamFormat, &sizeof_format, &device_desc); + } + } + } + else + { + /* nothing matches? -- get current DAC settings */ + sizeof_format = sizeof(AudioStreamBasicDescription); + AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyStreamFormat, &sizeof_format, &device_desc); + } + } + } + /* now DAC claims it is ready for device_desc.mChannelsPerFrame, (int)(device_desc.mSampleRate) */ + dac_out_chans = device_desc.mChannelsPerFrame; /* use better variable names */ + dac_out_srate = (int)(device_desc.mSampleRate); + open_for_input = false; + if ((bufs == NULL) || (bufsize > current_bufsize)) + { + int i; + if (bufs) + { + for (i = 0; i < MAX_BUFS; i++) FREE(bufs[i]); + FREE(bufs); + } + bufs = (char **)CALLOC(MAX_BUFS, sizeof(char *)); + for (i = 0; i < MAX_BUFS; i++) + bufs[i] = (char *)CALLOC(bufsize, sizeof(char)); + current_bufsize = bufsize; + } + in_buf = 0; + out_buf = 0; + fill_point = 0; + incoming_out_srate = srate; + incoming_out_chans = chans; + if (incoming_out_chans == dac_out_chans) + { + if (incoming_out_srate == dac_out_srate) + { + conversion_choice = CONVERT_NOT; + conversion_multiplier = 1.0; + } + else + { + /* here we don't get very fancy -- assume dac/2=in */ + conversion_choice = CONVERT_COPY; + conversion_multiplier = 2.0; + } + } + else + { + if (incoming_out_srate == dac_out_srate) + { + if ((dac_out_chans == 2) && (incoming_out_chans == 1)) /* the usual case */ + { + conversion_choice = CONVERT_SKIP; + conversion_multiplier = 2.0; + } + else + { + conversion_choice = CONVERT_SKIP_N; + conversion_multiplier = ((float)dac_out_chans / (float)incoming_out_chans); + } + } + else + { + if ((dac_out_chans == 2) && (incoming_out_chans == 1)) /* the usual case */ + { + conversion_choice = CONVERT_COPY_AND_SKIP; + conversion_multiplier = 4.0; + } + else + { + conversion_choice = CONVERT_COPY_AND_SKIP_N; + conversion_multiplier = ((float)dac_out_chans / (float)incoming_out_chans) * 2; + } + } + } + return(MUS_NO_ERROR); +} + +static void convert_incoming(char *to_buf, int fill_point, int lim, char *buf) +{ + int i, j, k, jc, kc, ic; + switch (conversion_choice) + { + case CONVERT_NOT: + /* no conversion needed */ + for (i = 0; i < lim; i++) + to_buf[i + fill_point] = buf[i]; + break; + case CONVERT_COPY: + /* copy sample to mimic lower srate */ + for (i = 0, j = fill_point; i < lim; i += 8, j += 16) + for (k = 0; k < 8; k++) + { + to_buf[j + k] = buf[i + k]; + to_buf[j + k + 8] = buf[i + k]; + } + break; + case CONVERT_SKIP: + /* skip sample for empty chan */ + for (i = 0, j = fill_point; i < lim; i += 4, j += 8) + for (k = 0; k < 4; k++) + { + to_buf[j + k] = buf[i + k]; + to_buf[j + k + 4] = 0; + } + break; + case CONVERT_SKIP_N: + /* copy incoming_out_chans then skip up to dac_out_chans */ + jc = dac_out_chans * 4; + ic = incoming_out_chans * 4; + for (i = 0, j = fill_point; i < lim; i += ic, j += jc) + { + for (k = 0; k < ic; k++) to_buf[j + k] = buf[i + k]; + for (k = ic; k < jc; k++) to_buf[j + k] = 0; + } + break; + case CONVERT_COPY_AND_SKIP: + for (i = 0, j = fill_point; i < lim; i += 4, j += 16) + for (k = 0; k < 4; k++) + { + to_buf[j + k] = buf[i + k]; + to_buf[j + k + 4] = 0; + to_buf[j + k + 8] = buf[i + k]; + to_buf[j + k + 12] = 0; + } + break; + case CONVERT_COPY_AND_SKIP_N: + /* copy for each active chan, skip rest */ + jc = dac_out_chans * 8; + ic = incoming_out_chans * 4; + kc = dac_out_chans * 4; + for (i = 0, j = fill_point; i < lim; i += ic, j += jc) + { + for (k = 0; k < ic; k++) + { + to_buf[j + k] = buf[i + k]; + to_buf[j + k + kc] = buf[i + k]; + } + for (k = ic; k < kc; k++) + { + to_buf[j + k] = 0; + to_buf[j + k + kc] = 0; + } + } + break; + } +} + +int mus_audio_write(int line, char *buf, int bytes) +{ + OSStatus err = noErr; + int lim, bp, out_bytes; + UInt32 sizeof_running; + UInt32 running; + char *to_buf; + to_buf = bufs[in_buf]; + out_bytes = (int)(bytes * conversion_multiplier); + if ((fill_point + out_bytes) > bufsize) + out_bytes = bufsize - fill_point; + lim = (int)(out_bytes / conversion_multiplier); + if (!writing) + { + convert_incoming(to_buf, fill_point, lim, buf); + fill_point += out_bytes; + if (fill_point >= bufsize) + { + in_buf++; + fill_point = 0; + if (in_buf == MAX_BUFS) + { + in_buf = 0; + err = AudioDeviceAddIOProc(device, (AudioDeviceIOProc)writer, NULL); + if (err == noErr) + err = AudioDeviceStart(device, (AudioDeviceIOProc)writer); /* writer will be called right away */ + if (err == noErr) + { + writing = true; + return(MUS_NO_ERROR); + } + else return(MUS_ERROR); + } + } + return(MUS_NO_ERROR); + } + if ((fill_point == 0) && (in_buf == out_buf)) + { + bp = out_buf; + sizeof_running = sizeof(UInt32); + while (bp == out_buf) + { + /* i.e. just kill time without hanging */ + err = AudioDeviceGetProperty(device, 0, false, kAudioDevicePropertyDeviceIsRunning, &sizeof_running, &running); + /* usleep(10); */ + } + } + to_buf = bufs[in_buf]; + if (fill_point == 0) memset((void *)to_buf, 0, bufsize); + convert_incoming(to_buf, fill_point, lim, buf); + fill_point += out_bytes; + if (fill_point >= bufsize) + { + in_buf++; + fill_point = 0; + if (in_buf >= MAX_BUFS) in_buf = 0; + } + return(MUS_NO_ERROR); +} + +int mus_audio_open_input(int dev, int srate, int chans, int format, int size) +{ + OSStatus err = noErr; + UInt32 sizeof_device; + UInt32 sizeof_bufsize; + sizeof_device = sizeof(AudioDeviceID); + sizeof_bufsize = sizeof(unsigned int); + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &sizeof_device, (void *)(&device)); + bufsize = 4096; + if (err == noErr) + err = AudioDeviceGetProperty(device, 0, true, kAudioDevicePropertyBufferSize, &sizeof_bufsize, &bufsize); + if (err != noErr) + { + fprintf(stderr,"open audio input err: %d %s\n", (int)err, osx_error(err)); + return(MUS_ERROR); + } + open_for_input = true; + /* assume for now that recorder (higher level) will enforce match */ + if ((bufs == NULL) || (bufsize > current_bufsize)) + { + int i; + if (bufs) + { + for (i = 0; i < MAX_BUFS; i++) FREE(bufs[i]); + FREE(bufs); + } + bufs = (char **)CALLOC(MAX_BUFS, sizeof(char *)); + for (i = 0; i < MAX_BUFS; i++) + bufs[i] = (char *)CALLOC(bufsize, sizeof(char)); + current_bufsize = bufsize; + } + in_buf = 0; + out_buf = 0; + fill_point = 0; + incoming_out_srate = srate; + incoming_out_chans = chans; + err = AudioDeviceAddIOProc(device, (AudioDeviceIOProc)reader, NULL); + if (err == noErr) + err = AudioDeviceStart(device, (AudioDeviceIOProc)reader); + if (err != noErr) + { + fprintf(stderr,"add open audio input err: %d %s\n", (int)err, osx_error(err)); + return(MUS_ERROR); + } + return(MUS_NO_ERROR); +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + OSStatus err = noErr; + int bp; + UInt32 sizeof_running; + UInt32 running; + char *to_buf; + if (in_buf == out_buf) + { + bp = out_buf; + sizeof_running = sizeof(UInt32); + while (bp == out_buf) + { + err = AudioDeviceGetProperty(device, 0, true, kAudioDevicePropertyDeviceIsRunning, &sizeof_running, &running); + if (err != noErr) + fprintf(stderr,"wait err: %s ", osx_error(err)); + } + } + to_buf = bufs[in_buf]; + if (bytes <= bufsize) + memmove((void *)buf, (void *)to_buf, bytes); + else memmove((void *)buf, (void *)to_buf, bufsize); + in_buf++; + if (in_buf >= MAX_BUFS) in_buf = 0; + return(MUS_ERROR); +} + +static int max_chans(AudioDeviceID device, int input) +{ + int maxc = 0, formats, k, config_chans; + UInt32 size; + OSStatus err; + AudioStreamBasicDescription desc; + AudioStreamBasicDescription *descs; + size = sizeof(AudioStreamBasicDescription); + err = AudioDeviceGetProperty(device, 0, input, kAudioDevicePropertyStreamFormat, &size, &desc); + if (err == noErr) + { + maxc = (int)(desc.mChannelsPerFrame); + size = 0; + err = AudioDeviceGetPropertyInfo(device, 0, input, kAudioDevicePropertyStreamFormats, &size, NULL); + formats = size / sizeof(AudioStreamBasicDescription); + if (formats > 1) + { + descs = (AudioStreamBasicDescription *)CALLOC(formats, sizeof(AudioStreamBasicDescription)); + size = formats * sizeof(AudioStreamBasicDescription); + err = AudioDeviceGetProperty(device, 0, input, kAudioDevicePropertyStreamFormats, &size, descs); + if (err == noErr) + for (k = 0; k < formats; k++) + if ((int)(descs[k].mChannelsPerFrame) > maxc) maxc = (int)(descs[k].mChannelsPerFrame); + FREE(descs); + } + } + else fprintf(stderr, "read chans hit: %s\n", osx_error(err)); + config_chans = max_chans_via_stream_configuration(device, input); + if (config_chans > maxc) return(config_chans); + return(maxc); +} + +int mus_audio_mixer_read(int dev1, int field, int chan, float *val) +{ + AudioDeviceID dev = kAudioDeviceUnknown; + OSStatus err = noErr; + UInt32 size; + Float32 amp; + int i, curdev; + bool in_case = false; + switch (field) + { + case MUS_AUDIO_AMP: + size = sizeof(AudioDeviceID); + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &dev); + size = sizeof(Float32); + err = AudioDeviceGetProperty(dev, chan + 1, false, kAudioDevicePropertyVolumeScalar, &size, &); + if (err == noErr) + val[0] = (Float)amp; + else val[0] = 0.0; + break; + case MUS_AUDIO_CHANNEL: + curdev = MUS_AUDIO_DEVICE(dev1); + size = sizeof(AudioDeviceID); + in_case = ((curdev == MUS_AUDIO_MICROPHONE) || (curdev == MUS_AUDIO_LINE_IN)); + if (in_case) + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &size, &dev); + else err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &dev); + if (err != noErr) fprintf(stderr, "get default: %s\n", osx_error(err)); + val[0] = max_chans(dev, in_case); + break; + case MUS_AUDIO_SRATE: + val[0] = 44100; + break; + case MUS_AUDIO_FORMAT: + /* never actually used except perhaps play.scm */ + val[0] = 1.0; +#if MUS_LITTLE_ENDIAN + val[1] = MUS_LFLOAT; +#else + val[1] = MUS_BFLOAT; +#endif + break; + case MUS_AUDIO_PORT: + i = 0; + if (1 < chan) val[1] = MUS_AUDIO_MICROPHONE; + if (2 < chan) val[2] = MUS_AUDIO_DAC_OUT; + val[0] = 2; + break; + case MUS_AUDIO_SAMPLES_PER_CHANNEL: + /* bufsize / 16: mulaw 22050 mono -> float 44100 stereo => 16:1 expansion */ + { + int bufsize = 4096; + UInt32 sizeof_bufsize; + sizeof_bufsize = sizeof(unsigned int); + curdev = MUS_AUDIO_DEVICE(dev1); + size = sizeof(AudioDeviceID); + in_case = ((curdev == MUS_AUDIO_MICROPHONE) || (curdev == MUS_AUDIO_LINE_IN)); + if (in_case) + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice, &size, &dev); + else err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, &dev); + if (err != noErr) + fprintf(stderr, "get samps/chan: %s\n", osx_error(err)); + else + { + err = AudioDeviceGetProperty(dev, 0, true, kAudioDevicePropertyBufferSize, &sizeof_bufsize, &bufsize); + if (err == noErr) val[0] = (float)(bufsize / 16); + } + } + break; + default: + return(MUS_ERROR); + break; + } + return(MUS_NO_ERROR); +} + +int mus_audio_mixer_write(int dev1, int field, int chan, float *val) +{ + AudioDeviceID dev = kAudioDeviceUnknown; + OSStatus err = noErr; + Boolean writable; + UInt32 size; + Float32 amp; + switch (field) + { + case MUS_AUDIO_AMP: + size = sizeof(AudioDeviceID); + err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &size, (void *)(&dev)); + err = AudioDeviceGetPropertyInfo(dev, chan + 1, false, kAudioDevicePropertyVolumeScalar, NULL, &writable); /* "false" -> output */ + amp = (Float32)(val[0]); + if ((err == kAudioHardwareNoError) && (writable)) + err = AudioDeviceSetProperty(dev, NULL, chan + 1, false, kAudioDevicePropertyVolumeScalar, sizeof(Float32), &); + break; + default: + return(MUS_ERROR); + break; + } + return(MUS_NO_ERROR); +} + +int mus_audio_initialize(void) {return(MUS_NO_ERROR);} +int mus_audio_systems(void) {return(1);} +char *mus_audio_system_name(int system) {return("Mac OSX");} + +char *mus_audio_moniker(void) {return("Mac OSX audio");} +#endif + + + +/* -------------------------------- ESD -------------------------------- */ + +/* ESD audio IO for Linux * + * Nick Bailey <nick@bailey-family.org.uk> * + * also n.bailey@elec.gla.ac.uk */ + +/* ESD is pretty well undocumented, and I've not looked at snd before, * + * but here goes... * + * * + * History: * + * 14th Nov 2000: copied SUN drivers here and started to hack. NJB. * + * */ + +#ifdef MUS_ESD +#define AUDIO_OK + +#include <esd.h> + +static int esd_play_sock = -1; +static int esd_rec_sock = -1; +static char esd_name[] = "Enlightened Sound Daemon"; +static int swap_end, resign; /* How to handle samples on write */ + +int mus_audio_initialize(void) {return(MUS_NO_ERROR);} +int mus_audio_systems(void) {return(1);} +char *mus_audio_system_name(int system) {return esd_name;} +static char our_name[LABEL_BUFFER_SIZE]; +char *mus_audio_moniker(void) +{ +#ifdef MUS_ESD_VERSION + #ifdef MUS_AUDIOFILE_VERSION + mus_snprintf(our_name, LABEL_BUFFER_SIZE, "%s: %s (Audiofile %s)", esd_name, MUS_ESD_VERSION, MUS_AUDIOFILE_VERSION); + #else + mus_snprintf(our_name, LABEL_BUFFER_SIZE, "%s: %s", esd_name, MUS_ESD_VERSION); + #endif + return(our_name); +#else + return(esd_name); +#endif +} + +int mus_audio_api(void) {return(0);} + +#define RETURN_ERROR_EXIT(Error_Type, Audio_Line, Ur_Error_Message) \ + do { char *Error_Message; Error_Message = Ur_Error_Message; \ + if (esd_play_sock != -1) close(esd_play_sock); \ + if (esd_rec_sock != -1) close(esd_rec_sock); \ + if (Error_Message) \ + {MUS_STANDARD_ERROR(Error_Type, Error_Message); FREE(Error_Message);} \ + else MUS_STANDARD_ERROR(Error_Type, mus_error_type_to_string(Error_Type)); \ + return(MUS_ERROR); \ + } while (false) + +/* No we're laughing. snd think's its talking to a real piece of hardware + so it'll only try to open it once. We can just use the socket numbers */ + +/* REVOLTING HACK! to_esd_format is called from mus_audio_open, and + /as a side effect/, sets a flag to tell the write routine whether + or not to change the endienness of the audio sample data (afaik, + esd can't do this for us). Same goes for signed-ness. + If it gets called from elsewhere, it could be nasty. */ + +static int to_esd_format(int snd_format) +{ + /* Try this on the Macs: it may be esd expects Bigendian on those */ + switch (snd_format) { /* Only some are supported */ + case MUS_UBYTE: swap_end = 0; resign = 0; return ESD_BITS8; + case MUS_LSHORT: swap_end = 0; resign = 0; return ESD_BITS16; + case MUS_BSHORT: swap_end = 1; resign = 0; return ESD_BITS16; + case MUS_ULSHORT: swap_end = 0; resign = 1; return ESD_BITS16; + case MUS_UBSHORT: swap_end = 1; resign = 1; return ESD_BITS16; + } + return MUS_ERROR; +} + +int mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + int esd_prop = ESD_STREAM; + int esd_format; + + if ((esd_format = to_esd_format(format)) == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_out, + mus_format("Can't handle format %d (%s) through esd", + format, mus_data_format_name(format))); + else + esd_prop |= esd_format; + + if (chans < 1 || chans > 2) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_out, + mus_format("Can't handle format %d channels through esd", + format)); + else + esd_prop |= chans == 1 ? ESD_MONO : ESD_STEREO; + + esd_play_sock = esd_play_stream(esd_prop, srate, + NULL, "snd playback stream"); + + if (esd_play_sock == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, audio_out, + mus_format("Sonorus device %d (%s) not available", + ur_dev, mus_audio_device_name(ur_dev))); + else + return esd_play_sock; +} + +int mus_audio_write(int line, char *buf, int bytes) +{ + int written; + char *to = buf; + + /* Esd can't do endianness or signed/unsigned conversion, + so it's our problem. We won't screw up the callers data */ + + if (swap_end) { + char *from = buf; + char *p; + int samps = bytes/2; + p = to = (char *)alloca(bytes); + while (samps--) { + *p++ = *(from+1); + *p++ = *(from); + from += 2; + } + } + + /* Need to do something about sign correction here */ + + do { + written = write(line, to, bytes); + if (written > 0) { + bytes -= written; + to += written; + } + else + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("write error: %s", strerror(errno))); + } while (bytes > 0); + return MUS_NO_ERROR; +} + +int mus_audio_close(int line) +{ + esd_close(line); + if (esd_play_sock == line) esd_play_sock = -1; + else if (esd_rec_sock == line) esd_rec_sock = -1; + return MUS_NO_ERROR; +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + int bytes_read; + + do { + bytes_read = read(line, buf, bytes); + if (bytes_read > 0) { /* 0 -> EOF; we'll regard that as an error */ + bytes -= bytes_read; + buf += bytes_read; + } else + RETURN_ERROR_EXIT(MUS_AUDIO_WRITE_ERROR, -1, + mus_format("read error: %s", strerror(errno))); + } while (bytes > 0); + return MUS_NO_ERROR; +} + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int size) +{ + int esd_prop = ESD_STREAM; + int esd_format; + + if ((esd_format = to_esd_format(format)) == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, audio_out, + mus_format("Can't handle format %d (%s) through esd", + format, mus_data_format_name(format))); + else + esd_prop |= esd_format; + + if (chans < 1 || chans > 2) + RETURN_ERROR_EXIT(MUS_AUDIO_CHANNELS_NOT_AVAILABLE, audio_out, + mus_format("Can't handle format %d channels through esd", + chans)); + else + esd_prop |= chans == 1 ? ESD_MONO : ESD_STEREO; + + esd_rec_sock = esd_play_stream(esd_prop, srate, + NULL, "snd record stream"); + + if (esd_rec_sock == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_DEVICE_NOT_AVAILABLE, audio_out, + mus_format("Device %d (%s) not available", + ur_dev, mus_audio_device_name(ur_dev))); + else + return esd_rec_sock; +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + /* Not really sure what to do here. Mixer is at the other end of the + socket. Needs work. NJB */ + + /* int card = MUS_AUDIO_SYSTEM(ur_dev); */ + int device = MUS_AUDIO_DEVICE(ur_dev); + + if (device == MUS_AUDIO_MIXER) { + val[0] = 0.0; + return MUS_NO_ERROR; + } + + if (field == MUS_AUDIO_PORT) { + val[0] = 1.0; + return MUS_NO_ERROR; + } + + switch (field) { + case MUS_AUDIO_AMP: + /* amplitude value */ + val[0] = 1.0; + break; + case MUS_AUDIO_SAMPLES_PER_CHANNEL: + val[0] = 44100; + break; + case MUS_AUDIO_CHANNEL: + /* number of channels */ + val[0] = 2.0; + if (chan > 1) { + val[1] = 1.0; + val[2] = 2.0; + } + break; + case MUS_AUDIO_SRATE: + /* supported sample rates */ + val[0] = 44100; + if (chan > 1) { + val[1] = 8000; + val[2] = 48000; + } + break; + case MUS_AUDIO_FORMAT: + /* supported formats (ugly...) */ + val[0] = 3.0; + val[1] = MUS_UBYTE; + val[2] = MUS_LSHORT; + val[3] = MUS_BSHORT; + break; + + case MUS_AUDIO_DIRECTION: /* Needs sorting. NJB */ + /* 0-->playback, 1-->capture */ + val[0] = 0; + break; + + default: + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, NULL); + /* return(mus_error(MUS_AUDIO_CANT_READ, NULL)); */ /* Bill 14-Nov-02 -- avoid possibly uncaught throw */ + break; + } + return(MUS_NO_ERROR); +} + + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + /* Ditto */ + val[0] = 0.0; + return MUS_NO_ERROR; +} + +/* pause can be implemented with play.pause and record.pause */ + + +void describe_audio_state_1(void) +{ + pprint("Enlightened Sound Daemon via socket connexion to default host"); +} + +#endif + + +/* ------------------------------- JACK ----------------------------------------- */ + +/* Kjetil S. Matheussen. k.s.matheussen@notam02.no */ +/* Based on code from ceres. */ + +#if HAVE_JACK +#define AUDIO_OK +#include <jack/jack.h> +#include <samplerate.h> +#include <sys/mman.h> +#include <signal.h> + +#if MUS_LITTLE_ENDIAN +# define MUS_COMP_SHORT MUS_LSHORT +# define MUS_COMP_FLOAT MUS_LFLOAT +#else +# define MUS_COMP_SHORT MUS_BSHORT +# define MUS_COMP_FLOAT MUS_BFLOAT +#endif + +#define SRC_QUALITY SRC_SINC_BEST_QUALITY + +/*************/ +/* Jack Part */ +/*************/ + +#define SNDJACK_NUMINCHANNELS 4 + +#define SNDJACK_MAXSNDS 20 + +#define SNDJACK_BUFFERSIZE 32768 + +typedef jack_default_audio_sample_t sample_t; +typedef jack_nframes_t nframes_t; + +struct SndjackChannel{ + jack_port_t *port; + sample_t *buffer; +}; + +static jack_client_t *sndjack_client = NULL; + + +/*************************/ +/* Variables for reading */ +/*************************/ +static int sndjack_num_read_channels_allocated=0; +static int sndjack_num_read_channels_inuse=0; +static struct SndjackChannel *sndjack_read_channels=NULL; +static pthread_cond_t sndjack_read_cond= PTHREAD_COND_INITIALIZER; +static pthread_mutex_t sndjack_read_mutex= PTHREAD_MUTEX_INITIALIZER; +static int sj_r_buffersize=0; +static int sj_r_writeplace=0; +static int sj_r_readplace=0; +static int sj_r_unread=0; +static int sj_r_xrun=0; +static int sj_r_totalxrun=0; + +/*************************/ +/* Variables for writing */ +/*************************/ +static pthread_cond_t sndjack_cond= PTHREAD_COND_INITIALIZER; +static pthread_mutex_t sndjack_mutex= PTHREAD_MUTEX_INITIALIZER; + +enum{SJ_STOPPED,SJ_RUNNING,SJ_ABOUTTOSTOP}; + +// Variables for the ringbuffer: +static int sj_writeplace=0; +static int sj_readplace=0; +static int sj_unread=0; +static int sj_buffersize; +static int sj_jackbuffersize; // number of frames sent to sndjack_process. +static int sj_totalxrun=0; +static int sj_xrun=0; +static int sj_status=SJ_STOPPED; + +static int sndjack_num_channels_allocated=0; +static int sndjack_num_channels_inuse=0; +static struct SndjackChannel *sndjack_channels=NULL; +static int sndjack_read_format; + +static SRC_STATE **sndjack_srcstates; +static double sndjack_srcratio=1.0; + +static int jack_mus_watchdog_counter=0; + + +#define SJ_MAX(a,b) (((a)>(b))?(a):(b)) + +static void sndjack_read_process(jack_nframes_t nframes){ + int i,ch; + sample_t *out[sndjack_num_channels_allocated]; + + if(sndjack_num_read_channels_inuse==0) return; + + for(ch=0;ch<sndjack_num_read_channels_allocated;ch++){ + out[ch]=(sample_t*)jack_port_get_buffer(sndjack_read_channels[ch].port,nframes); + } + + for(i=0;i<nframes;i++){ + if(sj_r_unread==sj_buffersize){ + sj_r_xrun+=nframes-i; + goto exit; + } + for(ch=0;ch<sndjack_num_read_channels_inuse;ch++) + sndjack_read_channels[ch].buffer[sj_r_writeplace]=out[ch][i]; + sj_r_unread++; + sj_r_writeplace++; + if(sj_r_writeplace==sj_r_buffersize) + sj_r_writeplace=0; + } + exit: + pthread_cond_broadcast(&sndjack_read_cond); +} + + +static void sndjack_write_process(jack_nframes_t nframes){ + int ch,i; + sample_t *out[sndjack_num_channels_allocated]; + + for(ch=0;ch<sndjack_num_channels_allocated;ch++){ + out[ch]=(sample_t*)jack_port_get_buffer(sndjack_channels[ch].port,nframes); + } + + if(sj_status==SJ_STOPPED){ + for(ch=0;ch<sndjack_num_channels_allocated;ch++){ + memset(out[ch],0,nframes*sizeof(sample_t)); + } + }else{ + + // First null out unused channels, if any. + if(sndjack_num_channels_inuse==1 && sndjack_num_channels_allocated>=2){ + for(ch=2;ch<sndjack_num_channels_allocated;ch++){ + memset(out[ch],0,nframes*sizeof(sample_t)); + } + }else{ + for(ch=sndjack_num_channels_inuse;ch<sndjack_num_channels_allocated;ch++){ + memset(out[ch],0,nframes*sizeof(sample_t)); + } + } + + for(i=0;i<nframes;i++){ + if(sj_unread==0){ + if(sj_status==SJ_RUNNING) + sj_xrun+=nframes-i; + for(;i<nframes;i++){ + for(ch=0;ch<sndjack_num_channels_inuse;ch++){ + out[ch][i]=0.0f; + } + } + break; + } + + if(sndjack_num_channels_inuse==1 && sndjack_num_channels_allocated>=2){ + for(ch=0;ch<2;ch++){ + out[ch][i]=sndjack_channels[0].buffer[sj_readplace]; + } + }else{ + for(ch=0;ch<sndjack_num_channels_inuse;ch++){ + out[ch][i]=sndjack_channels[ch].buffer[sj_readplace]; + } + } + sj_unread--; + sj_readplace++; + if(sj_readplace==sj_buffersize) + sj_readplace=0; + } + + pthread_cond_broadcast(&sndjack_cond); + + if(sj_status==SJ_ABOUTTOSTOP && sj_unread==0) + sj_status=SJ_STOPPED; + } + +} + + + +static int sndjack_process(jack_nframes_t nframes, void *arg){ + sndjack_read_process(nframes); + sndjack_write_process(nframes); + return 0; +} + + +static int sndjack_read(void *buf,int bytes,int chs){ + int i,ch; + int nframes=bytes / + sndjack_read_format==MUS_COMP_FLOAT ? sizeof(float) : + sndjack_read_format==MUS_COMP_SHORT ? sizeof(short) : + 1; + float *buf_f=buf; + short *buf_s=buf; + char *buf_c=buf; + + for(i=0;i<nframes;i++){ + while(sj_r_unread==0){ + pthread_cond_wait(&sndjack_read_cond,&sndjack_read_mutex); + jack_mus_watchdog_counter++; + } + + if(sj_r_xrun>0){ + sj_r_totalxrun+=sj_r_xrun; + sj_r_xrun=0; + return -1; + } + for(ch=0;ch<chs;ch++){ + switch(sndjack_read_format){ + case MUS_BYTE: + buf_c[i*chs+ch]=sndjack_read_channels[ch].buffer[sj_r_readplace] * 127.9f; + break; + case MUS_COMP_SHORT: + buf_s[i*chs+ch]=sndjack_read_channels[ch].buffer[sj_r_readplace] * 32767.9f; + break; + case MUS_COMP_FLOAT: + buf_f[i*chs+ch]=sndjack_read_channels[ch].buffer[sj_r_readplace]; + break; + }} + sj_r_unread--; + sj_r_readplace++; + if(sj_r_readplace==sj_r_buffersize) + sj_r_readplace=0; + } + return 0; +} + +static void sndjack_write(sample_t **buf,int nframes,int latencyframes,int chs){ + int ch; + int i; + + if(sj_xrun>0){ + if(sj_status==SJ_RUNNING){ + printf("Warning. %d frames delayed.\n",sj_xrun); + sj_totalxrun+=sj_xrun; + } + sj_xrun=0; + } + + for(i=0;i<nframes;i++){ + while( + sj_status==SJ_RUNNING + && (sj_unread==sj_buffersize + || sj_unread >= SJ_MAX(sj_jackbuffersize*2, latencyframes)) + ) + { + jack_mus_watchdog_counter++; + pthread_cond_wait(&sndjack_cond,&sndjack_mutex); + } + + for(ch=0;ch<chs;ch++) + sndjack_channels[ch].buffer[sj_writeplace]=buf[ch][i]; + + sj_unread++; + sj_writeplace++; + if(sj_writeplace==sj_buffersize) + sj_writeplace=0; + } + + if(sj_status==SJ_STOPPED) + if(sj_unread>=sj_jackbuffersize) + sj_status=SJ_RUNNING; +} + +static int sndjack_buffersizecallback(jack_nframes_t nframes, void *arg){ + sj_jackbuffersize=nframes; + return 0; +} + +static int sndjack_getnumoutchannels(void){ + int lokke=0; + const char **ports=jack_get_ports(sndjack_client,NULL,NULL,JackPortIsPhysical|JackPortIsInput); + while(ports!=NULL && ports[lokke]!=NULL){ + lokke++; + } + if(lokke<2) return 2; + return lokke; +} + +static int sndjack_getnuminchannels(void){ + int lokke=0; + const char **ports=jack_get_ports(sndjack_client,NULL,NULL,JackPortIsPhysical|JackPortIsOutput); + while(ports!=NULL && ports[lokke]!=NULL){ + lokke++; + } + if(lokke<2) return 2; + return lokke; +} + + +static int sndjack_init(void){ + int ch; + int numch; + int numch_read; + int num=0; + + while(num<SNDJACK_MAXSNDS){ + char temp[500]; + sprintf(temp,"sndlib%d",num); + if ((sndjack_client=jack_client_new(temp)) != 0) { + break; + } + num++; + } + + if(sndjack_client==NULL){ + /* printf("Unable to create new jack_client\n"); */ + return -1; + } + + pthread_mutex_init(&sndjack_mutex,NULL); + pthread_cond_init(&sndjack_cond,NULL); + pthread_mutex_init(&sndjack_read_mutex,NULL); + pthread_cond_init(&sndjack_read_cond,NULL); + + jack_set_process_callback(sndjack_client,sndjack_process,NULL); + + sndjack_num_channels_allocated = numch = sndjack_getnumoutchannels(); + numch_read=sndjack_getnuminchannels(); + sndjack_num_read_channels_allocated=SJ_MAX(SNDJACK_NUMINCHANNELS,numch_read); + + sndjack_channels=calloc(sizeof(struct SndjackChannel),numch); + sndjack_read_channels=calloc(sizeof(struct SndjackChannel),sndjack_num_read_channels_allocated); + + for(ch=0;ch<numch;ch++){ + sndjack_channels[ch].buffer=calloc(sizeof(sample_t),SNDJACK_BUFFERSIZE); + } + for(ch=0;ch<sndjack_num_read_channels_allocated;ch++){ + sndjack_read_channels[ch].buffer=calloc(sizeof(sample_t),SNDJACK_BUFFERSIZE); + } + sj_buffersize=SNDJACK_BUFFERSIZE; + + for(ch=0;ch<numch;ch++){ + char temp[500]; + sprintf(temp,"out_%d",ch+1); + if((sndjack_channels[ch].port=jack_port_register( + sndjack_client, + strdup(temp), + JACK_DEFAULT_AUDIO_TYPE, + JackPortIsOutput, + 0 + ))==NULL) + { + fprintf(stderr,"Error. Could not register jack port.\n"); + goto failed_register; + } + } + + for(ch=0;ch<sndjack_num_read_channels_allocated;ch++){ + char temp[500]; + sprintf(temp,"in_%d",ch+1); + if((sndjack_read_channels[ch].port=jack_port_register( + sndjack_client, + strdup(temp), + JACK_DEFAULT_AUDIO_TYPE, + JackPortIsInput, + 0 + ))==NULL) + { + fprintf(stderr,"Error. Could not register jack port.\n"); + goto failed_register; + } + } + + + + + sj_jackbuffersize=jack_get_buffer_size(sndjack_client); + jack_set_buffer_size_callback(sndjack_client,sndjack_buffersizecallback,NULL); + + if (jack_activate (sndjack_client)) { + fprintf (stderr, "Error. Cannot activate jack client.\n"); + goto failed_activate; + } + + { + const char **outportnames=jack_get_ports(sndjack_client,NULL,NULL,JackPortIsPhysical|JackPortIsInput); + for(ch=0;outportnames && outportnames[ch]!=NULL && ch<numch;ch++){ + if ( + jack_connect( + sndjack_client, + jack_port_name(sndjack_channels[ch].port), + outportnames[ch] + ) + ) + { + printf ("Warning. Cannot connect jack output port %d: \"%s\".\n",ch,outportnames[ch]); + } + } + } + + { + const char **inportnames=jack_get_ports(sndjack_client,NULL,NULL,JackPortIsPhysical|JackPortIsOutput); + for(ch=0;inportnames && inportnames[ch]!=NULL && ch<numch;ch++){ + if ( + jack_connect( + sndjack_client, + inportnames[ch], + jack_port_name(sndjack_read_channels[ch].port) + ) + ) + { + printf ("Warning. Cannot connect jack input port %d: \"%s\".\n",ch,inportnames[ch]); + } + } + } + return 0; + + // failed_connect: + failed_activate: + jack_deactivate(sndjack_client); + + failed_register: + jack_client_close(sndjack_client); + sndjack_client=NULL; + + return -1; +} +static void sndjack_cleanup(void){ + int ch; + for(ch=0;ch<sndjack_num_channels_allocated;ch++){ + src_delete(sndjack_srcstates[ch]); + } + jack_deactivate(sndjack_client); + jack_client_close(sndjack_client); + +} + + + +/***************/ +/* Sndlib Part */ +/***************/ + +static int sndjack_format; +static sample_t **sndjack_buffer; +static sample_t *sndjack_srcbuffer; + +static int sndjack_dev; +static int sndjack_read_dev; + +/* prototypes for the jack sndlib functions */ +static int jack_mus_audio_initialize(void); +static void jack_mus_oss_set_buffers(int num, int size); +static int jack_mus_audio_systems(void); +static char* jack_mus_audio_system_name(int system); +static char* jack_mus_audio_moniker(void); +static int jack_mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size); +static int jack_mus_audio_open_input(int ur_dev, int srate, int chans, int format, int requested_size); +static int jack_mus_audio_write(int id, char *buf, int bytes); +static int jack_mus_audio_read(int id, char *buf, int bytes); +static int jack_mus_audio_close(int id); +static int jack_mus_audio_mixer_read(int ur_dev, int field, int chan, float *val); +static int jack_mus_audio_mixer_write(int ur_dev, int field, int chan, float *val); +static void jack_describe_audio_state_1(void); + + +static int jack_mus_audio_initialize(void) { + int ch; + + if(audio_initialized){ + return MUS_NO_ERROR; + } + + if(sndjack_init()!=0) + return MUS_ERROR; + + sndjack_buffer=calloc(sizeof(sample_t*),sndjack_num_channels_allocated); + for(ch=0;ch<sndjack_num_channels_allocated;ch++) + sndjack_buffer[ch]=calloc(sizeof(sample_t),SNDJACK_BUFFERSIZE); + sndjack_srcbuffer=calloc(sizeof(sample_t),SNDJACK_BUFFERSIZE); + + sndjack_srcstates=calloc(sizeof(SRC_STATE*),sndjack_num_channels_allocated); + for(ch=0;ch<sndjack_num_channels_allocated;ch++){ + sndjack_srcstates[ch]=src_new(SRC_QUALITY,1,NULL); + } + + atexit(sndjack_cleanup); + + api = JACK_API; + vect_mus_audio_initialize = jack_mus_audio_initialize; + vect_mus_oss_set_buffers = jack_mus_oss_set_buffers; + vect_mus_audio_systems = jack_mus_audio_systems; + vect_mus_audio_system_name = jack_mus_audio_system_name; + vect_mus_audio_moniker = jack_mus_audio_moniker; + vect_mus_audio_open_output = jack_mus_audio_open_output; + vect_mus_audio_open_input = jack_mus_audio_open_input; + vect_mus_audio_write = jack_mus_audio_write; + vect_mus_audio_read = jack_mus_audio_read; + vect_mus_audio_close = jack_mus_audio_close; + vect_mus_audio_mixer_read = jack_mus_audio_mixer_read; + vect_mus_audio_mixer_write = jack_mus_audio_mixer_write; + vect_describe_audio_state_1 = jack_describe_audio_state_1; + + audio_initialized = true; + +#if 0 + + /* Locking all future memory shouldn't be that necessary, and might even freeze the machine in certain situations. */ + /* So remove MCL_FUTURE from the mlockall call. (No. We can't do that. It can screw up code using the realtime extension. -Kjetil.*/ + munlockall(); + //mlockall(MCL_CURRENT); + + // Instead we just do this: (which is not enough, but maybe better than nothing) + { + mlock(sndjack_channels,sizeof(struct SndjackChannel)*sndjack_num_channels_allocated); + mlock(sndjack_read_channels,sizeof(struct SndjackChannel)*sndjack_num_read_channels_allocated); + + for(ch=0;ch<numch;ch++){ + mlock(sndjack_channels[ch].buffer,sizeof(sample_t)*SNDJACK_BUFFERSIZE); + } + for(ch=0;ch<sndjack_num_read_channels_allocated;ch++){ + mlock(sndjack_read_channels[ch].buffer,sizeof(sample_t)*SNDJACK_BUFFERSIZE); + } + } +#endif + + return MUS_NO_ERROR; +} + +// ?? +static void jack_mus_oss_set_buffers(int num, int size){ +} + +static int jack_mus_isrunning=0; +static pid_t jack_mus_player_pid; +static pthread_t jack_mus_watchdog_thread; + +static void *jack_mus_audio_watchdog(void *arg){ + struct sched_param par; + + par.sched_priority = sched_get_priority_max(SCHED_RR); + if(sched_setscheduler(0,SCHED_RR,&par)==-1){ + fprintf(stderr,"SNDLIB: Unable to set SCHED_RR realtime priority for the watchdog thread. No watchdog.\n"); + goto exit; + } + + for(;;){ + int last=jack_mus_watchdog_counter; + sleep(1); + + if(jack_mus_isrunning && jack_mus_watchdog_counter<last+10){ + struct sched_param par; + fprintf(stderr,"SNDLIB: Setting player to non-realtime for 2 seconds.\n"); + + par.sched_priority = 0; + if(sched_setscheduler(jack_mus_player_pid,SCHED_OTHER,&par)==-1){ + fprintf(stderr,"SNDLIB: Unable to set non-realtime priority. Must kill player thread. Sorry!\n"); + while(1){ + kill(jack_mus_player_pid,SIGKILL); + sleep(2); + } + } + + sleep(2); + + if(jack_mus_isrunning){ + par.sched_priority = sched_get_priority_min(SCHED_RR)+1; + if(sched_setscheduler(jack_mus_player_pid,SCHED_RR,&par)==-1){ + fprintf(stderr,"SNDLIB: Could not set back to realtime priority...\n"); + }else + fprintf(stderr,"SNDLIB: Play thread set back to realtime priority.\n"); + } + + } + } + exit: + fprintf(stderr,"SNDLIB: Watchdog exiting\n"); + return NULL; +} + + + +static void jack_mus_audio_set_realtime(void){ + struct sched_param par; + static int watchdog_started=0; + + jack_mus_player_pid=getpid(); + + if(watchdog_started==0){ + if(pthread_create(&jack_mus_watchdog_thread,NULL,jack_mus_audio_watchdog,NULL)!=0){ + fprintf(stderr,"Could not create watchdog. Not running realtime\n"); + return; + } + watchdog_started=1; + } + + jack_mus_isrunning=1; + + par.sched_priority = sched_get_priority_min(SCHED_RR)+1; + if(sched_setscheduler(0,SCHED_RR,&par)==-1){ + fprintf(stderr,"SNDLIB: Unable to set SCHED_RR realtime priority for the player thread.\n"); + }{ + //fprintf(stderr,"Set realtime priority\n"); + } +} + +static void jack_mus_audio_set_non_realtime(void){ + struct sched_param par; + par.sched_priority = 0; + sched_setscheduler(0,SCHED_OTHER,&par); + //fprintf(stderr,"Set non-realtime priority\n"); + jack_mus_isrunning=0; +} + +int jack_mus_audio_open_output(int dev, int srate, int chans, int format, int size){ + if(sndjack_client==NULL){ + if(jack_mus_audio_initialize()==MUS_ERROR) + return MUS_ERROR; + } + + if(sndjack_num_channels_allocated<chans){ + printf("Error. Can not play back %d channels. (Only %d)\n",chans,sndjack_num_channels_allocated); + return MUS_ERROR; + } + + if(format!=MUS_BYTE && format!=MUS_COMP_SHORT && format!=MUS_COMP_FLOAT){ + printf("Error, unable to handle format %s.\n",mus_data_format_to_string(format)); + return MUS_ERROR; + } + + while(sj_status!=SJ_STOPPED) usleep(5); + + sj_unread=0; + sj_writeplace=0; + sj_readplace=0; + + + if(srate!=jack_get_sample_rate(sndjack_client)){ + int lokke; + //printf("Warning, sample-rate differs between snd and jack. Sound will not be played correctly! %d/%d\n",srate,jack_get_sample_rate(sndjack_client)); + sndjack_srcratio=(double)jack_get_sample_rate(sndjack_client)/(double)srate; + for(lokke=0;lokke<chans;lokke++){ + src_reset(sndjack_srcstates[lokke]); + } + }else{ + sndjack_srcratio=1.0; + } + + sndjack_format=format; + sndjack_num_channels_inuse=chans; + sndjack_dev=dev; + + jack_mus_audio_set_realtime(); + + return(MUS_NO_ERROR); +} + +static int sndjack_from_byte(int ch,int chs,char *buf,float *out,int bytes){ + int i; + int len=bytes/chs; + if(len>SNDJACK_BUFFERSIZE) return -1; + + for(i=0;i<len;i++){ + out[i]=MUS_BYTE_TO_SAMPLE(buf[i*chs+ch]); + } + return len; +} + +static int sndjack_from_short(int ch,int chs,short *buf,float *out,int bytes){ + int i; + int len=bytes/(sizeof(short)*chs); + if(len>SNDJACK_BUFFERSIZE) return -1; + + for(i=0;i<len;i++){ + out[i]=(float)buf[i*chs+ch]/32768.1f; + } + return len; +} + +static int sndjack_from_float(int ch,int chs,float *buf,float *out,int bytes){ + int i; + int len=bytes/(sizeof(float)*chs); + if(len>SNDJACK_BUFFERSIZE) return -1; + + for(i=0;i<len;i++){ + out[i]=buf[i*chs+ch]; + } + return len; +} + + +int jack_mus_audio_write(int line, char *buf, int bytes){ + int i; + int ch; + int outlen=0; + + for(ch=0;ch<sndjack_num_channels_inuse;ch++){ + int len = 0; + float *buf2=sndjack_srcratio==1.0?sndjack_buffer[ch]:sndjack_srcbuffer; + + switch(sndjack_format){ + case MUS_BYTE: + len=sndjack_from_byte(ch,sndjack_num_channels_inuse,buf,buf2,bytes); + break; + case MUS_COMP_SHORT: + len=sndjack_from_short(ch,sndjack_num_channels_inuse,(short *)buf,buf2,bytes); + break; + case MUS_COMP_FLOAT: + len=sndjack_from_float(ch,sndjack_num_channels_inuse,(float *)buf,buf2,bytes); + break; + } + if(len<0){ + printf("Errur. Input buffer to large for mus_audio_write.\n"); + return MUS_ERROR; + } + + if(sndjack_srcratio!=1.0){ + SRC_DATA src_data={ + buf2,sndjack_buffer[ch], + len,SNDJACK_BUFFERSIZE, + 0,0, + 0, + sndjack_srcratio + }; + int res=src_process(sndjack_srcstates[ch],&src_data); + if(res!=0){ + printf("Error while resampling. (%s)\n",src_strerror(res)); + return MUS_ERROR; + } + if(src_data.input_frames!=len){ + printf("Unsuccessfull resampling: Should have used %d bytes, used %d.",len,src_data.input_frames); + return MUS_ERROR; + } + if(ch>0 && src_data.output_frames_gen!=outlen){ + printf("Error, src_process did not output the same number of frames as previous resampled channel (%d/%d).\n" + "Please report this problem to k.s.matheussen@notam02.no. Thanks!\n",src_data.output_frames_gen,outlen); + return MUS_ERROR; + } + outlen=src_data.output_frames_gen; + }else{ + outlen=len; + } + } + + + sndjack_write(sndjack_buffer,outlen,outlen*2,sndjack_num_channels_inuse); + + return MUS_NO_ERROR; +} + +int jack_mus_audio_close(int line) +{ + jack_mus_audio_set_non_realtime(); + if(line==sndjack_dev){ + sj_status=SJ_ABOUTTOSTOP; + sndjack_num_channels_inuse=0; + } + return MUS_NO_ERROR; + } + +int jack_mus_audio_mixer_read(int dev, int field, int chan, float *val) +{ + //printf("dev: %d, field: %d, chan: %d\n",dev,field,chan); + + switch(field){ + case MUS_AUDIO_FORMAT: + val[1]=MUS_COMP_FLOAT; + val[0]=1; + break; + case MUS_AUDIO_PORT: + val[0]=1; + val[1]=MUS_AUDIO_DIGITAL_IN; + break; + case MUS_AUDIO_CHANNEL: + val[0]=sndjack_num_read_channels_allocated; + break; + case MUS_AUDIO_AMP: + val[0] = 1.0f; + break; + default: + printf("Got unknown request with field %d %d\n",field, MUS_AUDIO_AMP); + return MUS_ERROR; + } + + return MUS_NO_ERROR; +} + +int jack_mus_audio_mixer_write(int dev, int field, int chan, float *val){ + return(MUS_NO_ERROR); +} + +int jack_mus_audio_open_input(int dev, int srate, int chans, int format, int size){ + if(sndjack_client==NULL){ + if(jack_mus_audio_initialize()==MUS_ERROR) + return MUS_ERROR; + } + + if(sndjack_num_read_channels_allocated<chans){ + printf("Error. Can not record %d channels. (Only %d)\n",chans,sndjack_num_read_channels_allocated); + return MUS_ERROR; + } + + printf("dev: %d\n" ,dev); + if(format!=MUS_BYTE && format!=MUS_COMP_SHORT && format!=MUS_COMP_FLOAT){ + printf("Error, unable to handle format %s.\n",mus_data_format_to_string(format)); + return MUS_ERROR; + } + + if(srate!=jack_get_sample_rate(sndjack_client)){ + printf("Warning, jacks samplerate is %d (and not %d), and the recording will use this samplerate too.\n",jack_get_sample_rate(sndjack_client),srate); + } + + sndjack_read_format=format; + sndjack_num_read_channels_inuse=chans; + sndjack_read_dev=dev; + + return(MUS_NO_ERROR); +} + +int jack_mus_audio_read(int line, char *buf, int bytes){ + if(sndjack_read(buf,bytes,sndjack_num_read_channels_inuse)==-1) + return(MUS_ERROR); + return MUS_NO_ERROR; +} + + +static void jack_describe_audio_state_1(void) { + char temp[500]; + + pprint("jack audio:\n"); + sprintf(temp,"\tNumber of output channels: %d\n",sndjack_num_channels_allocated);pprint(temp); + sprintf(temp,"\tNumber of input channels: %d\n",sndjack_num_read_channels_allocated);pprint(temp); + sprintf(temp,"\tSamplerate: %d\n",jack_get_sample_rate(sndjack_client));pprint(temp); + sprintf(temp,"\tJack buffersize: %d\n",sj_jackbuffersize);pprint(temp); + sprintf(temp,"\tSndjack buffersize: %d\n",SNDJACK_BUFFERSIZE);pprint(temp); + sprintf(temp,"\tMax number of instances: %d\n",SNDJACK_MAXSNDS);pprint(temp); + sprintf(temp,"\tTotal number of frames delayed: %d\n",sj_totalxrun);pprint(temp); + sprintf(temp,"\tCurrent cpu-load: %f\n",jack_cpu_load(sndjack_client));pprint(temp); + sprintf(temp,"\tIs running realtime: %s\n",jack_is_realtime(sndjack_client)==1?"yes":"no");pprint(temp); + sprintf(temp,"\tResample quality (only used when needed): %s (%s)\n",src_get_name(SRC_QUALITY),src_get_description(SRC_QUALITY));pprint(temp); + sprintf(temp,"\tIs able to handle the following audio formats: %s %s %s\n",mus_data_format_to_string(MUS_BYTE),mus_data_format_to_string(MUS_COMP_SHORT),mus_data_format_to_string(MUS_COMP_FLOAT));pprint(temp); + sprintf(temp,"\tPrefered audio format: %s\n",mus_data_format_to_string(MUS_COMP_FLOAT));pprint(temp); +} + + +int jack_mus_audio_systems(void) { + return(2); +} + +char *jack_mus_audio_system_name(int system) {return("linux jack");} +char *jack_mus_audio_moniker(void) {return("jack");} +#endif + + + +/* ------------------------------- HPUX ----------------------------------------- */ + +/* if this is basically the same as the Sun case with different macro names, + * then it could perhaps be updated to match the new Sun version above -- + * Sun version changed 28-Jan-99 + */ + +#if defined(MUS_HPUX) && (!(defined(AUDIO_OK))) +#define AUDIO_OK +#include <sys/audio.h> + +#define RETURN_ERROR_EXIT(Error_Type, Audio_Line, Ur_Error_Message) \ + do { char *Error_Message; Error_Message = Ur_Error_Message; \ + if (Audio_Line != -1) close(Audio_Line); \ + if (Error_Message) \ + {MUS_STANDARD_ERROR(Error_Type, Error_Message); FREE(Error_Message);} \ + else MUS_STANDARD_ERROR(Error_Type, mus_error_type_to_string(Error_Type)); \ + return(MUS_ERROR); \ + } while (false) + +char *mus_audio_moniker(void) {return("HPUX audio");} + +int mus_audio_open_output(int ur_dev, int srate, int chans, int format, int size) +{ + int fd, i, dev; + struct audio_describe desc; + dev = MUS_AUDIO_DEVICE(ur_dev); + fd = open("/dev/audio", O_RDWR); + if (fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, -1, + mus_format("can't open /dev/audio for output: %s", + strerror(errno))); + ioctl(fd, AUDIO_SET_CHANNELS, chans); + if (dev == MUS_AUDIO_SPEAKERS) + ioctl(fd, AUDIO_SET_OUTPUT, AUDIO_OUT_SPEAKER); + else + if (dev == MUS_AUDIO_LINE_OUT) + ioctl(fd, AUDIO_SET_OUTPUT, AUDIO_OUT_LINE); + else ioctl(fd, AUDIO_SET_OUTPUT, AUDIO_OUT_HEADPHONE); + if (format == MUS_BSHORT) + ioctl(fd, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_LINEAR16BIT); + else + if (format == MUS_MULAW) + ioctl(fd, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_ULAW); + else + if (format == MUS_ALAW) + ioctl(fd, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_ALAW); + else + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, fd, + mus_format("can't set output format to %d (%s) for %d (%s)", + format, mus_audio_format_name(format), + dev, + mus_audio_device_name(dev))); + ioctl(fd, AUDIO_DESCRIBE, &desc); + for(i = 0; i < desc.nrates; i++) + if(srate == desc.sample_rate[i]) + break; + if (i == desc.nrates) + RETURN_ERROR_EXIT(SRATE_NOT_AVAILABLE, fd, + mus_format("can't set srate to %d on %d (%s)", + srate, dev, + mus_audio_device_name(dev))); + ioctl(fd, AUDIO_SET_SAMPLE_RATE, srate); + return(fd); +} + +int mus_audio_write(int line, char *buf, int bytes) +{ + write(line, buf, bytes); + return(MUS_NO_ERROR); +} + +int mus_audio_close(int line) +{ + close(line); + return(MUS_NO_ERROR); +} + +static void describe_audio_state_1(void) +{ + struct audio_describe desc; + struct audio_gain gain; + int mina, maxa, fd, tmp; + int g[2]; + fd = open("/dev/audio", O_RDWR); + if (fd == -1) return; + ioctl(fd, AUDIO_GET_OUTPUT, &tmp); + switch (tmp) + { + case AUDIO_OUT_SPEAKER: pprint("output: speakers\n"); break; + case AUDIO_OUT_HEADPHONE: pprint("output: headphone\n"); break; + case AUDIO_OUT_LINE: pprint("output: line out\n"); break; + } + ioctl(fd, AUDIO_GET_INPUT, &tmp); + switch (tmp) + { + case AUDIO_IN_MIKE: pprint("input: mic\n"); break; + case AUDIO_IN_LINE: pprint("input: line in\n"); break; + } + ioctl(fd, AUDIO_GET_DATA_FORMAT, &tmp); + switch (tmp) + { + case AUDIO_FORMAT_LINEAR16BIT: pprint("format: 16-bit linear\n"); break; + case AUDIO_FORMAT_ULAW: pprint("format: mulaw\n"); break; + case AUDIO_FORMAT_ALAW: pprint("format: alaw\n"); break; + } + ioctl(fd, AUDIO_DESCRIBE, &desc); + gain.channel_mask = (AUDIO_CHANNEL_LEFT | AUDIO_CHANNEL_RIGHT); + ioctl(fd, AUDIO_GET_GAINS, &gain); + close(fd); + g[0] = gain.cgain[0].transmit_gain; + g[1] = gain.cgain[1].transmit_gain; + mina = desc.min_transmit_gain; + maxa = desc.max_transmit_gain; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "out vols: %.3f %.3f\n", + (float)(g[0] - mina) / (float)(maxa - mina), + (float)(g[1] - mina) / (float)(maxa - mina)); + pprint(audio_strbuf); + g[0] = gain.cgain[0].receive_gain; + g[1] = gain.cgain[1].receive_gain; + mina = desc.min_receive_gain; + maxa = desc.max_receive_gain; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "in vols: %.3f %.3f\n", + (float)(g[0] - mina) / (float)(maxa - mina), + (float)(g[1] - mina) / (float)(maxa - mina)); + pprint(audio_strbuf); + g[0] = gain.cgain[0].monitor_gain; + g[1] = gain.cgain[1].monitor_gain; + mina = desc.min_monitor_gain; + maxa = desc.max_monitor_gain; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "monitor vols: %.3f %.3f\n", + (float)(g[0] - mina) / (float)(maxa - mina), + (float)(g[1] - mina) / (float)(maxa - mina)); + pprint(audio_strbuf); +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + struct audio_describe desc; + struct audio_gain gain; + int audio_fd = -1, srate, g, maxa, mina, dev, err = MUS_NO_ERROR; + dev = MUS_AUDIO_DEVICE(ur_dev); + if (field == MUS_AUDIO_PORT) + { + val[0] = 4; + if (chan > 1) val[1] = MUS_AUDIO_MICROPHONE; + if (chan > 2) val[2] = MUS_AUDIO_DAC_OUT; + if (chan > 3) val[3] = MUS_AUDIO_LINE_OUT; + if (chan > 4) val[4] = MUS_AUDIO_LINE_IN; + } + else + { + if (field == FORMAT_FIELD) + { + val[0] = 3; + if (chan > 1) val[1] = MUS_BSHORT; + if (chan > 2) val[2] = MUS_MULAW; + if (chan > 3) val[3] = MUS_ALAW; + } + else + { + audio_fd = open("/dev/audio", O_RDWR); + ioctl(audio_fd, AUDIO_DESCRIBE, &desc); + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_AMP: + ioctl(audio_fd, AUDIO_GET_GAINS, &gain); + if (chan == 0) + g = gain.cgain[0].transmit_gain; + else g = gain.cgain[1].transmit_gain; + mina = desc.min_transmit_gain; + maxa = desc.max_transmit_gain; + val[0] = (float)(g - mina) / (float)(maxa - mina); + break; + case MUS_AUDIO_CHANNEL: + val[0] = 2; + break; + case MUS_AUDIO_SRATE: + ioctl(audio_fd, AUDIO_GET_SAMPLE_RATE, &srate); + val[0] = srate; + break; + default: + err = MUS_ERROR; + break; + } + break; + case MUS_AUDIO_MICROPHONE: + case MUS_AUDIO_LINE_IN: + case MUS_AUDIO_DUPLEX_DEFAULT: + switch (field) + { + case MUS_AUDIO_AMP: + ioctl(audio_fd, AUDIO_GET_GAINS, &gain); + if (chan == 0) + g = gain.cgain[0].receive_gain; + else g = gain.cgain[1].receive_gain; + mina = desc.min_receive_gain; + maxa = desc.max_receive_gain; + val[0] = (float)(g - mina) / (float)(maxa - mina); + break; + case MUS_AUDIO_CHANNEL: + val[0] = 2; + break; + case MUS_AUDIO_SRATE: + ioctl(audio_fd, AUDIO_GET_SAMPLE_RATE, &srate); + val[0] = srate; + break; + default: + err = MUS_ERROR; + break; + } + break; + default: + err = MUS_ERROR; + break; + } + } + } + if (err == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't read %s field of device %d (%s)", + mus_audio_device_name(field), + dev, + mus_audio_device_name(dev))); + + if (audio_fd != -1) close(audio_fd); + return(MUS_NO_ERROR); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + struct audio_describe desc; + struct audio_gain gain; + int audio_fd = -1, srate, g, maxa, mina, dev, err = MUS_NO_ERROR; + dev = MUS_AUDIO_DEVICE(ur_dev); + audio_fd = open("/dev/audio", O_RDWR); + ioctl(audio_fd, AUDIO_DESCRIBE, &desc); + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_AMP: + mina = desc.min_transmit_gain; + maxa = desc.max_transmit_gain; + ioctl(audio_fd, AUDIO_GET_GAINS, &gain); + g = mina + val[0] * (maxa - mina); + if (chan == 0) + gain.cgain[0].transmit_gain = g; + else gain.cgain[1].transmit_gain = g; + ioctl(audio_fd, AUDIO_SET_GAINS, &gain); + break; + case MUS_AUDIO_SRATE: + srate = val[0]; + ioctl(audio_fd, AUDIO_SET_SAMPLE_RATE, srate); + break; + default: + err = MUS_ERROR; + break; + } + break; + case MUS_AUDIO_MICROPHONE: + case MUS_AUDIO_LINE_IN: + case MUS_AUDIO_DUPLEX_DEFAULT: + switch (field) + { + case MUS_AUDIO_AMP: + mina = desc.min_receive_gain; + maxa = desc.max_receive_gain; + ioctl(audio_fd, AUDIO_GET_GAINS, &gain); + g = mina + val[0] * (maxa - mina); + if (chan == 0) + gain.cgain[0].receive_gain = g; + else gain.cgain[1].receive_gain = g; + ioctl(audio_fd, AUDIO_SET_GAINS, &gain); + break; + case MUS_AUDIO_SRATE: + srate = val[0]; + ioctl(audio_fd, AUDIO_SET_SAMPLE_RATE, srate); + break; + default: + err = MUS_ERROR; + break; + } + break; + default: + err = MUS_ERROR; + break; + } + if (err == MUS_ERROR) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't set %s field of device %d (%s)", + mus_audio_device_name(field), + dev, + mus_audio_device_name(dev))); + + if (audio_fd != -1) close(audio_fd); + return(MUS_NO_ERROR); +} + +int mus_audio_initialize(void) {return(MUS_NO_ERROR);} + +int mus_audio_systems(void) {return(1);} +char *mus_audio_system_name(int system) {return("HPUX");} + +/* struct audio_status status_b; + * ioctl(devAudio, AUDIO_GET_STATUS, &status_b) + * not_busy = (status_b.transmit_status == AUDIO_DONE); +*/ + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int size) +{ + int fd, i, dev; + struct audio_describe desc; + dev = MUS_AUDIO_DEVICE(ur_dev); + fd = open("/dev/audio", O_RDWR); + if (fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, NULL, + mus_format("can't open /dev/audio for input: %s", + strerror(errno))); + ioctl(fd, AUDIO_SET_CHANNELS, chans); + if (dev == MUS_AUDIO_MICROPHONE) + ioctl(fd, AUDIO_SET_INPUT, AUDIO_IN_MIKE); + else ioctl(fd, AUDIO_SET_INPUT, AUDIO_IN_LINE); + if (format == MUS_BSHORT) + ioctl(fd, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_LINEAR16BIT); + else + if (format == MUS_MULAW) + ioctl(fd, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_ULAW); + else + if (format == MUS_ALAW) + ioctl(fd, AUDIO_SET_DATA_FORMAT, AUDIO_FORMAT_ALAW); + else + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, fd, + mus_format("can't set input format to %d (%s) on %d (%s)", + format, mus_audio_format_name(format), + dev, + mus_audio_device_name(dev))); + ioctl(fd, AUDIO_DESCRIBE, &desc); + for(i = 0; i < desc.nrates; i++) + if(srate == desc.sample_rate[i]) + break; + if (i == desc.nrates) + RETURN_ERROR_EXIT(MUS_AUDIO_SRATE_NOT_AVAILABLE, fd, + mus_format("can't set srate to %d on %d (%s)", + srate, dev, + mus_audio_device_name(dev))); + ioctl(fd, AUDIO_SET_SAMPLE_RATE, srate); + return(fd); +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + read(line, buf, bytes); + return(MUS_NO_ERROR); +} + +#endif + + + +/* ------------------------------- NETBSD ----------------------------------------- */ + +#if defined(MUS_NETBSD) && (!(defined(AUDIO_OK))) +#define AUDIO_OK +/* started from Xanim a long time ago..., bugfixes from Thomas Klausner 30-Jul-05, worked into better shape Aug-05 */ +#include <fcntl.h> +#include <sys/audioio.h> +#include <sys/ioctl.h> + +#define RETURN_ERROR_EXIT(Error_Type, Audio_Line, Ur_Error_Message) \ + do { char *Error_Message; Error_Message = Ur_Error_Message; \ + if (Audio_Line != -1) close(Audio_Line); \ + if (Error_Message) \ + {MUS_STANDARD_ERROR(Error_Type, Error_Message); FREE(Error_Message);} \ + else MUS_STANDARD_ERROR(Error_Type, mus_error_type_to_string(Error_Type)); \ + return(MUS_ERROR); \ + } while (false) + +static int bsd_format_to_sndlib(int encoding) +{ + switch (encoding) + { + case AUDIO_ENCODING_ULAW: return(MUS_MULAW); break; + case AUDIO_ENCODING_ALAW: return(MUS_ALAW); break; + case AUDIO_ENCODING_LINEAR: return(MUS_BSHORT); break; /* "sun compatible" so probably big-endian? */ + case AUDIO_ENCODING_SLINEAR: + case AUDIO_ENCODING_LINEAR8: return(MUS_BYTE); break; + case AUDIO_ENCODING_SLINEAR_LE: return(MUS_LSHORT); break; + case AUDIO_ENCODING_SLINEAR_BE: return(MUS_BSHORT); break; + case AUDIO_ENCODING_ULINEAR_LE: return(MUS_ULSHORT); break; + case AUDIO_ENCODING_ULINEAR_BE: return(MUS_UBSHORT); break; + case AUDIO_ENCODING_ULINEAR: return(MUS_UBYTE); break; + case AUDIO_ENCODING_NONE: + case AUDIO_ENCODING_ADPCM: + default: return(MUS_UNKNOWN); break; + } + return(MUS_UNKNOWN); +} + +static int sndlib_format_to_bsd(int encoding) +{ + switch (encoding) + { + case MUS_MULAW: return(AUDIO_ENCODING_ULAW); break; + case MUS_ALAW: return(AUDIO_ENCODING_ALAW); break; + case MUS_BYTE: return(AUDIO_ENCODING_SLINEAR); break; + case MUS_LSHORT: return(AUDIO_ENCODING_SLINEAR_LE); break; + case MUS_BSHORT: return(AUDIO_ENCODING_SLINEAR_BE); break; + case MUS_ULSHORT: return(AUDIO_ENCODING_ULINEAR_LE); break; + case MUS_UBSHORT: return(AUDIO_ENCODING_ULINEAR_BE); break; + case MUS_UBYTE: return(AUDIO_ENCODING_ULINEAR); break; + } + return(AUDIO_ENCODING_NONE); +} + +int mus_audio_initialize(void) +{ + return(MUS_NO_ERROR); +} + +int mus_audio_systems(void) +{ + return(1); +} + +char *mus_audio_system_name(int system) +{ + return("NetBSD"); +} + +char *mus_audio_moniker(void) +{ + return("NetBSD audio"); +} + +static int cur_chans = 1, cur_srate = 22050; + +int mus_audio_write(int line, char *buf, int bytes) +{ + /* trouble... AUDIO_WSEEK always returns 0, no way to tell that I'm about to + * hit "hiwat", but when I do, it hangs. Can't use AUDIO_DRAIN -- + * it introduces interruptions. Not sure what to do... + */ + int b = 0; + b = write(line, buf, bytes); + usleep(10000); + if ((b != bytes) && (b > 0)) /* b <= 0 presumably some sort of error, and we want to avoid infinite recursion below */ + { + /* hangs at close if we don't handle this somehow */ + if ((cur_chans == 1) || (cur_srate == 22050)) + sleep(1); + else usleep(10000); + mus_audio_write(line, (char *)(buf + b), bytes - b); + } + return(MUS_NO_ERROR); +} + +int mus_audio_close(int line) +{ + usleep(100000); + ioctl(line, AUDIO_FLUSH, 0); + close(line); + return(MUS_NO_ERROR); +} + +static int netbsd_default_outputs = (AUDIO_HEADPHONE | AUDIO_LINE_OUT | AUDIO_SPEAKER); + +void mus_netbsd_set_outputs(int speakers, int headphones, int line_out) +{ + netbsd_default_outputs = 0; + if (speakers) netbsd_default_outputs |= AUDIO_SPEAKER; + if (headphones) netbsd_default_outputs |= AUDIO_HEADPHONE; + if (line_out) netbsd_default_outputs |= AUDIO_LINE_OUT; +} + +int mus_audio_open_output(int dev, int srate, int chans, int format, int size) +{ + int line, encode; + audio_info_t a_info; + + line = open("/dev/sound", O_WRONLY | O_NDELAY); /* /dev/audio assumes mono 8-bit mulaw */ + if (line == -1) + { + if (errno == EBUSY) + return(mus_error(MUS_AUDIO_CANT_OPEN, NULL)); + else return(mus_error(MUS_AUDIO_DEVICE_NOT_AVAILABLE, NULL)); + } + AUDIO_INITINFO(&a_info); + + /* a_info.blocksize = size; */ + encode = sndlib_format_to_bsd(format); + if (encode == AUDIO_ENCODING_NONE) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %d (%s) not available", + format, + mus_data_format_name(format))); + a_info.play.encoding = encode; + a_info.mode = AUMODE_PLAY | AUMODE_PLAY_ALL; + a_info.play.precision = mus_bytes_per_sample(format) * 8; + a_info.play.sample_rate = srate; + if (dev == MUS_AUDIO_LINE_OUT) + a_info.play.port = AUDIO_LINE_OUT; + else + { + if (dev == MUS_AUDIO_SPEAKERS) + a_info.play.port = AUDIO_SPEAKER | (netbsd_default_outputs & AUDIO_HEADPHONE); + else a_info.play.port = netbsd_default_outputs; + } + a_info.play.channels = chans; + ioctl(line, AUDIO_SETINFO, &a_info); + /* actually doesn't set the "ports" field -- always 0 */ + + ioctl(line, AUDIO_GETINFO, &a_info); + + if ((int)(a_info.play.sample_rate) != srate) + mus_print("srate: %d -> %d\n", srate, a_info.play.sample_rate); + if ((int)(a_info.play.encoding) != sndlib_format_to_bsd(format)) + mus_print("encoding: %d -> %d\n", sndlib_format_to_bsd(format), a_info.play.encoding); + if ((int)(a_info.play.channels) != chans) + mus_print("chans: %d -> %d\n", chans, a_info.play.channels); + + cur_chans = chans; + cur_srate = srate; + + return(line); +} + +int mus_audio_read(int line, char *buf, int bytes) +{ + read(line, buf, bytes); + return(MUS_NO_ERROR); +} + +static void describe_audio_state_1(void) +{ + audio_device_t dev; + int i = 0, val, err = 0; + int line; + float amp; + audio_info_t a_info; + audio_encoding_t e_info; + + pprint("NetBSD "); + line = open("/dev/sound", O_WRONLY | O_NDELAY); + if (line == -1) + return; + + pprint("/dev/sound:\n"); + err = ioctl(line, AUDIO_GETDEV, &dev); + if (err == 0) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "%s: version: %s (%s)", dev.name, dev.version, dev.config); + pprint(audio_strbuf); + } + + err = ioctl(line, AUDIO_GETPROPS, &val); + if (err == 0) + { + if (val & AUDIO_PROP_FULLDUPLEX) + pprint(" full-duplex"); + else pprint(" half-duplex"); + } + pprint("\n"); + + err = ioctl(line, AUDIO_GETINFO, &a_info); + if (err == 0) + { + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " play: srate: %d, chans: %d, format: %s (%d bits), ", + a_info.play.sample_rate, + a_info.play.channels, + mus_data_format_short_name(bsd_format_to_sndlib(a_info.play.encoding)), + a_info.play.precision); + pprint(audio_strbuf); + + amp = (float)(a_info.play.gain - AUDIO_MIN_GAIN) / (float)(AUDIO_MAX_GAIN - AUDIO_MIN_GAIN); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "volume: %.3f %.3f (gain: %d, balance: %d)\n", + amp * (1.0 - ((float)(a_info.play.balance) / (float)(2 * AUDIO_MID_BALANCE))), + amp * ((float)(a_info.play.balance) / (float)(2 * AUDIO_MID_BALANCE)), + a_info.play.gain, a_info.play.balance); + pprint(audio_strbuf); + + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " record: srate: %d, chans: %d, format: %s (%d bits), ", + a_info.record.sample_rate, + a_info.record.channels, + mus_data_format_short_name(bsd_format_to_sndlib(a_info.record.encoding)), + a_info.record.precision); + pprint(audio_strbuf); + + amp = (float)(a_info.record.gain - AUDIO_MIN_GAIN) / (float)(AUDIO_MAX_GAIN - AUDIO_MIN_GAIN); + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, "volume: %.3f %.3f (gain: %d, balance: %d)\n", + amp * (1.0 - ((float)(a_info.record.balance) / (float)(2 * AUDIO_MID_BALANCE))), + amp * ((float)(a_info.record.balance) / (float)(2 * AUDIO_MID_BALANCE)), + a_info.record.gain, a_info.record.balance); + pprint(audio_strbuf); + } + + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " available encodings:\n"); + pprint(audio_strbuf); + + for (i = 0; ; i++) + { + e_info.index = i; + err = ioctl(line, AUDIO_GETENC, &e_info); + if (err != 0) break; + mus_snprintf(audio_strbuf, PRINT_BUFFER_SIZE, " %s (%s, bits: %d)\n", + mus_data_format_short_name(bsd_format_to_sndlib(e_info.encoding)), + e_info.name, + e_info.precision); + pprint(audio_strbuf); + } + + close(line); + +#if 0 + /* I don't see anything useful in all this mixer data, so I'll omit it */ + fprintf(stderr,"/dev/mixer:\n"); + line = open("/dev/mixer", O_RDONLY | O_NDELAY); + if (line == -1) + return; + val = ioctl(line, AUDIO_GETDEV, &dev); + fprintf(stderr, "\n%d, name: %s, version: %s, config: %s\n", + val, dev.name, dev.version, dev.config); + for (i = 0; ; i++) + { + mdev.index = i; + val = ioctl(line, AUDIO_MIXER_DEVINFO, &mdev); + if (val != 0) break; + fprintf(stderr,"%d: name: %s ", i, mdev.label.name); + fprintf(stderr,"class: %d, type: %d, units: %s, chans: %d, delta: %d\n", + mdev.mixer_class, mdev.type, mdev.un.v.units.name, mdev.un.v.num_channels, mdev.un.v.delta); + mx.dev = i; + ioctl(line, AUDIO_MIXER_READ, &mx); + switch (mx.type) + { + case AUDIO_MIXER_CLASS: + fprintf(stderr, "mixer read: class type?\n"); + break; + case AUDIO_MIXER_ENUM: + fprintf(stderr, "mixer read: enum: %d\n", mx.un.ord); + break; + case AUDIO_MIXER_SET: + case AUDIO_MIXER_VALUE: + { + int j; + ml = mx.un.value; + fprintf(stderr, "mixer read: level: %d chans [", ml.num_channels); + for (j = 0; j < ml.num_channels; j++) + fprintf(stderr, "%d ", (int)(ml.level[j])); + fprintf(stderr, "]\n"); + } + break; + default: + fprintf(stderr, "mixer read: unknown type? %d\n", mx.type); + break; + } + } +#endif +} + +int mus_audio_mixer_read(int ur_dev, int field, int chan, float *val) +{ + int i, audio_fd, err, dev; + audio_info_t info; + bool ok = true; + + dev = MUS_AUDIO_DEVICE(ur_dev); + AUDIO_INITINFO(&info); + audio_fd = open("/dev/sound", O_RDONLY | O_NONBLOCK, 0); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, -1, + mus_format("can't open /dev/sound: %s", + strerror(errno))); + err = ioctl(audio_fd, AUDIO_GETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't get dac info")); + + if (field == MUS_AUDIO_PORT) + { + val[0] = 1; + val[1] = MUS_AUDIO_MICROPHONE; + } + else + { + if (field == MUS_AUDIO_FORMAT) + { + audio_encoding_t e_info; + for (i = 0; ; i++) + { + e_info.index = i; + err = ioctl(audio_fd, AUDIO_GETENC, &e_info); + if (err != 0) break; + val[i + 1] = bsd_format_to_sndlib(e_info.encoding); + } + val[0] = i; + } + else + { + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_AMP: + { + float amp; + amp = (float)(info.play.gain - AUDIO_MIN_GAIN) / (float)(AUDIO_MAX_GAIN - AUDIO_MIN_GAIN); + if (chan == 0) + val[0] = amp * (1.0 - ((float)(info.play.balance) / (float)(2 * AUDIO_MID_BALANCE))); + else val[0] = amp * ((float)(info.play.balance) / (float)(2 * AUDIO_MID_BALANCE)); + } + break; + case MUS_AUDIO_CHANNEL: + val[0] = 2; + break; + case MUS_AUDIO_SRATE: + val[0] = (float)info.play.sample_rate; + break; + default: + ok = false; + break; + } + break; + case MUS_AUDIO_MICROPHONE: + case MUS_AUDIO_LINE_IN: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_CD: + switch (field) + { + case MUS_AUDIO_AMP: + { + float amp; + amp = (float)(info.record.gain - AUDIO_MIN_GAIN) / (float)(AUDIO_MAX_GAIN - AUDIO_MIN_GAIN); + if (chan == 0) + val[0] = amp * (1.0 - ((float)(info.record.balance) / (float)(2 * AUDIO_MID_BALANCE))); + else val[0] = amp * ((float)(info.record.balance) / (float)(2 * AUDIO_MID_BALANCE)); + } + break; + case MUS_AUDIO_CHANNEL: + val[0] = 1; + break; + case MUS_AUDIO_SRATE: + val[0] = (float)(info.record.sample_rate); + break; + default: + ok = false; + break; + } + break; + default: + ok = false; + break; + } + } + } + if (!ok) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't read %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + return(mus_audio_close(audio_fd)); +} + +int mus_audio_mixer_write(int ur_dev, int field, int chan, float *val) +{ + audio_info_t info; + int dev, audio_fd, err; + bool ok = true; + + dev = MUS_AUDIO_DEVICE(ur_dev); + AUDIO_INITINFO(&info); + + audio_fd = open("/dev/sound", O_RDWR | O_NONBLOCK, 0); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, -1, + mus_format("can't open /dev/sound: %s", + strerror(errno))); + + err = ioctl(audio_fd, AUDIO_GETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_READ, audio_fd, + mus_format("can't get /dev/sound info")); + + switch (dev) + { + case MUS_AUDIO_DEFAULT: + case MUS_AUDIO_DAC_OUT: + case MUS_AUDIO_SPEAKERS: + case MUS_AUDIO_LINE_OUT: + switch (field) + { + case MUS_AUDIO_AMP: + info.play.balance = AUDIO_MID_BALANCE; + info.play.gain = AUDIO_MIN_GAIN + (int)((AUDIO_MAX_GAIN - AUDIO_MIN_GAIN) * val[0]); + break; + case MUS_AUDIO_CHANNEL: + info.play.channels = (int)val[0]; + break; + case MUS_AUDIO_SRATE: + info.play.sample_rate = (int)val[0]; + break; + default: + ok = false; + break; + } + break; + case MUS_AUDIO_MICROPHONE: + switch (field) + { + case MUS_AUDIO_AMP: + info.record.gain = AUDIO_MIN_GAIN + (int)((AUDIO_MAX_GAIN - AUDIO_MIN_GAIN) * val[0]); + info.record.balance = AUDIO_MID_BALANCE; + break; + case MUS_AUDIO_CHANNEL: + info.record.channels = (int)val[0]; + break; + case MUS_AUDIO_SRATE: + info.record.sample_rate = (int)val[0]; + break; + default: + ok = false; + break; + } + break; + case MUS_AUDIO_LINE_IN: + case MUS_AUDIO_DUPLEX_DEFAULT: + case MUS_AUDIO_CD: + switch (field) + { + case MUS_AUDIO_AMP: + info.record.balance = AUDIO_MID_BALANCE; + info.record.gain = AUDIO_MIN_GAIN + (int)((AUDIO_MAX_GAIN - AUDIO_MIN_GAIN) * val[0]); + break; + case MUS_AUDIO_CHANNEL: + info.record.channels = (int)val[0]; + break; + case MUS_AUDIO_SRATE: + info.record.sample_rate = (int)val[0]; + break; + default: + ok = false; + break; + } + break; + default: + ok = false; + break; + } + if (ok) + ioctl(audio_fd, AUDIO_SETINFO, &info); + else + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't write %s field %d (%s)", + mus_audio_device_name(dev), + field, + mus_audio_device_name(field))); + return(mus_audio_close(audio_fd)); +} + +int mus_audio_open_input(int ur_dev, int srate, int chans, int format, int size) +{ + audio_info_t info; + int encode, bits, dev, audio_fd, err; + + dev = MUS_AUDIO_DEVICE(ur_dev); + encode = sndlib_format_to_bsd(format); + bits = 8 * mus_bytes_per_sample(format); + if (encode == AUDIO_ENCODING_NONE) + RETURN_ERROR_EXIT(MUS_AUDIO_FORMAT_NOT_AVAILABLE, -1, + mus_format("format %s not available for recording", + mus_data_format_name(format))); + + if (dev != MUS_AUDIO_DUPLEX_DEFAULT) + audio_fd = open("/dev/sound", O_RDONLY, 0); + else audio_fd = open("/dev/sound", O_RDWR, 0); + if (audio_fd == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_OPEN, -1, + mus_format("can't open /dev/sound: %s", + strerror(errno))); + + AUDIO_INITINFO(&info); + info.record.sample_rate = srate; + info.record.channels = chans; + info.record.precision = bits; + info.record.encoding = encode; + info.record.port = AUDIO_MICROPHONE; + err = ioctl(audio_fd, AUDIO_SETINFO, &info); + if (err == -1) + RETURN_ERROR_EXIT(MUS_AUDIO_CANT_WRITE, audio_fd, + mus_format("can't set up for recording")); + return(audio_fd); +} + +#endif + + + +/* ------------------------------- STUBS ----------------------------------------- */ + +#ifndef AUDIO_OK +static void describe_audio_state_1(void) {pprint("audio stubbed out");} +int mus_audio_open_output(int dev, int srate, int chans, int format, int size) {return(MUS_ERROR);} +int mus_audio_open_input(int dev, int srate, int chans, int format, int size) {return(MUS_ERROR);} +int mus_audio_write(int line, char *buf, int bytes) {return(MUS_ERROR);} +int mus_audio_close(int line) {return(MUS_ERROR);} +int mus_audio_read(int line, char *buf, int bytes) {return(MUS_ERROR);} +int mus_audio_mixer_read(int dev, int field, int chan, float *val) {return(MUS_ERROR);} +int mus_audio_mixer_write(int dev, int field, int chan, float *val) {return(MUS_ERROR);} +int mus_audio_initialize(void) {return(MUS_ERROR);} +int mus_audio_systems(void) {return(0);} +char *mus_audio_system_name(int system) {return("none");} +char *mus_audio_moniker(void) {return("no audio support");} +#endif + + + +static char *save_it = NULL; +static int print_it = 1; +static int save_it_len = 0; +static int save_it_loc = 0; + +static void pprint(char *str) +{ + int i, len; + if ((str) && (*str)) + { + if ((print_it) || (!(save_it))) + { + mus_print(str); + } + else + { + len = strlen(str); + if ((len + save_it_loc + 2) >= save_it_len) + { + save_it_len = (len + save_it_loc + 1024); + save_it = (char *)REALLOC(save_it, save_it_len * sizeof(char)); + } + for (i = 0; i < len; i++) + save_it[save_it_loc++] = str[i]; + save_it[save_it_loc] = 0; + } + } +} + +char *mus_audio_report(void) +{ + mus_audio_initialize(); + if (!(save_it)) + { + save_it_len = 1024; + save_it = (char *)CALLOC(save_it_len, sizeof(char)); + } + save_it_loc = 0; + print_it = 0; + if (!audio_strbuf) audio_strbuf = (char *)CALLOC(PRINT_BUFFER_SIZE, sizeof(char)); + describe_audio_state_1(); + return(save_it); +} + +void mus_audio_describe(void) +{ + mus_audio_initialize(); + print_it = 1; + if (!audio_strbuf) audio_strbuf = (char *)CALLOC(PRINT_BUFFER_SIZE, sizeof(char)); + describe_audio_state_1(); +} + +/* for CLM */ +void mus_reset_audio_c(void) +{ + audio_initialized = false; + save_it = NULL; + version_name = NULL; +#ifdef MUS_SUN + sun_vol_name = NULL; +#endif + save_it_len = 0; + audio_strbuf = NULL; +} + + +int mus_audio_compatible_format(int dev) +{ +#if HAVE_ALSA || HAVE_JACK + int err, i; + float val[32]; + int ival[32]; + err = mus_audio_mixer_read(dev, MUS_AUDIO_FORMAT, 32, val); + if (err != MUS_ERROR) + { + for (i = 0; i <= (int)(val[0]); i++) ival[i] = (int)(val[i]); + /* ^ this cast is vital! Memory clobbered otherwise in LinuxPPC */ + for (i = 1; i <= ival[0]; i++) + if (ival[i] == MUS_AUDIO_COMPATIBLE_FORMAT) + return(MUS_AUDIO_COMPATIBLE_FORMAT); + for (i = 1; i <= ival[0]; i++) + if ((ival[i] == MUS_BINT) || (ival[i] == MUS_LINT) || + (ival[i] == MUS_BFLOAT) || (ival[i] == MUS_LFLOAT) || + (ival[i] == MUS_BSHORT) || (ival[i] == MUS_LSHORT)) + return(ival[i]); + for (i = 1; i <= ival[0]; i++) + if ((ival[i] == MUS_MULAW) || (ival[i] == MUS_ALAW) || + (ival[i] == MUS_UBYTE) || (ival[i] == MUS_BYTE)) + return(ival[i]); + return(ival[1]); + } +#endif + return(MUS_AUDIO_COMPATIBLE_FORMAT); +} + + +/* next two added 17-Dec-02 for non-interleaved audio IO */ +static char *output_buffer = NULL; +static int output_buffer_size = 0; + +int mus_audio_write_buffers(int port, int frames, int chans, mus_sample_t **bufs, int output_format, bool clipped) +{ + int bytes; + bytes = chans * frames * mus_bytes_per_sample(output_format); + if (output_buffer_size < bytes) + { + if (output_buffer) free(output_buffer); + output_buffer = (char *)malloc(bytes); + output_buffer_size = bytes; + } + mus_file_write_buffer(output_format, 0, frames - 1, chans, bufs, output_buffer, clipped); + return(mus_audio_write(port, output_buffer, bytes)); +} + +static char *input_buffer = NULL; +static int input_buffer_size = 0; + +int mus_audio_read_buffers(int port, int frames, int chans, mus_sample_t **bufs, int input_format) +{ + int bytes; + bytes = chans * frames * mus_bytes_per_sample(input_format); + if (input_buffer_size < bytes) + { + if (input_buffer) free(input_buffer); + input_buffer = (char *)malloc(bytes); + input_buffer_size = bytes; + } + mus_audio_read(port, input_buffer, bytes); + return(mus_file_read_buffer(input_format, 0, chans, frames, bufs, input_buffer)); +} |