The cl-mixed Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-mixed Reference Manual

This is the cl-mixed Reference Manual, version 2.0.0, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:25:45 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

About cl-mixed

This is a bindings library to libmixed, an audio mixing and processing library.

How To

Precompiled versions of the underlying library are included in this. If you want to build it manually however, refer to the libmixed repository.

First, set up your input and output parts such as file decoders and audio systems. Handling this is not a part of libmixed. To see an example of how to incorporate them, see the test.lisp file.

Load the system through ASDF or Quicklisp:

(ql:quickload :cl-mixed)

Now you'll need to integrate your inputs and outputs with the Mixed system. In order to do that, you'll want an unpacker and a packer segment. Both of those create "packed-audio", which holds all the information about how the raw audio data is encoded in a byte buffer.

(cl-mixed:make-unpacker c-buffer bytes sample-encoding channel-count channel-layout samplerate)

If you don't already have a byte buffer from your input or output implementation, passing NIL for the c-buffer will automatically create one for you, which you can then access with data. An example call might look like this:

(cl-mixed:make-unpacker NIL 4096 :int16 2 :alternating 44100)

An optional third parameter designates the sample rate of the buffers that the source converts to or the drain converts from. This "buffer sample rate" has to be the same across all segments in a mixer pipeline. It defaults to 44100. Creating a packer looks and works exactly the same as an unpacker.

Next you'll want to create the segments that'll do the actual audio processing you want. For this example, let's create a 3D audio segment (space-mixer) and a fade effect (fader).

(cl-mixed:make-space-mixer)
(cl-mixed:make-fader :duration 5.0)

Next we'll need to create the buffers that are used to manipulate the audio internally and bind them to the appropriate inputs and outputs of our segments.

(cl-mixed:with-buffers 500 (input left right)
  (cl-mixed:connect unpacker :left fader :mono input)
  (setf (cl-mixed:output :right unpacker) right)
  (cl-mixed:connect fader :mono space-mixer 0 input)
  (cl-mixed:connect space-mixer :left packer :left left)
  (cl-mixed:connect space-mixer :right packer :right right)
  ...)

This here means we create three buffers, input, left, and right, each with a size capable of holding 500 samples. We then connect the source's left output to the fader's single input. Then we connect the right buffer to the unpacker's right output, just so that it has both outputs set. If your unpacker only has one channel, you can leave that out. If it has more, you'll have to repeat it for the other channels as well. Next we connect the fader's output as the space-mixer's first input. Finally we connect the left and right outputs of the space-mixer segment to the left and right inputs of the packer respectively. For the fader segment we can connect the same buffer to both input and output, as it is declared to work "in place". For the space-mixer segment we need distinct buffers, hence the extra input buffer.

Now we can create our segment-sequence object, which keeps the order in which to process each segment.

(cl-mixed:make-segment-sequence source fader space drain)

Finally we can move to the main processing loop, which should look as follows:

(cl-mixed:start segment-sequence)
(unwind-protect
    (loop while has-more
          do (process-source)
             (cl-mixed:mix 500 segment-sequence)
             (process-drain))
  (cl-mixed:end segment-sequence))

Where process-source and process-drain are functions that will cause your source to put samples into its buffer and drain to read out the samples from its buffer. Running this now will just give you a fade in effect, which isn't too exciting. Since we haven't actually set or changed any of the 3D audio parameters, that effect remains inaudible. Changing the loop body to read something like the following

for tt = 0 then (+ tt 0.001)
for dx = 0 then (- (* 100 (sin tt)) x)
for dz = 0 then (- (* 50 (cos tt)) z)
for x = (* 100 (sin tt)) then (+ x dx)
for z = (* 50 (cos tt)) then (+ z dz)
do (setf (cl-mixed:input-field :location 0 space-mixer) (list x 0 z))
   (setf (cl-mixed:input-field :velocity 0 space-mixer) (list dx 0 dz))
   (process-source)
   (cl-mixed:mix 500 segment-sequence)
   (process-drain)

Should cause the source to now also circle around the listener as it is fading in. If you change the tt change factor from 0.001 to something higher, it will circle faster, and the doppler effect should become more noticeable.

The following segments are included with the standard libmixed distribution:

See the next section on how to make custom segments.

Creating Custom Segments

While it is perfectly possible to create custom segments in C and load them into your lisp image, you can also write them directly in CL. This may be desired if performance is not crucial or if you want to quickly prototype an effect before translating it to a lower-level language.

In order to create a segment in Lisp, you must subclass virtual and in the very least implement the mix method for it. Here's an example for a very primitive echo effect:

(defclass echo (cl-mixed:virtual)
  ((buffer :initform NIL :accessor buffer)
   (offset :initform 0 :accessor offset)
   (delay :initarg :delay :initform 0.2 :accessor delay)
   (falloff :initarg :falloff :initform 0.8 :accessor falloff)
   (samplerate :initarg :samplerate :initform 44100 :accessor samplerate)))

(defmethod cl-mixed:start ((echo echo))
  (setf (buffer echo) (make-array (ceiling (* (delay echo) (samplerate echo)))
                                  :element-type 'single-float
                                  :initial-element 0.0s0)))

(defmethod cl-mixed:mix (samples (echo echo))
  (let ((out (cl-mixed:data (aref (cl-mixed:outputs echo) 0)))
        (in (cl-mixed:data (aref (cl-mixed:inputs echo) 0)))
        (buf (buffer echo))
        (offset (offset echo))
        (falloff (falloff echo)))
    (loop for i from 0 below samples
          for sample = (cffi:mem-aref in :float i)
          for echo = (aref buf offset)
          do (setf (cffi:mem-aref out :float i) (+ sample echo))
             (setf (aref buf offset) (* (+ sample echo) falloff))
             (setf offset (mod (1+ offset) (length buf))))
    (setf (offset echo) offset)))

In order to achieve the echo effect we keep samples of a given duration around in a ring buffer and then decrease their potency with each iteration while adding the new samples on top. Of course, a more natural sounding echo effect would need more complicated processing than this. Regardless, this segment can now be integrated just the same as the fader segment from the above introductory code.

Concepts

Buffer

A buffer holds an array of float-encoded audio samples. Everything within libmixed deals in float samples and reads from these buffers and/or writes to these buffers. This means everything that processes audio will be able to work within the same constraints of 32-bit float encoded samples, without having to worry about different sample rates, sample encodings, or channel layouts. Buffers have a fixed number of samples that they can hold, which should typically be consistent throughout the entire system.

Packed-Audio

The packed-audio is a representation of audio data that is packed into a single array and isn't in the standard buffer format. Many libraries that decode or encode audio files, play audio back, or process audio in some other way expect a single audio sample array of a particular samplerate, sample encoding, and channel layout, rather than the standardised sample buffers that libmixed uses. The packed-audio allows you to handle the conversion from this single array, encoded format, to the buffer format of libmixed and back.

Particularly relevant are the unpacker and packer segments, which you can use to handle the edges of the pipeline where other libraries interact with libmixed.

Segment

Libmixed allows you to define a pipeline to process audio in. This pipeline -- or graph, if you will -- is pieced together by segments that exchange data between each other through buffers. Each segment has a number of inputs, outputs, and fields that you can set and get. Every input and output can also have a differing amount of applicable fields, but each must have at least the buffer field, which designates the buffer that is connected at that point. You can retrieve information about how many inputs and outputs the segment expects or supports as well as information about the fields it understands by using the info function on a segment.

Aside from the inputs, outputs, and fields, each segment has three methods that are central to the mixing of audio: start, mix, and end. start and end allow you to prepare and clean up work shortly before and after mixing has been done. This can be important for real-time audio processing that cannot afford long pauses. The mix method performs the actual mixing operation and should cause new samples to appear in the outputs' buffers.

Mixer

Mixers are segments that take a run-time variable number of inputs and mix them together to a single output per channel. Libmixed provides two standard mixers out of the box, basic-mixer and space-mixer, which should serve most needs.

Segment-Sequence

A segment-sequence simply ties together a number of segments and performs the start, mix, and end operations in the order the segments were added to the sequence. This is mostly for convenience, in order to quickly perform the actual mixing, once the pipeline has been completely assembled already.

Also See


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-mixed

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shirakumo/cl-mixed

License

Artistic

Description

Bindings to libmixed, a sound mixing and processing library.

Version

2.0.0

Dependencies
Source

cl-mixed.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 cl-mixed/segments

Dependency

segment-sequence.lisp (file)

Parent

cl-mixed (system)

Location

segments/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 cl-mixed.asd

Location

cl-mixed.asd

Systems

