******************************************************************** Python OSS Module - A Python interface to the Open Sound System API ******************************************************************** Public Domain 1997 Timothy Butler THIS DOCUMENT IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Introduction ************ The oss module provides access to the Open Sound System from the Python programming language. The Open Sound System is a UNIX device driver that allows you to record and play digitized audio, control input and output volume levels, select recording sources, and generate synthesizer commands and midi bytes controlled by a low-level sequencer. It runs on FreeBSD, Linux, BSD/OS, Solaris, and other operating systems. Python is an interpreted, interactive, object-oriented, extensible, and way-cool programming language. An interactive programming environment extended with objects to control your sound card can be a powerful and fun combination. Essential References ==================== This manual does not cover all of the details you need to program the Open Sound System. You should consult the following resources to learn about the Open Sound System. Open Sound System http://www.4front-tech.com/oss.html Open Sound System (OSS) Free http://www.4front-tech.com/usslite/ OSS Programmer's Guide http://www.4front-tech.com/pguide/index.html OSS documentation (contains link to valuable "Hackers Guide to VoxWare") http://www.4front-tech.com/usslite/docs.html You can find more information about Python at Python Home Page http://www.python.org Obtaining the oss Module ======================== You can download the oss Module from http://www.indra.com/~tim/ossmodule Installation ============ The oss module consists entirely of a single C language source file, `ossmodule.c'. You must either 1. compile and link the module into the Python interpreter or 2. create and install a shared library in a directory named by your `PYTHONPATH'. Linking into the Interpreter ---------------------------- 1. Copy `ossmodule.c' into Python's `Modules' directory. > cp ossmodule.c Python-1.4/Modules 2. Edit `Modules/Setup' and add an entry for the oss module. oss ossmodule.c -I/usr/include/machine -I/usr/include/sys You may need to add or change the C preprocessor's search directories so it can find `soundcard.h' on your system. You can also create a shared library this way if you place the module line in the `*shared*' section of the `Setup' file. Read the comments in the `Setup' file for details. 3. Recompile, test, and install the Python interpreter > cd Python-1.4 > make > ./python >> import oss >make bininstall Building a Shared Library ------------------------- You can use the `Makefile' provided with the oss module distribution to compile a shared library. You will have to edit the `Makefile' to match your system. Copy the resulting shared library to a directory named by your `PYTHONPATH'. Feedback ======== Please email bug reports and comments concerning the oss module to `tim@netbox.com'. I am not qualified to answer questions about the OSS itself. Part of the reason I wrote the oss module was to create an environment where I could experiment with and learn about the OSS. If you can't get your sound card to work in the first place I can't help; but you might check out the resources listed above. *Note Essential References::. Design and Implementation ========================= The C language header file, `sys/soundcard.h', defines the OSS API. Most of the API consists of macros which define operations and arguments for the `ioctl()' system call. The oss module implements only the bare minimum to use the API including: Sound device objects. Represent devices such as a mixer, sequencer, and digital audio devices. The sound device objects in the oss module store a file descriptor and their methods typically involve little more than a call to `ioctl()' with the proper arguments. Functions that open and return sound device objects. Module-level variables holding macro "constants". Bitmasks or device numbers that are ultimately provided as arguments to the `ioctl()' calls. Many module-level variables exist in the oss module which correspond to the exact same names of macro constants in `soundcard.h'. For example the value of `oss.SOUND_MIXER_NRDEVICES' is the same as `SOUND_MIXER_NRDEVICES' in `soundcard.h'. "Structure" objects. Hold read-only information about system capabilities. The API operations, such as `SOUND_MIXER_READ_RECMASK', typically translate into methods of sound device objects, such as `mixer.read_recmask()'. The correspondence should be clear from the documentation if not from the names. None of the objects provided by the oss module can serve as base classes. Not every name and data structure provided by `soundcard.h' is available through the oss module. The oss module provides only the interface that is described in the official OSS API documentation. Many parts of `soundcard.h' are either unsupported, obsolete, not portable, or undocumented. The MIDI interface and the /dev/sndstat objects are not provided because these interfaces are simply read and write operations. The oss module was developed using the OSSFree implementation under FreeBSD. Your mileage may vary. Future Development ================== I would like to stick as close as possible to the OSS API as opposed to implementing old or undocumented features. So far, I have provided that part of the API provided implemented by OSSFree. I may add features of the commercial version as an option. As a separate project I'd like to add a layer on top of the oss module (called "possum") that provides graphical interfaces to the sound devices. MIDI protocol support would be handy also. Mixer Programming ***************** Channel Identifiers =================== Channel Numbers --------------- Mixer channels are identified by channel numbers stored in these module-level variables. Each channel number variable has a corresponding "MASK" variable has a single bit set shifted left by the channel number. `SOUND_MIXER_NRDEVICES' number of channels known to OSS [0,30] `SOUND_MIXER_VOLUME' `SOUND_MASK_VOLUME' master output level `SOUND_MIXER_BASS' `SOUND_MASK_BASS' bass level of all output channels `SOUND_MIXER_TREBLE' `SOUND_MASK_TREBLE' treble level of all output channels `SOUND_MIXER_SYNTH' `SOUND_MASK_SYNTH' level of synthesizer (e.g. FM, wave-table) `SOUND_MIXER_PCM' `SOUND_MASK_PCM' output level for audio device (/dev/dsp, /dev/audio) `SOUND_MIXER_SPEAKER' `SOUND_MASK_SPEAKER' volume of PC speaker signal routed through card `SOUND_MIXER_LINE' `SOUND_MASK_LINE' level for line-in jack `SOUND_MIXER_MIC' `SOUND_MASK_MIC' input level from microphone jack `SOUND_MIXER_CD' `SOUND_MASK_CD' input level from CD `SOUND_MIXER_IMIX' `SOUND_MASK_IMIX' output (headphone jack) vol for rec monitor (rec only) `SOUND_MIXER_ALTPCM' `SOUND_MASK_ALTPCM' volume of alternative CODEC device `SOUND_MIXER_RECLEV' `SOUND_MASK_RECLEV' global recording level (rec only) `SOUND_MIXER_IGAIN' `SOUND_MASK_IGAIN' ?? `SOUND_MIXER_OGAIN' `SOUND_MASK_OGAIN' ?? `SOUND_MIXER_LINE1' `SOUND_MASK_LINE1' vendor specific `SOUND_MIXER_LINE2' `SOUND_MASK_LINE2' vendor specific `SOUND_MIXER_LINE3' `SOUND_MASK_LINE3' vendor specific Channel Labels -------------- Two module-level lists, `SOUND_DEVICE_LABELS' and `SOUND_DEVICE_NAMES', store strings that can be used to name channels. These lists can be indexed by channel number (e.g. `SOUND_DEVICE_LABELS[SOUND_MIXER_VOLUME]'). `SOUND_DEVICE_LABELS' channel names that are suitable for user presentation. `SOUND_DEVICE_NAMES' lowercase fixed-size names without spaces. mixer Objects ============= A mixer object controls the volume levels of input and output channels. A mixer object also selects input sources from the microphone, line, and CD inputs. Read and write operations on a mixer's file descriptor are undefined and there are no `read()' or `write()' methods on a mixer. mixer Instantiation ------------------- Create an mixer object using the module function `open_mixer()'. The same mixer device may be opened more than once. An open mixer object will be closed before it is deleted. - Function: open_mixer (FILENAME, FLAGS) Create, open, and return a new mixer object. FILENAME defaults to `"/dev/mixer"'. FLAGS defaults to `FCNTL.O_RDWR'. mixer Methods ------------- - Method on mixer: fileno () Return the file number associated with this mixer. - Method on mixer: close () Free the resources associated with this mixer. Called on deletion if not called explicitly. Do not call any methods of a closed mixer. - Method on mixer: devmask () Return a bitmask of available mixer channels. - Method on mixer: recmask () Return a bitmask of channels that may be used as recording sources. - Method on mixer: stereodevs () Return a bitmask of stereo channels. - Method on mixer: caps () Return a bitmask describing the general capabilities of a mixer. Currently, the module-level constant mask `SOUND_CAP_EXCL_INPUT' is the only mixer capability defined. `SOUND_CAP_EXCL_INPUT' If this bit is set to 1, then only one mixer channel can be selected at the same time. - Method on mixer: read_recsrc () Return a bitmask of active recording sources. - Method on mixer: write_recsrc (MASK) Select recording source channels with a bitmask. If MASK is zero, then the mic input will be used. - Method on mixer: read_channel (CHANNEL_NUM) Return the level (volume) of a channel. The volume is returned as a tuple, ( LEFT, RIGHT ), representing the level of both stereo channels. For mono devices, only LEFT is valid, (the right channel value is set to the left). Levels are between 0 (off) and 100 (maximum), inclusive. - Method on mixer: write_channel (CHANNEL_NUM, LEVEL) Set the level (volume) of a channel. LEVEL may be either a single integer or a tuple (LEFT, RIGHT) with values from 0 (off) to 100 (maximum), inclusive. If LEVEL is a single integer, it is applied to just a mono channel or both sides of a stereo channel. If LEVEL is a tuple, then each side of a stereo channel will be assigned its own level. Mono-devices use the left value of a tuple. `write_channel()' returns a tuple that represents the new level(s) of a channel. Because some mixers will quantize levels with only 3 to 8 bits, the new levels may *not* be exactly the same as what was requested. See the OSS developer's guide for details. Sequencer Programming ********************* sequencer Objects ================= The sequencer object controls the on-board synthesizer using MIDI-like commands and allows I/O through MIDI ports. Synthesizers accept commands that resemble MIDI commands but otherwise have nothing to do with the MIDI capabilities of a soundcard. For example, some synthesizer methods are called `note_on()' and `chn_pressure()' but these do not send bytes out the MIDI port. Instead, they only mimic similar effects with the synthesizers. MIDI I/O support consists entirely of simple commands to read and write individual bytes through specific MIDI ports. MIDI input is not implemented in this version. Read and write operations on a mixer's file descriptor are undefined and there are no `read()' or `write()' methods on a mixer. Many methods of a sequencer generate an "event" (synthesizer command or a MIDI byte) that is written immediately to a buffer in the oss module. As the buffer fills, events will eventually be passed to the driver's queue. The sequencer `dump_buf()' method flushes the module's buffer to the driver's event queue. The sequencer driver processes most events in its queue immediately. The sequencer method `wait_time()' intersperses timing events between other events. When the driver processes a timing event in the queue, it waits until that absolute time before continuing. Note that in order for the sequencer to see the timing event it must be flushed to the event queue using `dump_buf()'. sequencer Instantiation ----------------------- Create an sequencer object using the module function `open_sequencer()'. Only one sequencer may be open at a time; even within the same application. An open sequencer object will be closed before it is deleted. - Function: open_sequencer (FILENAME, FLAGS): Create, open, and return a new sequencer object. FILENAME defaults to `"/dev/sequencer"'. FLAGS defaults to `FCNTL.O_RDWR'. Use `FCNTL.O_WRONLY' for an output-only program so unnecessary functions like MIDI input aren't initialized. Likewise, use `FCNTL.O_RDONLY' for input-only programs. sequencer Methods ----------------- - Method on sequencer: fileno () Return the file number associated with this sequencer. - Method on sequencer: close () Free the resources associated with this sequencer. Called on deletion if not called explicitly. Do not call any methods of a closed sequencer. `close()' shuts off all synthesizer sounds immediately, so you might want to add an extra delay before closing this device. - Method on sequencer: nrsynths () Return the number of internal synthesizer devices. - Method on sequencer: synth_info (OBJ) Describe a specific synthesizer. OBJ may be either an integer device number or a synth_info object with its `device' member initialized. If OBJ is an integer then return a new synth_info object describing the device. If OBJ is an existing synth_info then it is filled in with the description and returned. You must provide a device number that is less than the value returned by the method `nrsynths()'. *Note synth_info Objects:: - Method on sequencer: nrmidis () Return the number of MIDI ports available. - Method on sequencer: midi_info (OBJ) Describe a specific MIDI port. OBJ may be either an integer port number or a midi_info object with its `device' member initialized to the desired MIDI port. If OBJ is an integer then return a new midi_info object describing the port. If OBJ is an existing midi_info then it is filled in with the description and returned. You must provide a port number that is less than the value returned by the `nrmidis()' method. *Note midi_info Objects::. - Method on sequencer: start_timer () EVENT Reset the sequencer's timer. Note that this method generates an *event* that will be processed only when it makes it to the head of the queue. The timer may not be restarted immediately. - Method on sequencer: wait_time (TIME) EVENT Pause the sequencer until TIME. TIME is the absolute time when the driver should continue reading the event queue. Absolute time is measured in units of the kernel timer (typically 100 Hz, 10 ms/tick) from the time the device was opened. Use the `ctrlrate()' method to determine the actual timer resolution. - Method on sequencer: ctrlrate () Return the timer resolution in ticks per second. - Method on sequencer: midiout (MIDI_DEV, BYTE) EVENT Write a byte to a MIDI port. MIDI_DEV the MIDI port number. BYTE either an integer or a single character that is the byte to output. - Method on sequencer: set_patch (DEV, VOICE, PATCH) EVENT Assign synthesizer instrument number (patch) to a voice. - Method on sequencer: start_note (DEV, VOICE, NOTE, VEL=64) EVENT Start a voice on a synthesizer device. NOTE VEL valid MIDI note number and velocity values, [0,127]. Some synthesizers support adjusting the volume of a note (rather than starting a new note) with a NOTE value of 255. A VEL of 255 may specify a volume stored in some synthesizers' internal tables. The use of these values is not portable. - Method on sequencer: stop_note (DEV, VOICE, NOTE, VEL=64) EVENT Stop the synthesizer note being played. NOTE the MIDI note number VEL the speed of the key release. For portability, use the same note number that started the voice. The voice may have already stopped or decayed. The release time is an instrument-specific parameter so the sound may not stop immediately. Consider adding a delay between the final note and the `close()' method, so the last notes have time to decay before being cut off. - Method on sequencer: chn_pressure (DEV, VOICE, PRESSURE) EVENT Change the channel pressure. `chn_pressure()' mimics the pressure used on some MIDI keyboards. The driver translates pressure into the amount of vibrato in OPL-3 voices. PRESSURE may be in the range [0,127]. - Method on sequencer: panning (DEV, VOICE, POS) EVENT Pan the voice between the left and right voice channels. POS is an integer [-128, 127] where -128 is far left, 0 is center, and 127 is far right. The pan position is determined by adding POS to the pan value stored in the instrument parameters and lasts until until the note is stopped. The OPL-3 pan value is simply its volume level. - Method on sequencer: control (VOICE, CONTROLLER, VALUE) EVENT Mimic standard MIDI controllers with the synthesizer. The change may be made before starting a note and lasts until the note is stopped. Once a note is stopped the controller value reverts to its default. Midi controllers that may be supported are: `CTRL_EXPRESSION' expression controller of MIDI with values in the range [0,127]. `CTRL_MAIN_VOLUME' main volume controller with values in the range [0,100]. Note that these values may have different ranges than their standard MIDI counterparts. - Method on sequencer: bender_range (VOICE, VALUE) Define the magnitude of the lowest and highest pitch-bends. VALUE is in units of cents (1/100 of a semitone). Although VALUE may be set larger, the maximum bend is two octaves (1200 cents or 12 semitones). See `pitch_bend()'. - Method on sequencer: pitch_bend (VOICE, VALUE) EVENT Alter the pitch of a sequencer voice. VALUE is in the range [-8192, 8191] representing the pitches of the most extreme low and high bends. The magnitude of the pitch bend is determined by the method `bender_range()'. If you want *value* to be in units of cents (1/100 semitone) then call `bender_range()' with a value of 8192. The value can be assigned before or after starting the note and the effect lasts until the note stops. See `bender_range()'. - Method on sequencer: expression (VOICE, VALUE) EVENT Apply an "expression" MIDI controller to a synthesizer voice. ??? - Method on sequencer: main_volume (VOICE, VALUE) EVENT Apply a "main volume" MIDI controller to a synthesizer voice. ??? synth_info Objects ================== A synth_info object is a description of a synthesizer device. synth_info Instantiation ------------------------ Typically a sequencer's `synth_info()' method creates and returns a synth_info object. You can also create a synth_info (for a sequencer to fill in) with the module-level function `synth_info()'. - Function: synth_info () Return a new, uninitialized synth_info object. synth_info Members ------------------ All of these members are read-only except for `device'. When a synth_info object is printed, it decodes and displays all of its members. This behavior may change in a future release. `name' a string containing the name of the device `device' the device number of the synthesizer This is used only when this synth_info object is passed to a sequencer's `synth_info()' method. `synth_type' integer describing the type of synthesizer. `SYNTH_TYPE_FM' `SYNTH_TYPE_SAMPLE' `SYNTH_TYPE_MIDI' `synth_subtype' integer which may be used to detect the hardware type. `nr_voices' maximum number of voices the device supports in its current mode. If you change the mode, the value will change also. midi_info Objects ================= A midi_info object describes a MIDI port. midi_info Instantiation ----------------------- Typically a sequencer's `midi_info()' method creates and returns a midi_info object. You can also create a midi_info (for a sequencer to fill in) with the module-level function `midi_info()'. - Function: midi_info () Return a new, uninitialized midi_info object. midi_info Members ----------------- All of these members are read-only except for `device'. When a midi_info object is printed, it decodes and displays all of its members. This behavior may change in a future release. `name' a string containing the name of the device `device' the midi port number, less than sequencer.nrmidis(). This is used only when this midi_info object is passed to a sequencer's `midi_info()' method. `dev_type' integer describing the type of sound card where the MIDI port resides. *Note Sound Card ID Numbers::. `capabilities' bit mask describing some MIDI capabilities?? One mask is defined: `MIDI_CAP_MPU401' mask Audio Programming ***************** Audio Formats ============= Audio formats are represented by the following module-level bit-flag values. `AFMT_MU_LAW' logarithmic mu-Law (8-bit) `AFMT_A_LAW' logarithmic A-Law (8-bit) `AFMT_IMA_ADPCM' ADPCM as defined by the Interactive Multimedia Association (IMA). This is *not* the Creative ADPCM format. Requires an average of 4 bits per sample. `AFMT_U8' unsigned 8-bit `AFMT_S16_LE' signed 16-bit little-endian (Intel) `AFMT_S16_BE' signed 16-bit big-endian (Motorola) `AFMT_S8' unsigned 8-bit `AFMT_U16_LE' unsigned 16-bit little-endian `AFMT_U16_BE' unsigned 16-bit big-endian `AFMT_MPEG' MPEG audio format audio Objects ============= An audio object allows you to play and record digitized audio. You do so by writing and reading samples to the audio device. Please be aware that because Python is not as fast as languages that are compiled to machine code, you may have difficulty producing some sounds without output buffer underruns and input overflows. These may manifest themselves as pauses, clicking, humming, or other distortions in the sound. You may have some luck, however, if you use some of the built-in modules and modules compiled from C. Consider using operations in the `array' and `audioop' modules. Before an audio object can be read or written, you must perform at least three operations on it: 1. Set its sample format with the `format()' method. 2. Set the number of channels (mono or stereo) with the `stereo()' method. 3. Set the sample rate with the `speed()' method. These operations must be performed in the order presented above. Please consult the OSS Programmer's Guide for more information. audio Instantiation ------------------- Create an audio object using the module function `open_audio()'. An open audio object will be closed before it is deleted. - Function: open_audio (FILENAME, FLAGS): Create, open, and return a new audio object. FILENAME defaults to `"/dev/audio"'. FLAGS defaults to `FCNTL.O_RDWR'. Use `FCNTL.O_WRONLY' if you intend to only play audio. Likewise, use `FCNTL.O_RDONLY' to only record audio. audio Methods ------------- - Method on audio: fileno () Return the file number associated with this audio object. - Method on audio: close () Free the resources associated with this audio object. Called on deletion if not called explicitly. Do not call any methods of a closed audio object. `close()' performs a `sync()' operation. - Method on audio: reset () Stop the audio device. Once an audio device is reset you may set new format, stereo, and speed parameters. - Method on audio: sync () Wait until the last byte has been played. Once all of the bytes that were written have been played, `sync()' performs a `reset()' on the audio device. - Method on audio: post () Warn the audio device of a pause in the output. - Method on audio: format (FORMAT_FLAG) Select and return the audio format. *Note Audio Formats:: for valid values of FORMAT_FLAG. You should check the return value to ensure that the format you requested is supported. To check the current audio format, pass `AFMT_QUERY' as FORMAT or use the `query_format()' method. - Method on audio: get_formats () Return a mask of all the audio formats supported by this device. *Note Audio Formats::. - Method on audio: query_format () Return the current audio format. This is a shortcut for `format(AFMT_QUERY)'. *Note Audio Formats::. - Method on audio: stereo (IS_STEREO) Set the number of channels. IS_STEREO: 0=mono, 1=stereo - Method on audio: channels (NUM_CHANNELS) Set the number of channels. *This operation is documented in the OSS manuals, but not implemented in my version. -twb* NUM_CHANNELS: 1=mono, 2=stereo - Method on audio: speed (SAMPLING_RATE) Set the sampling rate. Sets and returns the sampling rate that was as close as the device could get to the requested SAMPLING_RATE. - Method on audio: read (BYTES_REQUESTED) Record bytes from the audio device. Returns a string holding the bytes that were read. This may not be the same length as the number of bytes requested. Note that the request is in units of *bytes*, not samples. For example, if the device is configured for 16-bit stereo, you should request multiples of four bytes. - Method on audio: write (SAMPLES) Play a string of samples. SAMPLES is a string holding the bytes that should be written to the audio device. Returns the actual number of bytes that were written. This could be less than the length of SAMPLES. SAMPLES should be a length that is a multiple of the the sample size (#channels * format size). Miscellaneous ************* Sound Card ID Numbers ===================== These module-level variables hold numbers that identify sound cards. `SNDCARD_ADLIB' `SNDCARD_SB' `SNDCARD_PAS' `SNDCARD_GUS' `SNDCARD_MPU401' `SNDCARD_SB16' `SNDCARD_SB16MIDI' `SNDCARD_UART6850' `SNDCARD_GUS16' `SNDCARD_MSS' `SNDCARD_PSS' `SNDCARD_SSCAPE' `SNDCARD_PSS_MPU' `SNDCARD_PSS_MSS' `SNDCARD_SSCAPE_MSS' `SNDCARD_TRXPRO' `SNDCARD_TRXPRO_SB' `SNDCARD_TRXPRO_MPU' `SNDCARD_AWE32' Variable Index ************** * Menu: * AFMT_A_LAW: Audio Formats. * AFMT_IMA_ADPCM: Audio Formats. * AFMT_MPEG: Audio Formats. * AFMT_MU_LAW: Audio Formats. * AFMT_S16_BE: Audio Formats. * AFMT_S16_LE: Audio Formats. * AFMT_S8: Audio Formats. * AFMT_U16_BE: Audio Formats. * AFMT_U16_LE: Audio Formats. * AFMT_U8: Audio Formats. * CTRL_EXPRESSION: sequencer Methods. * CTRL_MAIN_VOLUME: sequencer Methods. * MIDI_CAP_MPU401: midi_info Members. * SNDCARD_ADLIB: Sound Card ID Numbers. * SNDCARD_AWE32: Sound Card ID Numbers. * SNDCARD_GUS: Sound Card ID Numbers. * SNDCARD_GUS16: Sound Card ID Numbers. * SNDCARD_MPU401: Sound Card ID Numbers. * SNDCARD_MSS: Sound Card ID Numbers. * SNDCARD_PAS: Sound Card ID Numbers. * SNDCARD_PSS: Sound Card ID Numbers. * SNDCARD_PSS_MPU: Sound Card ID Numbers. * SNDCARD_PSS_MSS: Sound Card ID Numbers. * SNDCARD_SB: Sound Card ID Numbers. * SNDCARD_SB16: Sound Card ID Numbers. * SNDCARD_SB16MIDI: Sound Card ID Numbers. * SNDCARD_SSCAPE: Sound Card ID Numbers. * SNDCARD_SSCAPE_MSS: Sound Card ID Numbers. * SNDCARD_TRXPRO: Sound Card ID Numbers. * SNDCARD_TRXPRO_MPU: Sound Card ID Numbers. * SNDCARD_TRXPRO_SB: Sound Card ID Numbers. * SNDCARD_UART6850: Sound Card ID Numbers. * SOUND_CAP_EXCL_INPUT: mixer Methods. * SOUND_DEVICE_LABELS: Channel Labels. * SOUND_DEVICE_NAMES: Channel Labels. * SOUND_MASK_ALTPCM: Channel Numbers. * SOUND_MASK_BASS: Channel Numbers. * SOUND_MASK_CD: Channel Numbers. * SOUND_MASK_IGAIN: Channel Numbers. * SOUND_MASK_IMIX: Channel Numbers. * SOUND_MASK_LINE: Channel Numbers. * SOUND_MASK_LINE1: Channel Numbers. * SOUND_MASK_LINE2: Channel Numbers. * SOUND_MASK_LINE3: Channel Numbers. * SOUND_MASK_MIC: Channel Numbers. * SOUND_MASK_OGAIN: Channel Numbers. * SOUND_MASK_PCM: Channel Numbers. * SOUND_MASK_RECLEV: Channel Numbers. * SOUND_MASK_SPEAKER: Channel Numbers. * SOUND_MASK_SYNTH: Channel Numbers. * SOUND_MASK_TREBLE: Channel Numbers. * SOUND_MASK_VOLUME: Channel Numbers. * SOUND_MIXER_ALTPCM: Channel Numbers. * SOUND_MIXER_BASS: Channel Numbers. * SOUND_MIXER_CD: Channel Numbers. * SOUND_MIXER_IGAIN: Channel Numbers. * SOUND_MIXER_IMIX: Channel Numbers. * SOUND_MIXER_LINE: Channel Numbers. * SOUND_MIXER_LINE1: Channel Numbers. * SOUND_MIXER_LINE2: Channel Numbers. * SOUND_MIXER_LINE3: Channel Numbers. * SOUND_MIXER_MIC: Channel Numbers. * SOUND_MIXER_NRDEVICES: Channel Numbers. * SOUND_MIXER_OGAIN: Channel Numbers. * SOUND_MIXER_PCM: Channel Numbers. * SOUND_MIXER_RECLEV: Channel Numbers. * SOUND_MIXER_SPEAKER: Channel Numbers. * SOUND_MIXER_SYNTH: Channel Numbers. * SOUND_MIXER_TREBLE: Channel Numbers. * SOUND_MIXER_VOLUME: Channel Numbers. * SYNTH_TYPE_FM: synth_info Members. * SYNTH_TYPE_MIDI: synth_info Members. * SYNTH_TYPE_SAMPLE: synth_info Members. Function Index ************** * Menu: * bender_range on sequencer: sequencer Methods. * caps on mixer: mixer Methods. * channels on audio: audio Methods. * chn_pressure on sequencer: sequencer Methods. * close on audio: audio Methods. * close on mixer: mixer Methods. * close on sequencer: sequencer Methods. * control on sequencer: sequencer Methods. * ctrlrate on sequencer: sequencer Methods. * devmask on mixer: mixer Methods. * expression on sequencer: sequencer Methods. * fileno on audio: audio Methods. * fileno on mixer: mixer Methods. * fileno on sequencer: sequencer Methods. * format on audio: audio Methods. * get_formats on audio: audio Methods. * main_volume on sequencer: sequencer Methods. * midi_info: midi_info Instantiation. * midi_info on sequencer: sequencer Methods. * midiout on sequencer: sequencer Methods. * nrmidis on sequencer: sequencer Methods. * nrsynths on sequencer: sequencer Methods. * open_audio: audio Instantiation. * open_mixer: mixer Instantiation. * open_sequencer: sequencer Instantiation. * panning on sequencer: sequencer Methods. * pitch_bend on sequencer: sequencer Methods. * post on audio: audio Methods. * query_format on audio: audio Methods. * read on audio: audio Methods. * read_channel on mixer: mixer Methods. * read_recsrc on mixer: mixer Methods. * recmask on mixer: mixer Methods. * reset on audio: audio Methods. * set_patch on sequencer: sequencer Methods. * speed on audio: audio Methods. * start_note on sequencer: sequencer Methods. * start_timer on sequencer: sequencer Methods. * stereo on audio: audio Methods. * stereodevs on mixer: mixer Methods. * stop_note on sequencer: sequencer Methods. * sync on audio: audio Methods. * synth_info: synth_info Instantiation. * synth_info on sequencer: sequencer Methods. * wait_time on sequencer: sequencer Methods. * write on audio: audio Methods. * write_channel on mixer: mixer Methods. * write_recsrc on mixer: mixer Methods.