cl-mixed (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 cl-mixed/package.lisp

Parent

cl-mixed (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 cl-mixed/low-level.lisp

Dependency

package.lisp (file)

Parent

cl-mixed (system)

Location

low-level.lisp

Exported Definitions
Internal Definitions

*here* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 cl-mixed/toolkit.lisp

Dependency

low-level.lisp (file)

Parent

cl-mixed (system)

Location

toolkit.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 cl-mixed/c-object.lisp

Dependency

toolkit.lisp (file)

Parent

cl-mixed (system)

Location

c-object.lisp

Exported Definitions
Internal Definitions

*c-object-table* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 cl-mixed/buffer.lisp

Dependency

c-object.lisp (file)

Parent

cl-mixed (system)

Location

buffer.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 cl-mixed/packed-audio.lisp

Dependency

buffer.lisp (file)

Parent

cl-mixed (system)

Location

packed-audio.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 cl-mixed/segment.lisp

Dependency

packed-audio.lisp (file)

Parent

cl-mixed (system)

Location

segment.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 cl-mixed/mixer.lisp

Dependency

segment.lisp (file)

Parent

cl-mixed (system)

Location

mixer.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 cl-mixed/segment-sequence.lisp

Dependency

mixer.lisp (file)

Parent

cl-mixed (system)

Location

segment-sequence.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 cl-mixed/segments/basic-mixer.lisp

Parent

segments (module)

Location

segments/basic-mixer.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 cl-mixed/segments/delay.lisp

Parent

segments (module)

Location

segments/delay.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 cl-mixed/segments/fader.lisp

Parent

segments (module)

Location

segments/fader.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 cl-mixed/segments/frequency-pass.lisp

Parent

segments (module)

Location

segments/frequency-pass.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.15 cl-mixed/segments/generator.lisp

Parent

segments (module)

Location

segments/generator.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.16 cl-mixed/segments/ladspa.lisp

Parent

segments (module)

Location

segments/ladspa.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.17 cl-mixed/segments/noise.lisp

Parent

segments (module)

Location

segments/noise.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.18 cl-mixed/segments/packer.lisp

Parent

segments (module)

Location

segments/packer.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.19 cl-mixed/segments/pitch.lisp

Parent

segments (module)

Location

segments/pitch.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.20 cl-mixed/segments/repeat.lisp

Parent

segments (module)

Location

segments/repeat.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.21 cl-mixed/segments/space-mixer.lisp

Parent

segments (module)

Location

segments/space-mixer.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.22 cl-mixed/segments/unpacker.lisp

Parent

segments (module)

Location

segments/unpacker.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.23 cl-mixed/segments/virtual.lisp

Parent

segments (module)

Location

segments/virtual.lisp

Exported Definitions
Internal Definitions

free-handle (method)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.24 cl-mixed/segments/volume-control.lisp

Parent

segments (module)

Location

segments/volume-control.lisp

Exported Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.25 cl-mixed/documentation.lisp

Dependency

segments (module)

Parent

cl-mixed (system)

Location

documentation.lisp


Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 cl-mixed

Source

package.lisp (file)

Nickname

org.shirakumo.fraf.mixed

Use List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

5.2 cl-mixed-cffi

Source

package.lisp (file)

Nickname

org.shirakumo.fraf.mixed.cffi

Use List
Exported Definitions
Internal Definitions

*here* (special variable)


Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *default-samplerate*

This variable holds the default sample rate used throughout.

This is set to 44100 for 44.1 kHz, which is
the standard sample rate for CD audio and should
thus be of sufficient quality for most purposes.

Package

cl-mixed

Source

toolkit.lisp (file)

Special Variable: *static*

Variable containing the path to the static directory. That directory contains the precompiled library binaries.

Package

cl-mixed-cffi

Source

low-level.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: with-buffers SIZE BUFFERS &body BODY

Create a number of buffers for the duration of the body.

BUFFERS should be a list of symbols, to each of which a fresh instance of a BUFFER with a size of SAMPLES will be bound.

Package

cl-mixed

Source

buffer.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: buffer-data POINTER-TO-BUFFER
Function: (setf buffer-data) VALUE POINTER-TO-BUFFER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: buffer-from-packed-audio CHANNEL BUFFERS SAMPLES VOLUME
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: buffer-size POINTER-TO-BUFFER
Function: (setf buffer-size) VALUE POINTER-TO-BUFFER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: buffer-to-packed-audio BUFFERS CHANNEL SAMPLES VOLUME
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: clear-buffer BUFFER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: copy-buffer FROM TO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-data POINTER-TO-SEGMENT
Function: (setf direct-segment-data) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-end POINTER-TO-SEGMENT
Function: (setf direct-segment-end) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-free POINTER-TO-SEGMENT
Function: (setf direct-segment-free) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-get POINTER-TO-SEGMENT
Function: (setf direct-segment-get) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-get-in POINTER-TO-SEGMENT
Function: (setf direct-segment-get-in) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-get-out POINTER-TO-SEGMENT
Function: (setf direct-segment-get-out) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-info POINTER-TO-SEGMENT
Function: (setf direct-segment-info) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-mix POINTER-TO-SEGMENT
Function: (setf direct-segment-mix) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-set POINTER-TO-SEGMENT
Function: (setf direct-segment-set) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-set-in POINTER-TO-SEGMENT
Function: (setf direct-segment-set-in) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-set-out POINTER-TO-SEGMENT
Function: (setf direct-segment-set-out) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: direct-segment-start POINTER-TO-SEGMENT
Function: (setf direct-segment-start) VALUE POINTER-TO-SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: error ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: error-string ERROR
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: field-info-description POINTER-TO-FIELD-INFO
Function: (setf field-info-description) VALUE POINTER-TO-FIELD-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: field-info-field POINTER-TO-FIELD-INFO
Function: (setf field-info-field) VALUE POINTER-TO-FIELD-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: field-info-flags POINTER-TO-FIELD-INFO
Function: (setf field-info-flags) VALUE POINTER-TO-FIELD-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: field-info-type POINTER-TO-FIELD-INFO
Function: (setf field-info-type) VALUE POINTER-TO-FIELD-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: field-info-type-count POINTER-TO-FIELD-INFO
Function: (setf field-info-type-count) VALUE POINTER-TO-FIELD-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: free-buffer BUFFER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: free-segment SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: free-segment-sequence SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-basic-mixer CHANNELS

Create a new basic mixer, adding the given buffers as inputs.

See BASIC-MIXER
See ADD
See WITHDRAW

Package

cl-mixed

Source

basic-mixer.lisp (file)

Function: make-buffer SIZE

Create a new buffer capable of storing SIZE floats.

See BUFFER

Package

cl-mixed

Source

buffer.lisp (file)

Function: make-buffer SIZE BUFFER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-delay &rest ARGS &key TIME SAMPLERATE

Create a new delay segment.

See DELAY

Package

cl-mixed

Source

delay.lisp (file)

Function: make-fader &rest ARGS &key FROM TO TIME TYPE SAMPLERATE

Create a new volume fader segment.

See FADER

Package

cl-mixed

Source

fader.lisp (file)

Function: make-frequency-pass &rest ARGS &key PASS CUTOFF SAMPLERATE

Create a new frequency pass segment.

PASS can be either :high or :low, which will cause high and low frequencies to pass through the filter respectively.

See FREQUENCY-PASS

Package

cl-mixed

Source

frequency-pass.lisp (file)

Function: make-generator &rest ARGS &key TYPE FREQUENCY SAMPLERATE

Create a new tone generator.

See GENERATOR

Package

cl-mixed

Source

generator.lisp (file)

Function: make-ladspa &rest ARGS &key FILE INDEX SAMPLERATE &allow-other-keys

Create a new LADSPA segment.

The file must point to a valid shared library and the index should designate the requested plugin with the library.

Any additional keys are used to set the corresponding fields on the segments, allowing you to directly configure the LADSPA plugin in the same call.

See LADSPA

Package

cl-mixed

Source

ladspa.lisp (file)

Function: make-noise &rest ARGS &key TYPE

Create a new noise segment.

The type can be one of :WHITE, :PINK, :BROWN.

See NOISE

Package

cl-mixed

Source

noise.lisp (file)

Function: make-packed-audio DATA SIZE ENCODING CHANNELS LAYOUT SAMPLERATE

Create a new packed-audio object.

If DATA is NIL, then a new data buffer is allocated with SIZE number of bytes. This data buffer will be automatically freed whenever the pack is freed.

See PACKED-AUDIO

Package

cl-mixed

Source

packed-audio.lisp (file)

Function: make-packer DATA SIZE ENCODING CHANNELS LAYOUT SOURCE-SAMPLERATE &optional TARGET-SAMPLERATE

Create a new packer segment.

This automatically creates a packed-audio object to use. If you prefer to use a packed-audio object you created yourself, simply use MAKE-INSTANCE instead.

See PACKED-AUDIO
See PACKER

Package

cl-mixed

Source

packer.lisp (file)

Function: make-pitch &rest ARGS &key PITCH SAMPLERATE

Create a new pitch shifting segment.

See PITCH

Package

cl-mixed

Source

pitch.lisp (file)

Function: make-repeat &rest ARGS &key TIME SAMPLERATE

Create a new repeat segment.

The time designates the size of the internal buffer that it can repeat to the output.

See REPEAT

Package

cl-mixed

Source

repeat.lisp (file)

Function: make-segment-basic-mixer CHANNELS SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-delay TIME SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-fade FROM TO TIME TYPE SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-frequency-pass PASS CUTOFF SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-generator TYPE FREQUENCY SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-ladspa FILE INDEX SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-noise TYPE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-packer PACKED SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-pitch PITCH SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-repeat TIME SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-sequence &rest SEGMENTS

Create a new segment-sequence instance.

The segments given are added in order.

See SEGMENT-SEQUENCE

Package

cl-mixed

Source

segment-sequence.lisp (file)

Function: make-segment-space-mixer SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-unpacker PACKED SAMPLERATE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-segment-volume-control VOLUME PAN SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: make-space-mixer &rest ARGS &key SAMPLERATE UP SOUNDSPEED DOPPLER-FACTOR MIN-DISTANCE MAX-DISTANCE ROLLOFF ATTENUATION

Create a new space-mixer segment for 3D audio processing.

See SPACE-MIXER

Package

cl-mixed

Source

space-mixer.lisp (file)

Function: make-unpacker DATA SIZE ENCODING CHANNELS LAYOUT UNPACKER-SAMPLERATE &optional TARGET-SAMPLERATE

Create a new unpacker segment.

This automatically creates a packed-audi object to use. If you prefer to use a packed-audio object you created yourself, simply use MAKE-INSTANCE instead.

See PACKED-AUDIO
See UNPACKER

Package

cl-mixed

Source

unpacker.lisp (file)

Function: make-volume-control &rest ARGS &key VOLUME PAN

Create a new volume control segment.

See VOLUME-CONTROL

Package

cl-mixed

Source

volume-control.lisp (file)

Function: packed-audio-channels POINTER-TO-PACKED-AUDIO
Function: (setf packed-audio-channels) VALUE POINTER-TO-PACKED-AUDIO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: packed-audio-data POINTER-TO-PACKED-AUDIO
Function: (setf packed-audio-data) VALUE POINTER-TO-PACKED-AUDIO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: packed-audio-encoding POINTER-TO-PACKED-AUDIO
Function: (setf packed-audio-encoding) VALUE POINTER-TO-PACKED-AUDIO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: packed-audio-layout POINTER-TO-PACKED-AUDIO
Function: (setf packed-audio-layout) VALUE POINTER-TO-PACKED-AUDIO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: packed-audio-samplerate POINTER-TO-PACKED-AUDIO
Function: (setf packed-audio-samplerate) VALUE POINTER-TO-PACKED-AUDIO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: packed-audio-size POINTER-TO-PACKED-AUDIO
Function: (setf packed-audio-size) VALUE POINTER-TO-PACKED-AUDIO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: pointer->object POINTER

Accessor to the object associated with the given foreign pointer.

See *C-OBJECT-TABLE*

Package

cl-mixed

Source

c-object.lisp (file)

Writer

(setf pointer->object) (function)

Function: (setf pointer->object) OBJECT POINTER
Package

cl-mixed

Source

c-object.lisp (file)

Reader

pointer->object (function)

Function: resample-cubic IN IN-SAMPLERATE OUT OUT-SAMPLERATE OUT-SAMPLES
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: resample-linear IN IN-SAMPLERATE OUT OUT-SAMPLERATE OUT-SAMPLES
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: resample-nearest IN IN-SAMPLERATE OUT OUT-SAMPLERATE OUT-SAMPLES
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: resize-buffer SIZE BUFFER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: samplesize ENCODING

Return the number of bytes required to represent a sample in the given format.

Acceptable values are
:INT8 :UINT8 :INT16 :UINT16 :INT24 :UINT24 :INT32 :UINT32
:FLOAT :DOUBLE

Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-end SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-get FIELD VALUE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-get-in FIELD LOCATION VALUE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-get-out FIELD LOCATION VALUE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-description POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-description) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-fields POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-fields) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-flags POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-flags) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-max-inputs POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-max-inputs) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-min-inputs POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-min-inputs) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-name POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-name) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-info-outputs POINTER-TO-SEGMENT-INFO
Function: (setf segment-info-outputs) VALUE POINTER-TO-SEGMENT-INFO
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-mix SAMPLES SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-add SEGMENT MIXER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-count POINTER-TO-SEGMENT-SEQUENCE
Function: (setf segment-sequence-count) VALUE POINTER-TO-SEGMENT-SEQUENCE
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-end MIXER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-mix SAMPLES MIXER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-remove SEGMENT MIXER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-segments POINTER-TO-SEGMENT-SEQUENCE
Function: (setf segment-sequence-segments) VALUE POINTER-TO-SEGMENT-SEQUENCE
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-size POINTER-TO-SEGMENT-SEQUENCE
Function: (setf segment-sequence-size) VALUE POINTER-TO-SEGMENT-SEQUENCE
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-sequence-start MIXER
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-set FIELD VALUE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-set-in FIELD LOCATION VALUE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-set-out FIELD LOCATION VALUE SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Function: segment-start SEGMENT
Package

cl-mixed-cffi

Source

low-level.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: add BUFFER SEGMENT

Add the object to the given collection.

For segment-sequences this means adding a segment to the sequence. For mixers this means adding another input buffer.

See SEGMENT-SEQUENCE
See MIXER

Package

cl-mixed

Methods
Method: add (NEW segment) (SEGMENT space-mixer)
Source

space-mixer.lisp (file)

Method: add (NEW segment) (SEGMENT basic-mixer)
Source

basic-mixer.lisp (file)

Method: add (SEGMENT segment) (SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: add (BUFFER buffer) (SEGMENT mixer)
Source

mixer.lisp (file)

Generic Function: bypass SEGMENT2

Accessor to whether the segment is bypassed or not.

A bypassed segment does not perform any operations when mixed. The exact effects of this varies per segment, but usually for a segment that transforms its inputs somehow this will mean that it just copies the input to the output verbatim.

Note that not all segments support bypassing. Check the :FIELDS value in the field’s info plist.

See SEGMENT
See INFO

Package

cl-mixed

Writer

(setf bypass) (generic function)

Methods
Method: bypass (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: bypass (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: bypass (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: bypass (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: bypass (SEGMENT2 packer)
Source

packer.lisp (file)

Method: bypass (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: bypass (SEGMENT2 fader)
Source

fader.lisp (file)

Method: bypass (SEGMENT2 delay)
Source

delay.lisp (file)

Generic Function: (setf bypass) VALUE1 SEGMENT2
Package

cl-mixed

Reader

bypass (generic function)

Methods
Method: (setf bypass) VALUE1 (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 packer)
Source

packer.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf bypass) VALUE1 (SEGMENT2 delay)
Source

delay.lisp (file)

Generic Function: channels PACKED-AUDIO

Accessor to the number of channels encoded in the data buffer in the object.

See PACKED-AUDIO

Package

cl-mixed

Writer

(setf channels) (generic function)

Methods
Method: channels (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: channels (PACKER packer)
Source

packer.lisp (file)

Method: channels (BASIC-MIXER basic-mixer)

automatically generated reader method

Source

basic-mixer.lisp (file)

Method: channels (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: (setf channels) VALUE0 PACKED-AUDIO
Package

cl-mixed

Reader

channels (generic function)

Methods
Method: (setf channels) VALUE0 (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: (setf channels) VALUE0 (PACKER packer)
Source

packer.lisp (file)

Method: (setf channels) NEW-VALUE (BASIC-MIXER basic-mixer)

automatically generated writer method

Source

basic-mixer.lisp (file)

Method: (setf channels) VALUE0 (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: clear BUFFER

Clears the buffer to fill its data array with just zeroes.

See BUFFER

Package

cl-mixed

Methods
Method: clear (BUFFER buffer)
Source

buffer.lisp (file)

Generic Function: connect SOURCE SOURCE-LOCATION DRAIN DRAIN-LOCATION BUFFER

Connect two segments together by connecting their respective input and output to a specific buffer.

See INPUT
See OUTPUT
See SEGMENT

Package

cl-mixed

Methods
Method: connect (SOURCE segment) SOURCE-LOCATION (DRAIN segment) DRAIN-LOCATION BUFFER
Source

segment.lisp (file)

Generic Function: cutoff SEGMENT2

Accessor to the cutoff frequency of the frequency-pass segment.

See FREQUENCY-PASS

Package

cl-mixed

Writer

(setf cutoff) (generic function)

Methods
Method: cutoff (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Generic Function: (setf cutoff) VALUE1 SEGMENT2
Package

cl-mixed

Reader

cutoff (generic function)

Methods
Method: (setf cutoff) VALUE1 (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Generic Function: data BUFFER

Accessor to the raw data array contained in the object.

See BUFFER
See PACKED-AUDIO

Package

cl-mixed

Writer

(setf data) (generic function)

Methods
Method: data (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: data (PACKER packer)
Source

packer.lisp (file)

Method: data (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Method: data (BUFFER buffer)
Source

buffer.lisp (file)

Generic Function: (setf data) VALUE0 BUFFER
Package

cl-mixed

Reader

data (generic function)

Methods
Method: (setf data) VALUE0 (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: (setf data) VALUE0 (PACKER packer)
Source

packer.lisp (file)

Method: (setf data) VALUE0 (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Method: (setf data) VALUE0 (BUFFER buffer)
Source

buffer.lisp (file)

Generic Function: direction SEGMENT2

Accessor for the direction the listener is facing in space.

To set a vector, the value should be a list or a vector of three floats. When reading, the returned value is always a vector of three floats.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf direction) (generic function)

Methods
Method: direction (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf direction) VALUE1 SEGMENT2
Package

cl-mixed

Reader

direction (generic function)

Methods
Method: (setf direction) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: doppler-factor SEGMENT2

Accessor to the over-/under-statement factor of the doppler effect.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf doppler-factor) (generic function)

Methods
Method: doppler-factor (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf doppler-factor) VALUE1 SEGMENT2
Package

cl-mixed

Reader

doppler-factor (generic function)

Methods
Method: (setf doppler-factor) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: duration SEGMENT2

Accessor to the duration of the segment’s effect.

Must be measured in seconds.

See FADER
See DELAY
See REPEAT

Package

cl-mixed

Writer

(setf duration) (generic function)

Methods
Method: duration (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: duration (SEGMENT2 fader)
Source

fader.lisp (file)

Method: duration (SEGMENT2 delay)
Source

delay.lisp (file)

Generic Function: (setf duration) VALUE1 SEGMENT2
Package

cl-mixed

Reader

duration (generic function)

Methods
Method: (setf duration) VALUE1 (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf duration) VALUE1 (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf duration) VALUE1 (SEGMENT2 delay)
Source

delay.lisp (file)

Generic Function: encoding PACKED-AUDIO

Accessor to the sample encoding of the raw data buffer in the object.

The encoding has to be one of the following:
:INT8 :UINT8 :INT16 :UINT16 :INT24 :UINT24 :INT32 :UINT32
:FLOAT :DOUBLE

See PACKED-AUDIO

Package

cl-mixed

Writer

(setf encoding) (generic function)

Methods
Method: encoding (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: encoding (PACKER packer)
Source

packer.lisp (file)

Method: encoding (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: (setf encoding) VALUE0 PACKED-AUDIO
Package

cl-mixed

Reader

encoding (generic function)

Methods
Method: (setf encoding) VALUE0 (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: (setf encoding) VALUE0 (PACKER packer)
Source

packer.lisp (file)

Method: (setf encoding) VALUE0 (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: end SEGMENT

End the mixing process.

This method should be called as close as possible after all desired calls to MIX are done. Calling MIX after END is called is an error. Some segments may require END to be called before their fields can be set freely. Thus mixing might need to be ’paused’ to change settings.

See SEGMENT-SEQUENCE
See SEGMENT
See START
See MIX

Package

cl-mixed

Methods
Method: end (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: end (SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: end (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: error-code CONDITION

Accessor for the error code contained in the condition instance.

See CL-MIXED-CFFI:ERROR
See CL-MIXED-CFFI:ERROR-STRING

Package

cl-mixed

Writer

(setf error-code) (generic function)

Methods
Method: error-code (CONDITION mixed-error)
Source

toolkit.lisp (file)

Generic Function: (setf error-code) NEW-VALUE CONDITION
Package

cl-mixed

Reader

error-code (generic function)

Methods
Method: (setf error-code) NEW-VALUE (CONDITION mixed-error)
Source

toolkit.lisp (file)

Generic Function: fade-type SEGMENT2

Accessor to the type of easing function used for the fade.

Must be one of :LINEAR :CUBIC-IN :CUBIC-OUT :CUBIC-IN-OUT

See FADER

Package

cl-mixed

Writer

(setf fade-type) (generic function)

Methods
Method: fade-type (SEGMENT2 fader)
Source

fader.lisp (file)

Generic Function: (setf fade-type) VALUE1 SEGMENT2
Package

cl-mixed

Reader

fade-type (generic function)

Methods
Method: (setf fade-type) VALUE1 (SEGMENT2 fader)
Source

fader.lisp (file)

Generic Function: field FIELD SEGMENT2

Access the field of the segment.

Which fields are supported depends on the segment in question.

Some fields may only be read and not written to or vice-versa.

See SEGMENT

Package

cl-mixed

Writer

(setf field) (generic function)

Methods
Method: field (FIELD (eql bypass)) (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: field (FIELD (eql pan)) (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: field FIELD (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: field (FIELD (eql attenuation)) (SEGMENT space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql rolloff)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql max-distance)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql min-distance)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql doppler-factor)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql soundspeed)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql up)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql direction)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql velocity)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql location)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: field (FIELD (eql samplerate)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: field (FIELD (eql repeat-mode)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: field (FIELD (eql duration)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: field (FIELD (eql samplerate)) (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: field (FIELD (eql pitch)) (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 packer)
Source

packer.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 packer)
Source

packer.lisp (file)

Method: field (FIELD (eql noise-type)) (SEGMENT2 noise)
Source

noise.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 noise)
Source

noise.lisp (file)

Method: field FIELD (SEGMENT ladspa)
Source

ladspa.lisp (file)

Method: field (FIELD (eql frequency)) (SEGMENT2 generator)
Source

generator.lisp (file)

Method: field (FIELD (eql wave-type)) (SEGMENT2 generator)
Source

generator.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 generator)
Source

generator.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: field (FIELD (eql samplerate)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: field (FIELD (eql frequency-pass)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: field (FIELD (eql cutoff)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: field (FIELD (eql fade-type)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: field (FIELD (eql duration)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: field (FIELD (eql to)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: field (FIELD (eql from)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: field (FIELD (eql bypass)) (SEGMENT2 delay)
Source

delay.lisp (file)

Method: field (FIELD (eql samplerate)) (SEGMENT2 delay)
Source

delay.lisp (file)

Method: field (FIELD (eql duration)) (SEGMENT2 delay)
Source

delay.lisp (file)

Method: field (FIELD (eql volume)) (SEGMENT2 basic-mixer)
Source

basic-mixer.lisp (file)

Generic Function: (setf field) VALUE FIELD SEGMENT
Package

cl-mixed

Reader

field (generic function)

Methods
Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql pan)) (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: (setf field) VALUE FIELD (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: (setf field) VALUE (FIELD (eql attenuation)) (SEGMENT space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql rolloff)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql max-distance)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql min-distance)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql doppler-factor)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql soundspeed)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql up)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql direction)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql velocity)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql location)) (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql samplerate)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql repeat-mode)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql duration)) (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql samplerate)) (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql pitch)) (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 packer)
Source

packer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 packer)
Source

packer.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql noise-type)) (SEGMENT2 noise)
Source

noise.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 noise)
Source

noise.lisp (file)

Method: (setf field) VALUE FIELD (SEGMENT ladspa)
Source

ladspa.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql frequency)) (SEGMENT2 generator)
Source

generator.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql wave-type)) (SEGMENT2 generator)
Source

generator.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 generator)
Source

generator.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql samplerate)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql frequency-pass)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql cutoff)) (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql fade-type)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql duration)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql to)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql from)) (SEGMENT2 fader)
Source

fader.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql bypass)) (SEGMENT2 delay)
Source

delay.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql samplerate)) (SEGMENT2 delay)
Source

delay.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql duration)) (SEGMENT2 delay)
Source

delay.lisp (file)

Method: (setf field) VALUE1 (FIELD (eql volume)) (SEGMENT2 basic-mixer)
Source

basic-mixer.lisp (file)

Method: (setf field) VALUE FIELD (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: free OBJECT

Free the foreign data associated with this object.

This makes sure that the data is properly cleaned up and that the object can’t accidentally be double-freed or accessed in any way after the free.

See C-OBJECT

Package

cl-mixed

Methods
Method: free (OBJECT c-object)
Source

c-object.lisp (file)

Generic Function: frequency SEGMENT2

Accessor to the frequency of the wave.

Must be in the range [0.0, samplerate].

See GENERATOR

Package

cl-mixed

Writer

(setf frequency) (generic function)

Methods
Method: frequency (SEGMENT2 generator)
Source

generator.lisp (file)

Generic Function: (setf frequency) VALUE1 SEGMENT2
Package

cl-mixed

Reader

frequency (generic function)

Methods
Method: (setf frequency) VALUE1 (SEGMENT2 generator)
Source

generator.lisp (file)

Generic Function: frequency-pass SEGMENT2

Accessor to whether the frequency-pass segment passes high or low frequencies.

Value must be either :HIGH or :LOW.

See FREQUENCY-PASS

Package

cl-mixed

Writer

(setf frequency-pass) (generic function)

Methods
Method: frequency-pass (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Generic Function: (setf frequency-pass) VALUE1 SEGMENT2
Package

cl-mixed

Reader

frequency-pass (generic function)

Methods
Method: (setf frequency-pass) VALUE1 (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Generic Function: from SEGMENT2

Accessor to the starting volume of the fading segment.

Must be in the range of [0.0, infinity[.

See FADER

Package

cl-mixed

Writer

(setf from) (generic function)

Methods
Method: from (SEGMENT2 fader)
Source

fader.lisp (file)

Generic Function: (setf from) VALUE1 SEGMENT2
Package

cl-mixed

Reader

from (generic function)

Methods
Method: (setf from) VALUE1 (SEGMENT2 fader)
Source

fader.lisp (file)

Generic Function: handle THING

Accessor to the pointer to the foreign data that this object tracks.

See CFFI:FOREIGN-POINTER
See C-OBJECT

Package

cl-mixed

Writer

(setf handle) (generic function)

Methods
Method: handle (C-OBJECT c-object)

automatically generated reader method

Source

c-object.lisp (file)

Method: handle THING
Source

c-object.lisp (file)

Generic Function: (setf handle) NEW-VALUE OBJECT
Package

cl-mixed

Reader

handle (generic function)

Methods
Method: (setf handle) NEW-VALUE (C-OBJECT c-object)

automatically generated writer method

Source

c-object.lisp (file)

Generic Function: info SEGMENT

Fetch metadata information about the segment.

Returns a plist with the following entries:
:NAME — A string denoting the name of the type of segment this is. :DESCRIPTION — A string denoting a human-readable description of the segment. :FLAGS — A list of flags for the segment. Should be one of:
:INPLACE — Output and input buffers may be identical as processing is in-place.
:MODIFIES-INPUT — The data in the input buffer is modified.
:MIN-INPUTS — The minimal number of inputs that needs to be connected to this segment.
:MAX-INPUTS — The maximal number of inputs that may be connected to this segment. :OUTPUTS — The number of outputs that this segment provides.
:FIELDS — A list of plists describing the possible flags. Each plist has the following entries:
:FIELD — The keyword or integer denoting the field.
:DESCRIPTION — A string for a human-readable description of what the field does.
:FLAGS — A list of keywords describing the applicability of the field. Must be one of:
:IN — This field is for inputs. :OUT — This field is for outputs. :SEGMENT — This field is for the segment. :SET — This field may be written to. :GET — This field may be read.

Note that this value is cached after the first retrieval. You are thus not allowed to modify the return value.

See SEGMENT

Package

cl-mixed

Methods
Method: info (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: info (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: input LOCATION SEGMENT

Accessor to the input buffer at the specified location of the segment.

See INPUT-FIELD
See SEGMENT

Package

cl-mixed

Writer

(setf input) (generic function)

Methods
Method: input LOCATION (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: (setf input) BUFFER LOCATION SEGMENT
Package

cl-mixed

Reader

input (generic function)

Methods
Method: (setf input) BUFFER LOCATION (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: input-field FIELD LOCATION SEGMENT

Access the field of an input of the segment.

Which fields are supported depends on the segment in question. Usually the :BUFFER field will be recognised for which the value should be a BUFFER instance.

Some fields may only be read and not written to or vice-versa.

See SEGMENT
See INPUT

Package

cl-mixed

Writer

(setf input-field) (generic function)

Methods
Method: input-field (FIELD (eql buffer)) (LOCATION integer) (SEGMENT virtual)
Source

virtual.lisp (file)

Method: input-field FIELD LOCATION (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: input-field (FIELD (eql velocity)) LOCATION2 (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: input-field (FIELD (eql location)) LOCATION2 (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: input-field (FIELD (eql source)) LOCATION (SEGMENT mixer)
Source

mixer.lisp (file)

Method: input-field (FIELD (eql buffer)) (LOCATION integer) (SEGMENT segment)
Source

segment.lisp (file)

Method: input-field (FIELD (eql buffer)) (LOCATION symbol) (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: (setf input-field) VALUE FIELD LOCATION SEGMENT
Package

cl-mixed

Reader

input-field (generic function)

Methods
Method: (setf input-field) VALUE FIELD LOCATION (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: (setf input-field) VALUE1 (FIELD (eql velocity)) LOCATION2 (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf input-field) VALUE1 (FIELD (eql location)) LOCATION2 (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf input-field) VALUE (FIELD (eql buffer)) (LOCATION symbol) (SEGMENT segment)
Source

segment.lisp (file)

Method: (setf input-field) (VALUE null) (FIELD (eql source)) LOCATION (SEGMENT mixer) after
Source

mixer.lisp (file)

Method: (setf input-field) VALUE FIELD LOCATION SEGMENT
Source

segment.lisp (file)

Generic Function: input-location LOCATION2 SEGMENT3

Accessor for the location of the source in space.

To set a vector, the value should be a list or a vector of three floats. When reading, the returned value is always a vector of three floats.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf input-location) (generic function)

Methods
Method: input-location (LOCATION2 segment) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: input-location (LOCATION2 integer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: input-location (LOCATION2 buffer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf input-location) VALUE1 LOCATION2 SEGMENT3
Package

cl-mixed

Reader

input-location (generic function)

Methods
Method: (setf input-location) VALUE1 (LOCATION2 segment) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf input-location) VALUE1 (LOCATION2 integer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf input-location) VALUE1 (LOCATION2 buffer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: input-velocity LOCATION2 SEGMENT3

Accessor for the velocity of the source in space.

To set a vector, the value should be a list or a vector of three floats. When reading, the returned value is always a vector of three floats.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf input-velocity) (generic function)

Methods
Method: input-velocity (LOCATION2 segment) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: input-velocity (LOCATION2 integer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: input-velocity (LOCATION2 buffer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf input-velocity) VALUE1 LOCATION2 SEGMENT3
Package

cl-mixed

Reader

input-velocity (generic function)

Methods
Method: (setf input-velocity) VALUE1 (LOCATION2 segment) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf input-velocity) VALUE1 (LOCATION2 integer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf input-velocity) VALUE1 (LOCATION2 buffer) (SEGMENT3 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: inputs OBJECT

Accessor to the vector of input buffers connected to the segment.

This vector will become out of date if the segment’s
buffers are added or removed from the C side directly,
or directly through this vector. Thus you should never
modify this directly and instead always
make sure to go through INPUT.

See SEGMENT
See INPUT

Package

cl-mixed

Methods
Method: inputs (SEGMENT segment)

automatically generated reader method

Source

segment.lisp (file)

Generic Function: layout PACKED-AUDIO

Accessor to the channel layout in which the samples are laid out in the buffer of the object.

The layout has to be either :ALTERNATING or :SEQUENTIAL.
Alternating means that the samples are encoded like this:
(C₁C₂...)ⁿ
Sequential means that the samples are encoded like this:
C₁ⁿC₂ⁿ...

See PACKED-AUDIO

Package

cl-mixed

Writer

(setf layout) (generic function)

Methods
Method: layout (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: layout (PACKER packer)
Source

packer.lisp (file)

Method: layout (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: (setf layout) VALUE0 PACKED-AUDIO
Package

cl-mixed

Reader

layout (generic function)

Methods
Method: (setf layout) VALUE0 (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: (setf layout) VALUE0 (PACKER packer)
Source

packer.lisp (file)

Method: (setf layout) VALUE0 (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: location SEGMENT2

Accessor for the location of the listener in space.

To set a vector, the value should be a list or a vector of three floats. When reading, the returned value is always a vector of three floats.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf location) (generic function)

Methods
Method: location (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf location) VALUE1 SEGMENT2
Package

cl-mixed

Reader

location (generic function)

Methods
Method: (setf location) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: max-distance SEGMENT2

Accessor to the maximal distance above which the source is inaudible.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf max-distance) (generic function)

Methods
Method: max-distance (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf max-distance) VALUE1 SEGMENT2
Package

cl-mixed

Reader

max-distance (generic function)

Methods
Method: (setf max-distance) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: min-distance SEGMENT2

Accessor to the minimal distance below which the source is at max volume.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf min-distance) (generic function)

Methods
Method: min-distance (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf min-distance) VALUE1 SEGMENT2
Package

cl-mixed

Reader

min-distance (generic function)

Methods
Method: (setf min-distance) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: mix SAMPLES SEGMENT

Perform the actual mixing.

This processes the given number of samples through the pipeline. It is your job to make sure that sources provide enough fresh samples and drains will consume enough samples. Calling MIX with more samples specified than any one buffer connected to the segments in the sequence can hold is an error and may crash your system. No checks for this problem are done.

Calling MIX before START has been called or after END has been called is an error and may result in crashes. No checks for this problem are done.

If you want to ensure that the sequence is complete and able to process the requested number of samples, you should call CHECK-COMPLETE after running START.

See SEGMENT-SEQUENCE
See SEGMENT
See START
See END

Package

cl-mixed

Methods
Method: mix SAMPLES (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: mix SAMPLES (SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: mix SAMPLES (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: noise-type SEGMENT2

Accessor to the type of noise being generated.

The value must be one of :WHITE, :PINK, :BROWN.

See NOISE

Package

cl-mixed

Writer

(setf noise-type) (generic function)

Methods
Method: noise-type (SEGMENT2 noise)
Source

noise.lisp (file)

Generic Function: (setf noise-type) VALUE1 SEGMENT2
Package

cl-mixed

Reader

noise-type (generic function)

Methods
Method: (setf noise-type) VALUE1 (SEGMENT2 noise)
Source

noise.lisp (file)

Generic Function: output LOCATION SEGMENT

Accessor to the output buffer at the specified location of the segment.

See OUTPUT-FIELD
See SEGMENT

Package

cl-mixed

Writer

(setf output) (generic function)

Methods
Method: output LOCATION (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: (setf output) BUFFER LOCATION SEGMENT
Package

cl-mixed

Reader

output (generic function)

Methods
Method: (setf output) BUFFER LOCATION (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: output-field FIELD LOCATION SEGMENT

Access the field of an output of the segment.

Which fields are supported depends on the segment in question. Usually the :BUFFER field will be recognised for which the value should be a BUFFER instance.

Some fields may only be read and not written to or vice-versa.

See SEGMENT
See OUTPUT

Package

cl-mixed

Writer

(setf output-field) (generic function)

Methods
Method: output-field (FIELD (eql buffer)) (LOCATION integer) (SEGMENT virtual)
Source

virtual.lisp (file)

Method: output-field FIELD LOCATION (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: output-field (FIELD (eql buffer)) (LOCATION integer) (SEGMENT segment)
Source

segment.lisp (file)

Method: output-field (FIELD (eql buffer)) (LOCATION symbol) (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: (setf output-field) VALUE FIELD LOCATION SEGMENT
Package

cl-mixed

Reader

output-field (generic function)

Methods
Method: (setf output-field) VALUE FIELD LOCATION (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: (setf output-field) VALUE (FIELD (eql buffer)) (LOCATION symbol) (SEGMENT segment)
Source

segment.lisp (file)

Method: (setf output-field) VALUE FIELD LOCATION SEGMENT
Source

segment.lisp (file)

Generic Function: outputs OBJECT

Accessor to the vector of output buffers connected to the segment.

This vector will become out of date if the segment’s
buffers are added or removed from the C side directly,
or directly through this vector. Thus you should never
modify this directly and instead always
make sure to go through OUTPUT

See SEGMENT
See OUTPUT

Package

cl-mixed

Methods
Method: outputs (SEGMENT segment)

automatically generated reader method

Source

segment.lisp (file)

Generic Function: packed-audio OBJECT

Reader for the packed-audio the un/packer is translating from/to.

See PACKED-AUDIO
See UNPACKER
See PACKER

Package

cl-mixed

Methods
Method: packed-audio (UNPACKER unpacker)

automatically generated reader method

Source

unpacker.lisp (file)

Method: packed-audio (PACKER packer)

automatically generated reader method

Source

packer.lisp (file)

Generic Function: pan SEGMENT2

Accessor to the outputting pan of the volume control segment.

Must be in the range [-1,1].

See VOLUME-CONTROL

Package

cl-mixed

Writer

(setf pan) (generic function)

Methods
Method: pan (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Generic Function: (setf pan) VALUE1 SEGMENT2
Package

cl-mixed

Reader

pan (generic function)

Methods
Method: (setf pan) VALUE1 (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Generic Function: pitch SEGMENT2

Accessor to the current pitch shifting value.

The pitch shift is denoted as a float in the range of ]0,infinity[, where 1 is no change, 0.5 halves the pitch, and 2 doubles the pitch.

Note that extreme values on either side will result in heavy distortions and quality loss. Anything outside the range of [0.5,2.0] will already result in audible artefacts.

See PITCH

Package

cl-mixed

Writer

(setf pitch) (generic function)

Methods
Method: pitch (SEGMENT2 pitch)
Source

pitch.lisp (file)

Generic Function: (setf pitch) VALUE1 SEGMENT2
Package

cl-mixed

Reader

pitch (generic function)

Methods
Method: (setf pitch) VALUE1 (SEGMENT2 pitch)
Source

pitch.lisp (file)

Generic Function: repeat-mode SEGMENT2

Accessor to the mode the repeat segment is currently in.

The value must be either :RECORD or :PLAY.
When in record mode, the segment will fill its internal buffer with the samples from the input buffer, and copy them to the output buffer. While in this mode it is thus "transparent" and does not change anything.
When in play mode, the segment continuously plays back its internal buffer to the output buffer, ignoring all samples on the input buffer.

See REPEAT

Package

cl-mixed

Writer

(setf repeat-mode) (generic function)

Methods
Method: repeat-mode (SEGMENT2 repeat)
Source

repeat.lisp (file)

Generic Function: (setf repeat-mode) VALUE1 SEGMENT2
Package

cl-mixed

Reader

repeat-mode (generic function)

Methods
Method: (setf repeat-mode) VALUE1 (SEGMENT2 repeat)
Source

repeat.lisp (file)

Generic Function: rolloff SEGMENT2

Accessor to the rolloff factor that describes the curvature of the attenuation function.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf rolloff) (generic function)

Methods
Method: rolloff (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf rolloff) VALUE1 SEGMENT2
Package

cl-mixed

Reader

rolloff (generic function)

Methods
Method: (setf rolloff) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: samplerate PACKED-AUDIO

Accessor to the samplerate at which the samples are expected to be.

The sample rate is in Hz.

See PACKED-AUDIO
See DELAY
See FADER
See FREQUENCY-PASS
See PITCH
See REPEAT
See SPACE-MIXER

Package

cl-mixed

Writer

(setf samplerate) (generic function)

Methods
Method: samplerate (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: samplerate (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: samplerate (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: samplerate (PACKER packer)
Source

packer.lisp (file)

Method: samplerate (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: samplerate (SEGMENT2 delay)
Source

delay.lisp (file)

Method: samplerate (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: (setf samplerate) VALUE0 PACKED-AUDIO
Package

cl-mixed

Reader

samplerate (generic function)

Methods
Method: (setf samplerate) VALUE0 (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: (setf samplerate) VALUE1 (SEGMENT2 repeat)
Source

repeat.lisp (file)

Method: (setf samplerate) VALUE1 (SEGMENT2 pitch)
Source

pitch.lisp (file)

Method: (setf samplerate) VALUE0 (PACKER packer)
Source

packer.lisp (file)

Method: (setf samplerate) VALUE1 (SEGMENT2 frequency-pass)
Source

frequency-pass.lisp (file)

Method: (setf samplerate) VALUE1 (SEGMENT2 delay)
Source

delay.lisp (file)

Method: (setf samplerate) VALUE0 (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Generic Function: segments OBJECT

Accessor to a vector of segments the sequence contains.

This vector will become out of date if the sequence’s segments are added or removed from the C side directly, or directly through this vector. Thus you should never modify this directly and instead always make sure to go through ADD/WITHDRAW.

See SEGMENT-SEQUENCE
See ADD
See WITHDRAW

Package

cl-mixed

Methods
Method: segments (SEGMENT-SEQUENCE segment-sequence)

automatically generated reader method

Source

segment-sequence.lisp (file)

Generic Function: size BUFFER

Accessor to the size of the data contained in the object.

For packed-audio this number is in bytes.
For buffers this number is in floats.

When the size is set on a buffer, the buffer’s data array is resized to fit the requested size.

See BUFFER
See PACKED-AUDIO
See SEGMENT-SEQUENCE

Package

cl-mixed

Writer

(setf size) (generic function)

Methods
Method: size (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: size (PACKER packer)
Source

packer.lisp (file)

Method: size (SEGMENT-SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: size (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Method: size (BUFFER buffer)
Source

buffer.lisp (file)

Generic Function: (setf size) VALUE0 BUFFER
Package

cl-mixed

Reader

size (generic function)

Methods
Method: (setf size) VALUE0 (UNPACKER unpacker)
Source

unpacker.lisp (file)

Method: (setf size) VALUE0 (PACKER packer)
Source

packer.lisp (file)

Method: (setf size) VALUE0 (SEGMENT-SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: (setf size) VALUE0 (PACKED-AUDIO packed-audio)
Source

packed-audio.lisp (file)

Method: (setf size) NEW (BUFFER buffer)
Source

buffer.lisp (file)

Method: (setf size) SIZE (PACK packed-audio) before
Source

packed-audio.lisp (file)

Generic Function: soundspeed SEGMENT2

Accessor to the speed of sound in space.

This value only influences the strength of the doppler factor.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf soundspeed) (generic function)

Methods
Method: soundspeed (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf soundspeed) VALUE1 SEGMENT2
Package

cl-mixed

Reader

soundspeed (generic function)

Methods
Method: (setf soundspeed) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: source LOCATION SEGMENT

Accessor to the source segment attached to an input buffer or location.

Some mixers support attaching a source
segment to an input buffer. The effect being that the
segment is mixed before the corresponding buffer is
used, allowing for dynamic addition and removal of
segments without the need to alter the pipeline.

See MIXER
See SOURCES

Package

cl-mixed

Writer

(setf source) (generic function)

Methods
Method: source (BUFFER buffer) (SEGMENT mixer)
Source

mixer.lisp (file)

Method: source (LOCATION integer) (SEGMENT mixer)
Source

mixer.lisp (file)

Generic Function: (setf source) VALUE LOCATION SEGMENT
Package

cl-mixed

Reader

source (generic function)

Generic Function: sources OBJECT

Accessor to the hash table mapping input locations to segments.

This map holds which locations have segments attached.
You should use the INPUT-FIELD or SOURCE accessors to actually attach or detach source segments.

See MIXER
See SOURCE
See INPUT-FIELD

Package

cl-mixed

Writer

(setf sources) (generic function)

Methods
Method: sources (MIXER mixer)

automatically generated reader method

Source

mixer.lisp (file)

Generic Function: (setf sources) NEW-VALUE OBJECT
Package

cl-mixed

Reader

sources (generic function)

Methods
Method: (setf sources) NEW-VALUE (MIXER mixer)

automatically generated writer method

Source

mixer.lisp (file)

Generic Function: start SEGMENT

Start the mixing process.

This method should be called as close as possible to the next calls to MIX. Calling MIX before START is called or after END is called is an error. After START has been called, changing some segments’ fields may result in undefined behaviour and might even lead to crashes.

See SEGMENT-SEQUENCE
See SEGMENT
See END
See MIX

Package

cl-mixed

Methods
Method: start (VIRTUAL virtual)
Source

virtual.lisp (file)

Method: start (SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: start (SEGMENT segment)
Source

segment.lisp (file)

Generic Function: to SEGMENT2

Accessor to the ending volume of the fading segment.

Must be in the range of [0.0, infinity[.

See FADER

Package

cl-mixed

Writer

(setf to) (generic function)

Methods
Method: to (SEGMENT2 fader)
Source

fader.lisp (file)

Generic Function: (setf to) VALUE1 SEGMENT2
Package

cl-mixed

Reader

to (generic function)

Methods
Method: (setf to) VALUE1 (SEGMENT2 fader)
Source

fader.lisp (file)

Generic Function: up SEGMENT2

Accessor for the vector representing "upwards" in space.

To set a vector, the value should be a list or a vector of three floats. When reading, the returned value is always a vector of three floats.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf up) (generic function)

Methods
Method: up (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf up) VALUE1 SEGMENT2
Package

cl-mixed

Reader

up (generic function)

Methods
Method: (setf up) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: velocity SEGMENT2

Accessor for the velocity of the listener in space.

To set a vector, the value should be a list or a vector of three floats. When reading, the returned value is always a vector of three floats.

See SPACE-MIXER

Package

cl-mixed

Writer

(setf velocity) (generic function)

Methods
Method: velocity (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf velocity) VALUE1 SEGMENT2
Package

cl-mixed

Reader

velocity (generic function)

Methods
Method: (setf velocity) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Generic Function: volume SEGMENT2

Accessor to the outputting volume of the segment.

Must be in the range [0, infinity[.

See VOLUME-CONTROL
See NOISE
See GENERATOR

Package

cl-mixed

Writer

(setf volume) (generic function)

Methods
Method: volume (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: volume (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: volume (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: volume (SEGMENT2 packer)
Source

packer.lisp (file)

Method: volume (SEGMENT2 noise)
Source

noise.lisp (file)

Method: volume (SEGMENT2 generator)
Source

generator.lisp (file)

Method: volume (SEGMENT2 basic-mixer)
Source

basic-mixer.lisp (file)

Generic Function: (setf volume) VALUE1 SEGMENT2
Package

cl-mixed

Reader

volume (generic function)

Methods
Method: (setf volume) VALUE1 (SEGMENT2 volume-control)
Source

volume-control.lisp (file)

Method: (setf volume) VALUE1 (SEGMENT2 unpacker)
Source

unpacker.lisp (file)

Method: (setf volume) VALUE1 (SEGMENT2 space-mixer)
Source

space-mixer.lisp (file)

Method: (setf volume) VALUE1 (SEGMENT2 packer)
Source

packer.lisp (file)

Method: (setf volume) VALUE1 (SEGMENT2 noise)
Source

noise.lisp (file)

Method: (setf volume) VALUE1 (SEGMENT2 generator)
Source

generator.lisp (file)

Method: (setf volume) VALUE1 (SEGMENT2 basic-mixer)
Source

basic-mixer.lisp (file)

Generic Function: wave-type SEGMENT2

Accessor to the wave type the generator generates.

Must be one of :SINE :SQUARE :SAWTOOTH :TRIANGLE

See GENERATOR

Package

cl-mixed

Writer

(setf wave-type) (generic function)

Methods
Method: wave-type (SEGMENT2 generator)
Source

generator.lisp (file)

Generic Function: (setf wave-type) VALUE1 SEGMENT2
Package

cl-mixed

Reader

wave-type (generic function)

Methods
Method: (setf wave-type) VALUE1 (SEGMENT2 generator)
Source

generator.lisp (file)

Generic Function: withdraw BUFFER SEGMENT

Remove the object from the given collection.

For segment-sequences this means removing the segment from the sequence. For mixers this means removing the given input buffer.

See SEGMENT-SEQUENCE
See MIXER

Package

cl-mixed

Methods
Method: withdraw (OLD segment) (SEGMENT space-mixer)
Source

space-mixer.lisp (file)

Method: withdraw (OLD segment) (SEGMENT basic-mixer)
Source

basic-mixer.lisp (file)

Method: withdraw (SEGMENT segment) (SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: withdraw (BUFFER buffer) (SEGMENT mixer)
Source

mixer.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Conditions

Condition: mixed-error ()

Condition class for errors related to the mixed library.

See ERROR-CODE

Package

cl-mixed

Source

toolkit.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: error-code
Initargs

:error-code

Readers

error-code (generic function)

Writers

(setf error-code) (generic function)

Direct Default Initargs
InitargValue
:error-code(cl-mixed-cffi:error)

Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Classes

Class: basic-mixer ()

This segment additively mixes an arbitrary number of inputs to a single output.

Linear mixing means that all the inputs are summed
up and the resulting number is divided by the number
of inputs. This is equivalent to having all the
inputs play as "individual speakers" in real life.

See MIXER
See MAKE-BASIC-MIXER

Package

cl-mixed

Source

basic-mixer.lisp (file)

Direct superclasses

mixer (class)

Direct methods
Direct slots
Slot: channels
Initargs

:channels

Readers

channels (generic function)

Writers

(setf channels) (generic function)

Direct Default Initargs
InitargValue
:channels1
Class: buffer ()

Buffers encapsulate raw audio data between segments.

A buffer stores a C-array of floats. This array represents a sample buffer for a single audio channel. The data is not encoded in any way and consists solely of single-floats.

Upon construction the foreign array of floats is automatically allocated based on the given size.

See C-OBJECT
See DATA
See SIZE
See CLEAR

Package

cl-mixed

Source

buffer.lisp (file)

Direct superclasses

c-object (class)

Direct methods
Class: buffer ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: c-object ()

Superclass for all objects that track foreign resources.

If no handle is given to the object upon creation, the proper corresponding foreign data is automatically allocated. The pointer to this data is then associated with the instance to allow resolving the pointer to the original Lisp object. Finalisation of the foreign data upon garbage collection of the Lisp object is also handled.

The actual foreign allocation and cleanup of the data is handled by ALLOCATE-HANDLE and FREE-HANDLE respectively. The subclass in question is responsible for implementing appropriate methods for them.

See HANDLE
See ALLOCATE-HANDLE
See FREE-HANDLE
See FREE
See POINTER->OBJECT

Package

cl-mixed

Source

c-object.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: handle
Initargs

:handle

Readers

handle (generic function)

Writers

(setf handle) (generic function)

Class: delay ()

A simple delay segment.

This just delays the input to the output by a given number of seconds. Note that it will require an internal buffer to hold the samples for the required length of time, which might become expensive for very long durations.

See SEGMENT
See MAKE-DELAY
See DURATION
See SAMPLERATE
See BYPASS

Package

cl-mixed

Source

delay.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:sampleratecl-mixed:*default-samplerate*
Class: fader ()

A volume fading segment.

This allows you to smoothly fade in and out an input.

The from and to are given in relative volume, meaning in the range of [0.0, infinity[. The duration is given in seconds. The fade type must be one of the following: :LINEAR :CUBIC-IN :CUBIC-OUT :CUBIC-IN-OUT, each referring to the respective easing function.
The time is measured from the last call to START out.

See SEGMENT
See MAKE-FADER
See FROM
See TO
See DURATION
See FADE-TYPE

Package

cl-mixed

Source

fader.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:from0.0
:to1.0
:time1.0
:type:cubic-in-out
:sampleratecl-mixed:*default-samplerate*
Class: field-info ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: frequency-pass ()

A frequency low or high pass filter.

This filters out frequencies below or above a given cutoff frequency.

See SEGMENT
See MAKE-FREQUENCY-PASS
See CUTOFF
See FREQUENCY-PASS
See SAMPLERATE
See BYPASS

Package

cl-mixed

Source

frequency-pass.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:pass:low
:sampleratecl-mixed:*default-samplerate*
Class: generator ()

A primitive tone generator segment.

This segment can generate sine, square, sawtooth, and triangle waves at a requested frequency. You can even change the frequency and type on the fly.

See SEGMENT
See *DEFAULT-SAMPLERATE*
See WAVE-TYPE
See FREQUENCY

Package

cl-mixed

Source

generator.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:type:sine
:frequency440
:sampleratecl-mixed:*default-samplerate*
Class: ladspa ()

This segment invokes a LADSPA plugin.

LADSPA (Linux Audio Developers’ Simple Plugin API) is a standard interface for audio effects. Such effects are contained in shared library files and can be loaded in and used with libmixed straight up.

Please refer to the plugin’s documentation for necessary configuration values, and to the libmixed documentation for how to set them.

See SEGMENT
See *DEFAULT-SAMPLERATE*
See MAKE-LADSPA

Package

cl-mixed

Source

ladspa.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:file(error "ladspa file required.")
:index0
:sampleratecl-mixed:*default-samplerate*
Class: mixer ()

Superclass for segments that mix a variable number of sources together.

See SEGMENT
See ADD
See WITHDRAW
See SOURCES
See SOURCE

Package

cl-mixed

Source

mixer.lisp (file)

Direct superclasses

segment (class)

Direct subclasses
Direct methods
Direct slots
Slot: sources
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

sources (generic function)

Writers

(setf sources) (generic function)

Class: noise ()

A noise generator segment.

This segment produces a single channel of noise, either white, pink, or brownian noise.

See SEGMENT
See MAKE-NOISE
See VOLUME
See NOISE-TYPE

Package

cl-mixed

Source

noise.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:type:pink
Class: packed-audio ()

Packed-audio represents an interface to an outside sound source or drain.

The object holds all the necessary information to describe
the audio data present in a raw byte buffer. This includes
how many channels there are, how the samples are laid out
and how the samples are formatted in memory. It also includes
the samplerate of the channel’s source so that it can be
converted if necessary.

See MAKE-PACKED-AUDIO
See SOURCE
See DRAIN
See C-OBJECT
See OWN-DATA
See DATA
See SIZE
See ENCODING
See CHANNELS
See LAYOUT
See SAMPLERATE

Package

cl-mixed

Source

packed-audio.lisp (file)

Direct superclasses

c-object (class)

Direct methods
Direct slots
Slot: own-data
Initform

(cons nil nil)

Readers

own-data (generic function)

Class: packed-audio ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: packer ()

This segment converts data from individual sample buffers to data for packed-audio.

This is mostly useful at the edges to convert to
something like an audio file library or audio
playback system from the internal buffers as used
by Mixed.

The samplerate argument defines the sample rate
in the input buffers. If it diverges from the
sample rate in the packed-audio, resampling occurs to
account for this. To change the resampling method,
use the :RESAMPLER method. The value must be a
pointer to a C function of the following signature:

int resample(struct mixed_buffer *in,
size_t in_samplerate,
struct mixed_buffer *out,
size_t out_samplerate,
size_t out_samples)

Three such resampling functions are available out
of the box:

- CL-MIXED-CFFI:RESAMPLE-NEAREST
- CL-MIXED-CFFI:RESAMPLE-LINEAR
- CL-MIXED-CFFI:RESAMPLE-CUBIC

See mixed.h
See PACKED-AUDIO
See SEGMENT
See MAKE-PACKER
See *DEFAULT-SAMPLERATE*

Package

cl-mixed

Source

packer.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct slots
Slot: packed-audio
Initargs

:packed-audio

Readers

packed-audio (generic function)

Direct Default Initargs
InitargValue
:sampleratecl-mixed:*default-samplerate*
Class: pitch ()

A pitch shifting segment.

This segment allows you to change the pitch of the incoming audio.

See MAKE-PITCH
See PITCH
See SAMPLERATE
See BYPASS

Package

cl-mixed

Source

pitch.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:pitch1.0
:sampleratecl-mixed:*default-samplerate*
Class: repeat ()

This segment repeats a recorded bit of its input sequence.

The segment is first in record mode when created.
Once you have the bit you want to repeat back, you
can switch the repeat-mode to :PLAY. It will then ignore the input and instead continuously output the recorded input bit.

See MAKE-REPEAT
See DURATION
See REPEAT-MODE
See SAMPLERATE
See BYPASS

Package

cl-mixed

Source

repeat.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:sampleratecl-mixed:*default-samplerate*
Class: segment ()

Superclass for all mixing pipeline segments.

A segment is responsible for producing, consuming, combining, splitting, or just in general somehow processing audio data within a pipeline.

A segment is connected to several buffers at its inputs and outputs. Each input, output, and the segment itself may have a number of fields that can be accessed to change the properties of the segment’s behaviour.

Some of these properties may not be changed in real time and instead might require a ending the mixing first.

See C-OBJECT
See INPUTS
See OUTPUTS
See INFO
See START
See MIX
See END
See INPUT-FIELD
See OUTPUT-FIELD
See FIELD
See INPUT
See OUTPUT
See CONNECT

Package

cl-mixed

Source

segment.lisp (file)

Direct superclasses

c-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: inputs
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

inputs (generic function)

Slot: outputs
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

outputs (generic function)

Slot: info
Readers

direct-info (generic function)

Writers

(setf direct-info) (generic function)

Class: segment ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: segment-info ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: segment-sequence ()

A segment-sequence represents a mixing pipeline.

The sequence takes care of remembering the order in which segments should be processed and running them in that order when mixing is done.

See MAKE-SEGMENT-SEQUENCE
See C-OBJECT
See SEGMENTS
See ADD
See WITHDRAW
See START
See MIX
See END

Package

cl-mixed

Source

segment-sequence.lisp (file)

Direct superclasses

c-object (class)

Direct methods
Direct slots
Slot: segments
Initform

(make-array 0 :adjustable t :fill-pointer t)

Readers

segments (generic function)

Class: segment-sequence ()
Package

cl-mixed-cffi

Source

low-level.lisp (file)

Direct superclasses
  • translatable-foreign-type (class)
  • foreign-struct-type (class)
Class: space-mixer ()

A segment to simulate audio effects in 3D space.

Each input represents an individual source in space. Each such source can have a location and a velocity, both of which are vectors of three elements. If the velocity is non-zero, a doppler effect is applied to the source.

The segment itself also has a :LOCATION and :VELOCITY, representing the listener’s own properties. It has some additional fields to change the properties of the 3D space. In total, the following fields are available:

:LOCATION — The location of the input or listener. Value should be a list of three floats.
:VELOCITY — The velocity of the input or listener. Value should be a list of three floats.
:DIRECTION — The direction the listener is facing. Value should be a list of three floats. Default is (0 0 1) :UP — The vector pointing "up" in space. Value should be a list of three floats. Default is (0 1 0) :SOUNDSPEED — The speed of sound in the medium. Default is 34330, meaning "1" is measured as 1cm. :DOPPLER-FACTOR — This can be used to over- or understate the effect of the doppler. Default is 1.0. :MIN-DISTANCE — The minimal distance under which the source has reached max volume. :MAX-DISTANCE — The maximal distance over which the source is completely inaudible. :ROLLOFF — The rolloff factor describing the curvature of the attenuation function.
:ATTENUATION — The attenuation function describing how volume changes over distance. Should be one of :NONE :LINEAR :INVERSE :EXPONENTIAL.

See MIXER
See MAKE-SPACE-MIXER
See LOCATION
See INPUT-LOCATION
See VELOCITY
See INPUT-VELOCITY
See DIRECTION
See UP
See SOUNDSPEED
See DOPPLER-FACTOR
See MIN-DISTANCE
See MAX-DISTANCE
See ROLLOFF
See ATTENUATION
See *DEFAULT-SAMPLERATE*

Package

cl-mixed

Source

space-mixer.lisp (file)

Direct superclasses

mixer (class)

Direct methods
Direct Default Initargs
InitargValue
:sampleratecl-mixed:*default-samplerate*
Class: unpacker ()

This segment converts data from packed-audio to individual sample buffers.

This is mostly useful at the edges to convert from
something like an audio file library to the format
needed by Mixed.

The samplerate argument defines the sample rate
in the output buffers. If it diverges from the
sample rate in the packed-audio, resampling occurs to
account for this. To change the resampling method,
use the :RESAMPLER method. The value must be a
pointer to a C function of the following signature:

int resample(struct mixed_buffer *in,
size_t in_samplerate,
struct mixed_buffer *out,
size_t out_samplerate,
size_t out_samples)

Three such resampling functions are available out
of the box:

- CL-MIXED-CFFI:RESAMPLE-NEAREST
- CL-MIXED-CFFI:RESAMPLE-LINEAR
- CL-MIXED-CFFI:RESAMPLE-CUBIC

See PACKED-AUDIO
See SEGMENT
See MAKE-UNPACKER
See *DEFAULT-SAMPLERATE*

Package

cl-mixed

Source

unpacker.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct slots
Slot: packed-audio
Initargs

:packed-audio

Readers

packed-audio (generic function)

Direct Default Initargs
InitargValue
:sampleratecl-mixed:*default-samplerate*
Class: virtual ()

Superclass for segments implemented in Lisp.

The segment should implement the following methods according to its need:

INFO
START
MIX
END
INPUT-FIELD
(SETF INPUT-FIELD)
OUTPUT-FIELD
(SETF OUTPUT-FIELD)
FIELD

Default methods for INPUT/OUTPUT-FIELD to handle the recording of the input/output buffers already exist. Every other method by default does nothing. You should in the very least implement a method for MIX on your subclass.

See SEGMENT
See INFO
See START
See MIX
See END
See INPUT-FIELD
See OUTPUT-FIELD
See FIELD
See INPUTS
See OUTPUTS

Package

cl-mixed

Source

virtual.lisp (file)

Direct superclasses

segment (class)

Direct methods
Class: volume-control ()

A volume control segment that can change the volume and pan.

This is a stereo segment, and as such requires two
input and output buffers each. You may use the
location keywords :LEFT and :RIGHT to address them.

The pan goes from -1.0 for left to 1.0 for right.
The volume goes from 0.0 upwards. Values below zero result in an error, and values above 1.0 will likely lead to clipping and thus audio distortions.

See SEGMENT
See MAKE-VOLUME-CONTROL
See VOLUME
See PAN

Package

cl-mixed

Source

volume-control.lisp (file)

Direct superclasses

segment (class)

Direct methods
Direct Default Initargs
InitargValue
:volume1.0
:pan0.0

Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *c-object-table*

A weak value table associating pointer addresses to corresponding objects.

This table keeps track of which foreign data is tracked
by which lisp instance.

See POINTER->OBJECT
See C-OBJECT

Package

cl-mixed

Source

c-object.lisp (file)

Special Variable: *here*

Variable containing the path to the low-level.lisp file.

Package

cl-mixed-cffi

Source

low-level.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: define-accessor NAME CLASS FFI

Define a new accessor wrapper for a CFFI struct function.

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: define-callback NAME RETURN ARGS ERROR-RETURN &body BODY

Defines a new callback that handles errors automatically.

If an error occurs within BODY, the ERROR-RETURN form is instead evaluated and its value returned.

See CFFI:DEFCALLBACK

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: define-delegated-slot-accessor NAME CLASS ACCESSOR

Define an accessor that delegates its call to a slot of the instance.

Generates the necessary accessor methods to wrap
the access.

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: define-field-accessor NAME CLASS TYPE &optional ENUM

Define an accessor for a segment’s field.

Generates the necessary methods on FIELD as well as convenience wrapper methods.

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: define-input-vector-field-accessor NAME CLASS FIELD ENUM

Define an accessor for a segment’s input vector value field.

Generates the necessary methods on FIELD as well as convenience wrapper methods. The values should be
lists or vectors of three floats.

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: define-std-callback NAME ARGS &body BODY

Define a standard callback function.

Standard means that the function will return 1 on success and 0 on abnormal exit.

See DEFINE-CALLBACK

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: define-vector-field-accessor NAME CLASS ENUM

Define an accessor for a segment’s vector value field.

Generates the necessary methods on FIELD as well as convenience wrapper methods. The values should be lists or vectors of three floats.

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: with-cleanup-on-failure CLEANUP &body BODY

If the body unwinds abnormally, CLEANUP is run.

Package

cl-mixed

Source

toolkit.lisp (file)

Macro: with-error-on-failure (&optional DATUM &rest ARGS) &body BODY

Shorthand to handle return values of C functions.

If the last form in the body returns a zero, an error of type MIXED-ERROR is signalled.

See MIXED-ERROR

Package

cl-mixed

Source

toolkit.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: calloc TYPE &optional COUNT

Allocate a region of foreign data on the heap.

This is like CFFI:FOREIGN-ALLOC, except that the memory region is zeroed out before the pointer to it is returned.

Package

cl-mixed

Source

toolkit.lisp (file)

Function: coerce-ctype VALUE TYPE

Coerce the given value to the type and range appropriate for the given C-type.

Coercion is done for:
:FLOAT
:DOUBLE
:INT
:UINT

Package

cl-mixed

Source

toolkit.lisp (file)

Function: decode-field-info INFO

Decode the field info contained in the pointer to a segment-info struct.

See CL-MIXED-CFFI:SEGMENT-INFO
See CL-MIXED-CFFI:FIELD-INFO

Package

cl-mixed

Source

segment.lisp (file)

Function: decode-flags INTEGER

Decode an OR combined integer of INFO-FLAGS to a list of keywords for the flags.

See CL-MIXED-CFFI:INFO-FLAGS

Package

cl-mixed

Source

segment.lisp (file)

Function: encode-field-info FIELDS INFO

Encode the field info into the segment-info struct pointed to by the pointer.

See CL-MIXED-CFFI:SEGMENT-INFO
See CL-MIXED-CFFI:FIELD-INFO

Package

cl-mixed

Source

segment.lisp (file)

Function: encode-flags FLAGS

Encode the list of keywords for the INFO-FLAGS to a an OR combined integer.

See CL-MIXED-CFFI:INFO-FLAGS

Package

cl-mixed

Source

segment.lisp (file)

Function: ptr->vec VALUE-PTR

Convert a pointer to a C array of three floats to a vector.

Package

cl-mixed

Source

toolkit.lisp (file)

Function: removef PLIST &rest KEYS

Remove the given key/value pairs from the plist.

Returns a fresh list.

Package

cl-mixed

Source

toolkit.lisp (file)

Function: vec->ptr VALUE VALUE-PTR

Convert the vector into a C array of three floats

Package

cl-mixed

Source

toolkit.lisp (file)

Function: vector-insert-pos INDEX ELEMENT VECTOR

Set the value at the given position in the vector.

If the position is beyond the vector’s length, it is first adjusted to that length.

Package

cl-mixed

Source

toolkit.lisp (file)

Function: vector-remove ELEMENT VECTOR

Remove the element from the vector.

Elements above it are shifted down and the vector’s size is adjusted. Only the first occurrence is removed.

See VECTOR-REMOVE-POS

Package

cl-mixed

Source

toolkit.lisp (file)

Function: vector-remove-pos INDEX VECTOR

Remove the element at the specified index in the vector.

Elements above it are shifted down and the vector’s size is adjusted.

Package

cl-mixed

Source

toolkit.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Generic functions

Generic Function: allocate-handle BUFFER

Allocate space for the foreign resource of this object.

See C-OBJECT

Package

cl-mixed

Methods
Method: allocate-handle (SEQUENCE segment-sequence)
Source

segment-sequence.lisp (file)

Method: allocate-handle (SEGMENT segment)
Source

segment.lisp (file)

Method: allocate-handle (PACK packed-audio)
Source

packed-audio.lisp (file)

Method: allocate-handle (BUFFER buffer)
Source

buffer.lisp (file)

Generic Function: attenuation SPACE

Accessor to the attenuation function used to describe the distance volume falloff.

The value should be one of

:NONE :LINEAR :INVERSE :EXPONENTIAL

The value may also be a pointer to a C function
of the following signature:

float attenuation(float min,
float max,
float dist,
float roll);

See mixed.h
See SPACE-MIXER

Package

cl-mixed

Writer

(setf attenuation) (generic function)

Methods
Method: attenuation (SPACE space-mixer)
Source

space-mixer.lisp (file)

Generic Function: (setf attenuation) VALUE SPACE
Package

cl-mixed

Reader

attenuation (generic function)

Methods
Method: (setf attenuation) VALUE (SPACE space-mixer)
Source

space-mixer.lisp (file)

Generic Function: direct-info OBJECT

Direct accessor to the info slot on the segment.

See SEGMENT
See INFO

Package

cl-mixed

Writer

(setf direct-info) (generic function)

Methods
Method: direct-info (SEGMENT segment)

automatically generated reader method

Source

segment.lisp (file)

Generic Function: (setf direct-info) NEW-VALUE OBJECT
Package

cl-mixed

Reader

direct-info (generic function)

Methods
Method: (setf direct-info) NEW-VALUE (SEGMENT segment)

automatically generated writer method

Source

segment.lisp (file)

Generic Function: free-handle BUFFER HANDLE

Return a function that cleans up the given handle and frees its foreign resources.

Instead of calling this function directly yourself, you should
use FREE.

See FREE
See C-OBJECT

Package

cl-mixed

Methods
Method: free-handle (VIRTUAL virtual) HANDLE
Source

virtual.lisp (file)

Method: free-handle (SEQUENCE segment-sequence) HANDLE
Source

segment-sequence.lisp (file)

Method: free-handle (SEGMENT segment) HANDLE
Source

segment.lisp (file)

Method: free-handle (PACK packed-audio) HANDLE
Source

packed-audio.lisp (file)

Method: free-handle (BUFFER buffer) HANDLE
Source

buffer.lisp (file)

Generic Function: own-data OBJECT

Reader for a cons cell that holds information about the buffer in the channel.

If the cons cell stores NIL in its car, then the data buffer
is not owned by the channel and may not be freed by the
library. If it is T, the cdr must be the pointer to the
buffer data. This data is freed when the channel is GCed.

See PACKED-AUDIO

Package

cl-mixed

Methods
Method: own-data (PACKED-AUDIO packed-audio)

automatically generated reader method

Source

packed-audio.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   C   F   L   M  
Index Entry  Section

C
cl-mixed.asd: The cl-mixed<dot>asd file
cl-mixed/buffer.lisp: The cl-mixed/buffer<dot>lisp file
cl-mixed/c-object.lisp: The cl-mixed/c-object<dot>lisp file
cl-mixed/documentation.lisp: The cl-mixed/documentation<dot>lisp file
cl-mixed/low-level.lisp: The cl-mixed/low-level<dot>lisp file
cl-mixed/mixer.lisp: The cl-mixed/mixer<dot>lisp file
cl-mixed/package.lisp: The cl-mixed/package<dot>lisp file
cl-mixed/packed-audio.lisp: The cl-mixed/packed-audio<dot>lisp file
cl-mixed/segment-sequence.lisp: The cl-mixed/segment-sequence<dot>lisp file
cl-mixed/segment.lisp: The cl-mixed/segment<dot>lisp file
cl-mixed/segments: The cl-mixed/segments module
cl-mixed/segments/basic-mixer.lisp: The cl-mixed/segments/basic-mixer<dot>lisp file
cl-mixed/segments/delay.lisp: The cl-mixed/segments/delay<dot>lisp file
cl-mixed/segments/fader.lisp: The cl-mixed/segments/fader<dot>lisp file
cl-mixed/segments/frequency-pass.lisp: The cl-mixed/segments/frequency-pass<dot>lisp file
cl-mixed/segments/generator.lisp: The cl-mixed/segments/generator<dot>lisp file
cl-mixed/segments/ladspa.lisp: The cl-mixed/segments/ladspa<dot>lisp file
cl-mixed/segments/noise.lisp: The cl-mixed/segments/noise<dot>lisp file
cl-mixed/segments/packer.lisp: The cl-mixed/segments/packer<dot>lisp file
cl-mixed/segments/pitch.lisp: The cl-mixed/segments/pitch<dot>lisp file
cl-mixed/segments/repeat.lisp: The cl-mixed/segments/repeat<dot>lisp file
cl-mixed/segments/space-mixer.lisp: The cl-mixed/segments/space-mixer<dot>lisp file
cl-mixed/segments/unpacker.lisp: The cl-mixed/segments/unpacker<dot>lisp file
cl-mixed/segments/virtual.lisp: The cl-mixed/segments/virtual<dot>lisp file
cl-mixed/segments/volume-control.lisp: The cl-mixed/segments/volume-control<dot>lisp file
cl-mixed/toolkit.lisp: The cl-mixed/toolkit<dot>lisp file

F
File, Lisp, cl-mixed.asd: The cl-mixed<dot>asd file
File, Lisp, cl-mixed/buffer.lisp: The cl-mixed/buffer<dot>lisp file
File, Lisp, cl-mixed/c-object.lisp: The cl-mixed/c-object<dot>lisp file
File, Lisp, cl-mixed/documentation.lisp: The cl-mixed/documentation<dot>lisp file
File, Lisp, cl-mixed/low-level.lisp: The cl-mixed/low-level<dot>lisp file
File, Lisp, cl-mixed/mixer.lisp: The cl-mixed/mixer<dot>lisp file
File, Lisp, cl-mixed/package.lisp: The cl-mixed/package<dot>lisp file
File, Lisp, cl-mixed/packed-audio.lisp: The cl-mixed/packed-audio<dot>lisp file
File, Lisp, cl-mixed/segment-sequence.lisp: The cl-mixed/segment-sequence<dot>lisp file
File, Lisp, cl-mixed/segment.lisp: The cl-mixed/segment<dot>lisp file
File, Lisp, cl-mixed/segments/basic-mixer.lisp: The cl-mixed/segments/basic-mixer<dot>lisp file
File, Lisp, cl-mixed/segments/delay.lisp: The cl-mixed/segments/delay<dot>lisp file
File, Lisp, cl-mixed/segments/fader.lisp: The cl-mixed/segments/fader<dot>lisp file
File, Lisp, cl-mixed/segments/frequency-pass.lisp: The cl-mixed/segments/frequency-pass<dot>lisp file
File, Lisp, cl-mixed/segments/generator.lisp: The cl-mixed/segments/generator<dot>lisp file
File, Lisp, cl-mixed/segments/ladspa.lisp: The cl-mixed/segments/ladspa<dot>lisp file
File, Lisp, cl-mixed/segments/noise.lisp: The cl-mixed/segments/noise<dot>lisp file
File, Lisp, cl-mixed/segments/packer.lisp: The cl-mixed/segments/packer<dot>lisp file
File, Lisp, cl-mixed/segments/pitch.lisp: The cl-mixed/segments/pitch<dot>lisp file
File, Lisp, cl-mixed/segments/repeat.lisp: The cl-mixed/segments/repeat<dot>lisp file
File, Lisp, cl-mixed/segments/space-mixer.lisp: The cl-mixed/segments/space-mixer<dot>lisp file
File, Lisp, cl-mixed/segments/unpacker.lisp: The cl-mixed/segments/unpacker<dot>lisp file
File, Lisp, cl-mixed/segments/virtual.lisp: The cl-mixed/segments/virtual<dot>lisp file
File, Lisp, cl-mixed/segments/volume-control.lisp: The cl-mixed/segments/volume-control<dot>lisp file
File, Lisp, cl-mixed/toolkit.lisp: The cl-mixed/toolkit<dot>lisp file

L
Lisp File, cl-mixed.asd: The cl-mixed<dot>asd file
Lisp File, cl-mixed/buffer.lisp: The cl-mixed/buffer<dot>lisp file
Lisp File, cl-mixed/c-object.lisp: The cl-mixed/c-object<dot>lisp file
Lisp File, cl-mixed/documentation.lisp: The cl-mixed/documentation<dot>lisp file
Lisp File, cl-mixed/low-level.lisp: The cl-mixed/low-level<dot>lisp file
Lisp File, cl-mixed/mixer.lisp: The cl-mixed/mixer<dot>lisp file
Lisp File, cl-mixed/package.lisp: The cl-mixed/package<dot>lisp file
Lisp File, cl-mixed/packed-audio.lisp: The cl-mixed/packed-audio<dot>lisp file
Lisp File, cl-mixed/segment-sequence.lisp: The cl-mixed/segment-sequence<dot>lisp file
Lisp File, cl-mixed/segment.lisp: The cl-mixed/segment<dot>lisp file
Lisp File, cl-mixed/segments/basic-mixer.lisp: The cl-mixed/segments/basic-mixer<dot>lisp file
Lisp File, cl-mixed/segments/delay.lisp: The cl-mixed/segments/delay<dot>lisp file
Lisp File, cl-mixed/segments/fader.lisp: The cl-mixed/segments/fader<dot>lisp file
Lisp File, cl-mixed/segments/frequency-pass.lisp: The cl-mixed/segments/frequency-pass<dot>lisp file
Lisp File, cl-mixed/segments/generator.lisp: The cl-mixed/segments/generator<dot>lisp file
Lisp File, cl-mixed/segments/ladspa.lisp: The cl-mixed/segments/ladspa<dot>lisp file
Lisp File, cl-mixed/segments/noise.lisp: The cl-mixed/segments/noise<dot>lisp file
Lisp File, cl-mixed/segments/packer.lisp: The cl-mixed/segments/packer<dot>lisp file
Lisp File, cl-mixed/segments/pitch.lisp: The cl-mixed/segments/pitch<dot>lisp file
Lisp File, cl-mixed/segments/repeat.lisp: The cl-mixed/segments/repeat<dot>lisp file
Lisp File, cl-mixed/segments/space-mixer.lisp: The cl-mixed/segments/space-mixer<dot>lisp file
Lisp File, cl-mixed/segments/unpacker.lisp: The cl-mixed/segments/unpacker<dot>lisp file
Lisp File, cl-mixed/segments/virtual.lisp: The cl-mixed/segments/virtual<dot>lisp file
Lisp File, cl-mixed/segments/volume-control.lisp: The cl-mixed/segments/volume-control<dot>lisp file
Lisp File, cl-mixed/toolkit.lisp: The cl-mixed/toolkit<dot>lisp file

M
Module, cl-mixed/segments: The cl-mixed/segments module

Jump to:   C   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   L   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

(
(setf attenuation): Internal generic functions
(setf attenuation): Internal generic functions
(setf buffer-data): Exported functions
(setf buffer-size): Exported functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf bypass): Exported generic functions
(setf channels): Exported generic functions
(setf channels): Exported generic functions
(setf channels): Exported generic functions
(setf channels): Exported generic functions
(setf channels): Exported generic functions
(setf cutoff): Exported generic functions
(setf cutoff): Exported generic functions
(setf data): Exported generic functions
(setf data): Exported generic functions
(setf data): Exported generic functions
(setf data): Exported generic functions
(setf data): Exported generic functions
(setf direct-info): Internal generic functions
(setf direct-info): Internal generic functions
(setf direct-segment-data): Exported functions
(setf direct-segment-end): Exported functions
(setf direct-segment-free): Exported functions
(setf direct-segment-get): Exported functions
(setf direct-segment-get-in): Exported functions
(setf direct-segment-get-out): Exported functions
(setf direct-segment-info): Exported functions
(setf direct-segment-mix): Exported functions
(setf direct-segment-set): Exported functions
(setf direct-segment-set-in): Exported functions
(setf direct-segment-set-out): Exported functions
(setf direct-segment-start): Exported functions
(setf direction): Exported generic functions
(setf direction): Exported generic functions
(setf doppler-factor): Exported generic functions
(setf doppler-factor): Exported generic functions
(setf duration): Exported generic functions
(setf duration): Exported generic functions
(setf duration): Exported generic functions
(setf duration): Exported generic functions
(setf encoding): Exported generic functions
(setf encoding): Exported generic functions
(setf encoding): Exported generic functions
(setf encoding): Exported generic functions
(setf error-code): Exported generic functions
(setf error-code): Exported generic functions
(setf fade-type): Exported generic functions
(setf fade-type): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field): Exported generic functions
(setf field-info-description): Exported functions
(setf field-info-field): Exported functions
(setf field-info-flags): Exported functions
(setf field-info-type): Exported functions
(setf field-info-type-count): Exported functions
(setf frequency): Exported generic functions
(setf frequency): Exported generic functions
(setf frequency-pass): Exported generic functions
(setf frequency-pass): Exported generic functions
(setf from): Exported generic functions
(setf from): Exported generic functions
(setf handle): Exported generic functions
(setf handle): Exported generic functions
(setf input): Exported generic functions
(setf input): Exported generic functions
(setf input-field): Exported generic functions
(setf input-field): Exported generic functions
(setf input-field): Exported generic functions
(setf input-field): Exported generic functions
(setf input-field): Exported generic functions
(setf input-field): Exported generic functions
(setf input-field): Exported generic functions
(setf input-location): Exported generic functions
(setf input-location): Exported generic functions
(setf input-location): Exported generic functions
(setf input-location): Exported generic functions
(setf input-velocity): Exported generic functions
(setf input-velocity): Exported generic functions
(setf input-velocity): Exported generic functions
(setf input-velocity): Exported generic functions
(setf layout): Exported generic functions
(setf layout): Exported generic functions
(setf layout): Exported generic functions
(setf layout): Exported generic functions
(setf location): Exported generic functions
(setf location): Exported generic functions
(setf max-distance): Exported generic functions
(setf max-distance): Exported generic functions
(setf min-distance): Exported generic functions
(setf min-distance): Exported generic functions
(setf noise-type): Exported generic functions
(setf noise-type): Exported generic functions
(setf output): Exported generic functions
(setf output): Exported generic functions
(setf output-field): Exported generic functions
(setf output-field): Exported generic functions
(setf output-field): Exported generic functions
(setf output-field): Exported generic functions
(setf packed-audio-channels): Exported functions
(setf packed-audio-data): Exported functions
(setf packed-audio-encoding): Exported functions
(setf packed-audio-layout): Exported functions
(setf packed-audio-samplerate): Exported functions
(setf packed-audio-size): Exported functions
(setf pan): Exported generic functions
(setf pan): Exported generic functions
(setf pitch): Exported generic functions
(setf pitch): Exported generic functions
(setf pointer->object): Exported functions
(setf repeat-mode): Exported generic functions
(setf repeat-mode): Exported generic functions
(setf rolloff): Exported generic functions
(setf rolloff): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf samplerate): Exported generic functions
(setf segment-info-description): Exported functions
(setf segment-info-fields): Exported functions
(setf segment-info-flags): Exported functions
(setf segment-info-max-inputs): Exported functions
(setf segment-info-min-inputs): Exported functions
(setf segment-info-name): Exported functions
(setf segment-info-outputs): Exported functions
(setf segment-sequence-count): Exported functions
(setf segment-sequence-segments): Exported functions
(setf segment-sequence-size): Exported functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf size): Exported generic functions
(setf soundspeed): Exported generic functions
(setf soundspeed): Exported generic functions
(setf source): Exported generic functions
(setf sources): Exported generic functions
(setf sources): Exported generic functions
(setf to): Exported generic functions
(setf to): Exported generic functions
(setf up): Exported generic functions
(setf up): Exported generic functions
(setf velocity): Exported generic functions
(setf velocity): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf volume): Exported generic functions
(setf wave-type): Exported generic functions
(setf wave-type): Exported generic functions

A
add: Exported generic functions
add: Exported generic functions
add: Exported generic functions
add: Exported generic functions
add: Exported generic functions
allocate-handle: Internal generic functions
allocate-handle: Internal generic functions
allocate-handle: Internal generic functions
allocate-handle: Internal generic functions
allocate-handle: Internal generic functions
attenuation: Internal generic functions
attenuation: Internal generic functions

B
buffer-data: Exported functions
buffer-from-packed-audio: Exported functions
buffer-size: Exported functions
buffer-to-packed-audio: Exported functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions
bypass: Exported generic functions

C
calloc: Internal functions
channels: Exported generic functions
channels: Exported generic functions
channels: Exported generic functions
channels: Exported generic functions
channels: Exported generic functions
clear: Exported generic functions
clear: Exported generic functions
clear-buffer: Exported functions
coerce-ctype: Internal functions
connect: Exported generic functions
connect: Exported generic functions
copy-buffer: Exported functions
cutoff: Exported generic functions
cutoff: Exported generic functions

D
data: Exported generic functions
data: Exported generic functions
data: Exported generic functions
data: Exported generic functions
data: Exported generic functions
decode-field-info: Internal functions
decode-flags: Internal functions
define-accessor: Internal macros
define-callback: Internal macros
define-delegated-slot-accessor: Internal macros
define-field-accessor: Internal macros
define-input-vector-field-accessor: Internal macros
define-std-callback: Internal macros
define-vector-field-accessor: Internal macros
direct-info: Internal generic functions
direct-info: Internal generic functions
direct-segment-data: Exported functions
direct-segment-end: Exported functions
direct-segment-free: Exported functions
direct-segment-get: Exported functions
direct-segment-get-in: Exported functions
direct-segment-get-out: Exported functions
direct-segment-info: Exported functions
direct-segment-mix: Exported functions
direct-segment-set: Exported functions
direct-segment-set-in: Exported functions
direct-segment-set-out: Exported functions
direct-segment-start: Exported functions
direction: Exported generic functions
direction: Exported generic functions
doppler-factor: Exported generic functions
doppler-factor: Exported generic functions
duration: Exported generic functions
duration: Exported generic functions
duration: Exported generic functions
duration: Exported generic functions

E
encode-field-info: Internal functions
encode-flags: Internal functions
encoding: Exported generic functions
encoding: Exported generic functions
encoding: Exported generic functions
encoding: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
end: Exported generic functions
error: Exported functions
error-code: Exported generic functions
error-code: Exported generic functions
error-string: Exported functions

F
fade-type: Exported generic functions
fade-type: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field: Exported generic functions
field-info-description: Exported functions
field-info-field: Exported functions
field-info-flags: Exported functions
field-info-type: Exported functions
field-info-type-count: Exported functions
free: Exported generic functions
free: Exported generic functions
free-buffer: Exported functions
free-handle: Internal generic functions
free-handle: Internal generic functions
free-handle: Internal generic functions
free-handle: Internal generic functions
free-handle: Internal generic functions
free-handle: Internal generic functions
free-segment: Exported functions
free-segment-sequence: Exported functions
frequency: Exported generic functions
frequency: Exported generic functions
frequency-pass: Exported generic functions
frequency-pass: Exported generic functions
from: Exported generic functions
from: Exported generic functions
Function, (setf buffer-data): Exported functions
Function, (setf buffer-size): Exported functions
Function, (setf direct-segment-data): Exported functions
Function, (setf direct-segment-end): Exported functions
Function, (setf direct-segment-free): Exported functions
Function, (setf direct-segment-get): Exported functions
Function, (setf direct-segment-get-in): Exported functions
Function, (setf direct-segment-get-out): Exported functions
Function, (setf direct-segment-info): Exported functions
Function, (setf direct-segment-mix): Exported functions
Function, (setf direct-segment-set): Exported functions
Function, (setf direct-segment-set-in): Exported functions
Function, (setf direct-segment-set-out): Exported functions
Function, (setf direct-segment-start): Exported functions
Function, (setf field-info-description): Exported functions
Function, (setf field-info-field): Exported functions
Function, (setf field-info-flags): Exported functions
Function, (setf field-info-type): Exported functions
Function, (setf field-info-type-count): Exported functions
Function, (setf packed-audio-channels): Exported functions
Function, (setf packed-audio-data): Exported functions
Function, (setf packed-audio-encoding): Exported functions
Function, (setf packed-audio-layout): Exported functions
Function, (setf packed-audio-samplerate): Exported functions
Function, (setf packed-audio-size): Exported functions
Function, (setf pointer->object): Exported functions
Function, (setf segment-info-description): Exported functions
Function, (setf segment-info-fields): Exported functions
Function, (setf segment-info-flags): Exported functions
Function, (setf segment-info-max-inputs): Exported functions
Function, (setf segment-info-min-inputs): Exported functions
Function, (setf segment-info-name): Exported functions
Function, (setf segment-info-outputs): Exported functions
Function, (setf segment-sequence-count): Exported functions
Function, (setf segment-sequence-segments): Exported functions
Function, (setf segment-sequence-size): Exported functions
Function, buffer-data: Exported functions
Function, buffer-from-packed-audio: Exported functions
Function, buffer-size: Exported functions
Function, buffer-to-packed-audio: Exported functions
Function, calloc: Internal functions
Function, clear-buffer: Exported functions
Function, coerce-ctype: Internal functions
Function, copy-buffer: Exported functions
Function, decode-field-info: Internal functions
Function, decode-flags: Internal functions
Function, direct-segment-data: Exported functions
Function, direct-segment-end: Exported functions
Function, direct-segment-free: Exported functions
Function, direct-segment-get: Exported functions
Function, direct-segment-get-in: Exported functions
Function, direct-segment-get-out: Exported functions
Function, direct-segment-info: Exported functions
Function, direct-segment-mix: Exported functions
Function, direct-segment-set: Exported functions
Function, direct-segment-set-in: Exported functions
Function, direct-segment-set-out: Exported functions
Function, direct-segment-start: Exported functions
Function, encode-field-info: Internal functions
Function, encode-flags: Internal functions
Function, error: Exported functions
Function, error-string: Exported functions
Function, field-info-description: Exported functions
Function, field-info-field: Exported functions
Function, field-info-flags: Exported functions
Function, field-info-type: Exported functions
Function, field-info-type-count: Exported functions
Function, free-buffer: Exported functions
Function, free-segment: Exported functions
Function, free-segment-sequence: Exported functions
Function, make-basic-mixer: Exported functions
Function, make-buffer: Exported functions
Function, make-buffer: Exported functions
Function, make-delay: Exported functions
Function, make-fader: Exported functions
Function, make-frequency-pass: Exported functions
Function, make-generator: Exported functions
Function, make-ladspa: Exported functions
Function, make-noise: Exported functions
Function, make-packed-audio: Exported functions
Function, make-packer: Exported functions
Function, make-pitch: Exported functions
Function, make-repeat: Exported functions
Function, make-segment-basic-mixer: Exported functions
Function, make-segment-delay: Exported functions
Function, make-segment-fade: Exported functions
Function, make-segment-frequency-pass: Exported functions
Function, make-segment-generator: Exported functions
Function, make-segment-ladspa: Exported functions
Function, make-segment-noise: Exported functions
Function, make-segment-packer: Exported functions
Function, make-segment-pitch: Exported functions
Function, make-segment-repeat: Exported functions
Function, make-segment-sequence: Exported functions
Function, make-segment-space-mixer: Exported functions
Function, make-segment-unpacker: Exported functions
Function, make-segment-volume-control: Exported functions
Function, make-space-mixer: Exported functions
Function, make-unpacker: Exported functions
Function, make-volume-control: Exported functions
Function, packed-audio-channels: Exported functions
Function, packed-audio-data: Exported functions
Function, packed-audio-encoding: Exported functions
Function, packed-audio-layout: Exported functions
Function, packed-audio-samplerate: Exported functions
Function, packed-audio-size: Exported functions
Function, pointer->object: Exported functions
Function, ptr->vec: Internal functions
Function, removef: Internal functions
Function, resample-cubic: Exported functions
Function, resample-linear: Exported functions
Function, resample-nearest: Exported functions
Function, resize-buffer: Exported functions
Function, samplesize: Exported functions
Function, segment-end: Exported functions
Function, segment-get: Exported functions
Function, segment-get-in: Exported functions
Function, segment-get-out: Exported functions
Function, segment-info: Exported functions
Function, segment-info-description: Exported functions
Function, segment-info-fields: Exported functions
Function, segment-info-flags: Exported functions
Function, segment-info-max-inputs: Exported functions
Function, segment-info-min-inputs: Exported functions
Function, segment-info-name: Exported functions
Function, segment-info-outputs: Exported functions
Function, segment-mix: Exported functions
Function, segment-sequence-add: Exported functions
Function, segment-sequence-count: Exported functions
Function, segment-sequence-end: Exported functions
Function, segment-sequence-mix: Exported functions
Function, segment-sequence-remove: Exported functions
Function, segment-sequence-segments: Exported functions
Function, segment-sequence-size: Exported functions
Function, segment-sequence-start: Exported functions
Function, segment-set: Exported functions
Function, segment-set-in: Exported functions
Function, segment-set-out: Exported functions
Function, segment-start: Exported functions
Function, vec->ptr: Internal functions
Function, vector-insert-pos: Internal functions
Function, vector-remove: Internal functions
Function, vector-remove-pos: Internal functions

G
Generic Function, (setf attenuation): Internal generic functions
Generic Function, (setf bypass): Exported generic functions
Generic Function, (setf channels): Exported generic functions
Generic Function, (setf cutoff): Exported generic functions
Generic Function, (setf data): Exported generic functions
Generic Function, (setf direct-info): Internal generic functions
Generic Function, (setf direction): Exported generic functions
Generic Function, (setf doppler-factor): Exported generic functions
Generic Function, (setf duration): Exported generic functions
Generic Function, (setf encoding): Exported generic functions
Generic Function, (setf error-code): Exported generic functions
Generic Function, (setf fade-type): Exported generic functions
Generic Function, (setf field): Exported generic functions
Generic Function, (setf frequency): Exported generic functions
Generic Function, (setf frequency-pass): Exported generic functions
Generic Function, (setf from): Exported generic functions
Generic Function, (setf handle): Exported generic functions
Generic Function, (setf input): Exported generic functions
Generic Function, (setf input-field): Exported generic functions
Generic Function, (setf input-location): Exported generic functions
Generic Function, (setf input-velocity): Exported generic functions
Generic Function, (setf layout): Exported generic functions
Generic Function, (setf location): Exported generic functions
Generic Function, (setf max-distance): Exported generic functions
Generic Function, (setf min-distance): Exported generic functions
Generic Function, (setf noise-type): Exported generic functions
Generic Function, (setf output): Exported generic functions
Generic Function, (setf output-field): Exported generic functions
Generic Function, (setf pan): Exported generic functions
Generic Function, (setf pitch): Exported generic functions
Generic Function, (setf repeat-mode): Exported generic functions
Generic Function, (setf rolloff): Exported generic functions
Generic Function, (setf samplerate): Exported generic functions
Generic Function, (setf size): Exported generic functions
Generic Function, (setf soundspeed): Exported generic functions
Generic Function, (setf source): Exported generic functions
Generic Function, (setf sources): Exported generic functions
Generic Function, (setf to): Exported generic functions
Generic Function, (setf up): Exported generic functions
Generic Function, (setf velocity): Exported generic functions
Generic Function, (setf volume): Exported generic functions
Generic Function, (setf wave-type): Exported generic functions
Generic Function, add: Exported generic functions
Generic Function, allocate-handle: Internal generic functions
Generic Function, attenuation: Internal generic functions
Generic Function, bypass: Exported generic functions
Generic Function, channels: Exported generic functions
Generic Function, clear: Exported generic functions
Generic Function, connect: Exported generic functions
Generic Function, cutoff: Exported generic functions
Generic Function, data: Exported generic functions
Generic Function, direct-info: Internal generic functions
Generic Function, direction: Exported generic functions
Generic Function, doppler-factor: Exported generic functions
Generic Function, duration: Exported generic functions
Generic Function, encoding: Exported generic functions
Generic Function, end: Exported generic functions
Generic Function, error-code: Exported generic functions
Generic Function, fade-type: Exported generic functions
Generic Function, field: Exported generic functions
Generic Function, free: Exported generic functions
Generic Function, free-handle: Internal generic functions
Generic Function, frequency: Exported generic functions
Generic Function, frequency-pass: Exported generic functions
Generic Function, from: Exported generic functions
Generic Function, handle: Exported generic functions
Generic Function, info: Exported generic functions
Generic Function, input: Exported generic functions
Generic Function, input-field: Exported generic functions
Generic Function, input-location: Exported generic functions
Generic Function, input-velocity: Exported generic functions
Generic Function, inputs: Exported generic functions
Generic Function, layout: Exported generic functions
Generic Function, location: Exported generic functions
Generic Function, max-distance: Exported generic functions
Generic Function, min-distance: Exported generic functions
Generic Function, mix: Exported generic functions
Generic Function, noise-type: Exported generic functions
Generic Function, output: Exported generic functions
Generic Function, output-field: Exported generic functions
Generic Function, outputs: Exported generic functions
Generic Function, own-data: Internal generic functions
Generic Function, packed-audio: Exported generic functions
Generic Function, pan: Exported generic functions
Generic Function, pitch: Exported generic functions
Generic Function, repeat-mode: Exported generic functions
Generic Function, rolloff: Exported generic functions
Generic Function, samplerate: Exported generic functions
Generic Function, segments: Exported generic functions
Generic Function, size: Exported generic functions
Generic Function, soundspeed: Exported generic functions
Generic Function, source: Exported generic functions
Generic Function, sources: Exported generic functions
Generic Function, start: Exported generic functions
Generic Function, to: Exported generic functions
Generic Function, up: Exported generic functions
Generic Function, velocity: Exported generic functions
Generic Function, volume: Exported generic functions
Generic Function, wave-type: Exported generic functions
Generic Function, withdraw: Exported generic functions

H
handle: Exported generic functions
handle: Exported generic functions
handle: Exported generic functions

I
info: Exported generic functions
info: Exported generic functions
info: Exported generic functions
input: Exported generic functions
input: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-field: Exported generic functions
input-location: Exported generic functions
input-location: Exported generic functions
input-location: Exported generic functions
input-location: Exported generic functions
input-velocity: Exported generic functions
input-velocity: Exported generic functions
input-velocity: Exported generic functions
input-velocity: Exported generic functions
inputs: Exported generic functions
inputs: Exported generic functions

L
layout: Exported generic functions
layout: Exported generic functions
layout: Exported generic functions
layout: Exported generic functions
location: Exported generic functions
location: Exported generic functions

M
Macro, define-accessor: Internal macros
Macro, define-callback: Internal macros
Macro, define-delegated-slot-accessor: Internal macros
Macro, define-field-accessor: Internal macros
Macro, define-input-vector-field-accessor: Internal macros
Macro, define-std-callback: Internal macros
Macro, define-vector-field-accessor: Internal macros
Macro, with-buffers: Exported macros
Macro, with-cleanup-on-failure: Internal macros
Macro, with-error-on-failure: Internal macros
make-basic-mixer: Exported functions
make-buffer: Exported functions
make-buffer: Exported functions
make-delay: Exported functions
make-fader: Exported functions
make-frequency-pass: Exported functions
make-generator: Exported functions
make-ladspa: Exported functions
make-noise: Exported functions
make-packed-audio: Exported functions
make-packer: Exported functions
make-pitch: Exported functions
make-repeat: Exported functions
make-segment-basic-mixer: Exported functions
make-segment-delay: Exported functions
make-segment-fade: Exported functions
make-segment-frequency-pass: Exported functions
make-segment-generator: Exported functions
make-segment-ladspa: Exported functions
make-segment-noise: Exported functions
make-segment-packer: Exported functions
make-segment-pitch: Exported functions
make-segment-repeat: Exported functions
make-segment-sequence: Exported functions
make-segment-space-mixer: Exported functions
make-segment-unpacker: Exported functions
make-segment-volume-control: Exported functions
make-space-mixer: Exported functions
make-unpacker: Exported functions
make-volume-control: Exported functions
max-distance: Exported generic functions
max-distance: Exported generic functions
Method, (setf attenuation): Internal generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf bypass): Exported generic functions
Method, (setf channels): Exported generic functions
Method, (setf channels): Exported generic functions
Method, (setf channels): Exported generic functions
Method, (setf channels): Exported generic functions
Method, (setf cutoff): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf data): Exported generic functions
Method, (setf direct-info): Internal generic functions
Method, (setf direction): Exported generic functions
Method, (setf doppler-factor): Exported generic functions
Method, (setf duration): Exported generic functions
Method, (setf duration): Exported generic functions
Method, (setf duration): Exported generic functions
Method, (setf encoding): Exported generic functions
Method, (setf encoding): Exported generic functions
Method, (setf encoding): Exported generic functions
Method, (setf error-code): Exported generic functions
Method, (setf fade-type): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf field): Exported generic functions
Method, (setf frequency): Exported generic functions
Method, (setf frequency-pass): Exported generic functions
Method, (setf from): Exported generic functions
Method, (setf handle): Exported generic functions
Method, (setf input): Exported generic functions
Method, (setf input-field): Exported generic functions
Method, (setf input-field): Exported generic functions
Method, (setf input-field): Exported generic functions
Method, (setf input-field): Exported generic functions
Method, (setf input-field): Exported generic functions
Method, (setf input-field): Exported generic functions
Method, (setf input-location): Exported generic functions
Method, (setf input-location): Exported generic functions
Method, (setf input-location): Exported generic functions
Method, (setf input-velocity): Exported generic functions
Method, (setf input-velocity): Exported generic functions
Method, (setf input-velocity): Exported generic functions
Method, (setf layout): Exported generic functions
Method, (setf layout): Exported generic functions
Method, (setf layout): Exported generic functions
Method, (setf location): Exported generic functions
Method, (setf max-distance): Exported generic functions
Method, (setf min-distance): Exported generic functions
Method, (setf noise-type): Exported generic functions
Method, (setf output): Exported generic functions
Method, (setf output-field): Exported generic functions
Method, (setf output-field): Exported generic functions
Method, (setf output-field): Exported generic functions
Method, (setf pan): Exported generic functions
Method, (setf pitch): Exported generic functions
Method, (setf repeat-mode): Exported generic functions
Method, (setf rolloff): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf samplerate): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf size): Exported generic functions
Method, (setf soundspeed): Exported generic functions
Method, (setf sources): Exported generic functions
Method, (setf to): Exported generic functions
Method, (setf up): Exported generic functions
Method, (setf velocity): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf volume): Exported generic functions
Method, (setf wave-type): Exported generic functions
Method, add: Exported generic functions
Method, add: Exported generic functions
Method, add: Exported generic functions
Method, add: Exported generic functions
Method, allocate-handle: Internal generic functions
Method, allocate-handle: Internal generic functions
Method, allocate-handle: Internal generic functions
Method, allocate-handle: Internal generic functions
Method, attenuation: Internal generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, bypass: Exported generic functions
Method, channels: Exported generic functions
Method, channels: Exported generic functions
Method, channels: Exported generic functions
Method, channels: Exported generic functions
Method, clear: Exported generic functions
Method, connect: Exported generic functions
Method, cutoff: Exported generic functions
Method, data: Exported generic functions
Method, data: Exported generic functions
Method, data: Exported generic functions
Method, data: Exported generic functions
Method, direct-info: Internal generic functions
Method, direction: Exported generic functions
Method, doppler-factor: Exported generic functions
Method, duration: Exported generic functions
Method, duration: Exported generic functions
Method, duration: Exported generic functions
Method, encoding: Exported generic functions
Method, encoding: Exported generic functions
Method, encoding: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, end: Exported generic functions
Method, error-code: Exported generic functions
Method, fade-type: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, field: Exported generic functions
Method, free: Exported generic functions
Method, free-handle: Internal generic functions
Method, free-handle: Internal generic functions
Method, free-handle: Internal generic functions
Method, free-handle: Internal generic functions
Method, free-handle: Internal generic functions
Method, frequency: Exported generic functions
Method, frequency-pass: Exported generic functions
Method, from: Exported generic functions
Method, handle: Exported generic functions
Method, handle: Exported generic functions
Method, info: Exported generic functions
Method, info: Exported generic functions
Method, input: Exported generic functions
Method, input-field: Exported generic functions
Method, input-field: Exported generic functions
Method, input-field: Exported generic functions
Method, input-field: Exported generic functions
Method, input-field: Exported generic functions
Method, input-field: Exported generic functions
Method, input-field: Exported generic functions
Method, input-location: Exported generic functions
Method, input-location: Exported generic functions
Method, input-location: Exported generic functions
Method, input-velocity: Exported generic functions
Method, input-velocity: Exported generic functions
Method, input-velocity: Exported generic functions
Method, inputs: Exported generic functions
Method, layout: Exported generic functions
Method, layout: Exported generic functions
Method, layout: Exported generic functions
Method, location: Exported generic functions
Method, max-distance: Exported generic functions
Method, min-distance: Exported generic functions
Method, mix: Exported generic functions
Method, mix: Exported generic functions
Method, mix: Exported generic functions
Method, noise-type: Exported generic functions
Method, output: Exported generic functions
Method, output-field: Exported generic functions
Method, output-field: Exported generic functions
Method, output-field: Exported generic functions
Method, output-field: Exported generic functions
Method, outputs: Exported generic functions
Method, own-data: Internal generic functions
Method, packed-audio: Exported generic functions
Method, packed-audio: Exported generic functions
Method, pan: Exported generic functions
Method, pitch: Exported generic functions
Method, repeat-mode: Exported generic functions
Method, rolloff: Exported generic functions
Method, samplerate: Exported generic functions
Method, samplerate: Exported generic functions
Method, samplerate: Exported generic functions
Method, samplerate: Exported generic functions
Method, samplerate: Exported generic functions
Method, samplerate: Exported generic functions
Method, samplerate: Exported generic functions
Method, segments: Exported generic functions
Method, size: Exported generic functions
Method, size: Exported generic functions
Method, size: Exported generic functions
Method, size: Exported generic functions
Method, size: Exported generic functions
Method, soundspeed: Exported generic functions
Method, source: Exported generic functions
Method, source: Exported generic functions
Method, sources: Exported generic functions
Method, start: Exported generic functions
Method, start: Exported generic functions
Method, start: Exported generic functions
Method, to: Exported generic functions
Method, up: Exported generic functions
Method, velocity: Exported generic functions
Method, volume: Exported generic functions
Method, volume: Exported generic functions
Method, volume: Exported generic functions
Method, volume: Exported generic functions
Method, volume: Exported generic functions
Method, volume: Exported generic functions
Method, volume: Exported generic functions
Method, wave-type: Exported generic functions
Method, withdraw: Exported generic functions
Method, withdraw: Exported generic functions
Method, withdraw: Exported generic functions
Method, withdraw: Exported generic functions
min-distance: Exported generic functions
min-distance: Exported generic functions
mix: Exported generic functions
mix: Exported generic functions
mix: Exported generic functions
mix: Exported generic functions

N
noise-type: Exported generic functions
noise-type: Exported generic functions

O
output: Exported generic functions
output: Exported generic functions
output-field: Exported generic functions
output-field: Exported generic functions
output-field: Exported generic functions
output-field: Exported generic functions
output-field: Exported generic functions
outputs: Exported generic functions
outputs: Exported generic functions
own-data: Internal generic functions
own-data: Internal generic functions

P
packed-audio: Exported generic functions
packed-audio: Exported generic functions
packed-audio: Exported generic functions
packed-audio-channels: Exported functions
packed-audio-data: Exported functions
packed-audio-encoding: Exported functions
packed-audio-layout: Exported functions
packed-audio-samplerate: Exported functions
packed-audio-size: Exported functions
pan: Exported generic functions
pan: Exported generic functions
pitch: Exported generic functions
pitch: Exported generic functions
pointer->object: Exported functions
ptr->vec: Internal functions

R
removef: Internal functions
repeat-mode: Exported generic functions
repeat-mode: Exported generic functions
resample-cubic: Exported functions
resample-linear: Exported functions
resample-nearest: Exported functions
resize-buffer: Exported functions
rolloff: Exported generic functions
rolloff: Exported generic functions

S
samplerate: Exported generic functions
samplerate: Exported generic functions
samplerate: Exported generic functions
samplerate: Exported generic functions
samplerate: Exported generic functions
samplerate: Exported generic functions
samplerate: Exported generic functions
samplerate: Exported generic functions
samplesize: Exported functions
segment-end: Exported functions
segment-get: Exported functions
segment-get-in: Exported functions
segment-get-out: Exported func