Debian Multimedia Pure data packages

deken is a simple and easy to use package manager for Pure Data (Pd).

This package provides a command line tool that facilitates the creation and upload of your own packages to the official package repository puredata.info.

Gem is a loadable library for Pure Data (Pd), which adds OpenGL graphics rendering and animation to Pd. Pd is a graphical programming language and computer music system.

This package contains the core library. If you want to use external data (live video capture, film footage, still images, ...), you have to install one (or all) of the gem-plugin-* packages.

PDP is an extension library for Pd that allows you to manipulate movies and live video data in realtime. PDP stands for Pd Packet, the data container that is used for images in PDP.

This library extends PDP with texture and render context packets, to use some of the power of current video hardware.

Warning: this is still experimental and incomplete!

[abl_link~] is a Pd object that integrates Ableton Link into Pure Data (Pd). It has four outlets, which emit the index of the current step (at the beginning of each step), the current phase and beat time on each DSP tick, as well as the tempo on tempo changes. Phase and beat time are Link concepts. The purpose of the step feature is to generate events in Pd at a given rate (measured in steps per beat).

libambix is a library of C routines for reading and writing files following the "ambix" (AMBIsonics eXchange) conventions.

Ambisonics is a periphonic (3D) surround sound technique, with a scalable spatial resolution (put simply: "the more audio channels you use, the better"). The ambix convention defines an extensible format for exchanging soundfiles containing Higher Order Ambisonics data.

This package contains a set of Pure Data (Pd) objects to interact with ambix-files:

• [ambix_info]: information about ambix files
• [ambix_read~]: play an ambix file (simple mode)
• [ambix_readX~]: play an ambix file (extended mode)
• [ambix_write~]: record an ambix file

This provides a simple object for Pure Data that reports the size of an array by name. For historical reasons, it is packaged as a standalone object. It is a very simple object, but has always been distributed by itself. It is packaged alone in keeping with the one-library-per-package style of all other pd libraries.

This is a tiny package that might otherwise be lumped into a 'goodies' package, but it is the only tiny one like this, so a 'goodies' package would end up being just this single object anyway.

Since Pd>=0.47, this object can be replaced with the built-in [array size].

aubio gathers a set of functions for audio signal segmentation and labelling. The library contains a phase vocoder, onset and pitch detection functions, a beat tracking algorithm and other sound processing utilities.

This package provides PureData objects to use the aubio features.

AutoPreset is a simple state saving system (like rradical/ssad, among other ones). It aims to be simple and yet powerful.

One particularity of this system is to be able to interpolate float parameters between different settings (parameter morphing).

bassemu~ is an object that simulates a transistor-based electronic synthesizer. This serves as a emulation of an analogue bass synth. It includes the obligatory filter, saw/rect/tri/sine waveform select, an extra hi-pass filter. You can also feed another signal to its left inlet, and filter that, either alone or mixed to the vco.

Also included is a small, messy gop abstraction to resemble a 16-step sequencer.

This object is a realtime scheduler, event-delay, and quantizer object for Pure Data. It is used for making beats and other rhythmic sequences. Any list starting with a number T sent to the left inlet, will be sent to the output after T beats, quantized with tpq (tick per quarter) and stripped of the leading beat number. The tempo can be changed dynamically on the right inlet The quantification can be set at any time with a set-tpq message.

Boids is a bird flight and animal flock simulator. It is based on the same algorithm which was used in Jurassic Park for the herding dinosaurs. Boids takes an integer argument which is the number of boids. Each time Boids receives a bang, it calculates and outputs the new positions of the boids. The output consists of thew coordiantes for each boid, the number and type depending on the mode.

The flight parameters can be changed with messages. Use the 'dump' message to output a list of the current parameter settings.

For more information about the Boids algorithm, see Craig Reynolds' Web site at http://www.red3d.com/cwr/

bsaylor is a library of Pure Data objects by Benjamin Saylor:

pvoc~: a phase vocoder based on Pd's 09.pvoc.pd example patch. Advantages over the abstraction include (reportedly) faster execution, instantaneous response to input, and adjustable phase locking. It requires FFTW3.

susloop~: sample player with various loop methods (ping-pong, ... ) like a classic tracker interface.

svf~: a signal-controlled port of Steve Harris' state variable filter LADSPA plugin (http://plugin.org.uk).

zhzhx~: Turns the input signal into a staticky, distorted mess. Comes with tone control

chaos is a library of Pd objects for calculating various chaotic attractors, including: lorenz, rossler, henon, ikeda, attract1, base, base3, dejong, gingerbreadman, hopalong, latoocarfian, latoomutalpha, latoomutbeta, latoomutgamma, logistic, lotka_volterra, martin, mlogistic, pickover, popcorn, quadruptwo, standardmap, strange1, tent, three_d, threeply, tinkerbell and unity.

The package includes 1, 2 and 3 dimensional attractors. There are outlets for each dimension, starting from the left, followed by three outlets for attractor data (see the help patches for details). The scale of the values vary between the different attractors.

Some of the algorithms were derived from other projects, including Julian C. Sprott's attract.java and algorithms by Cliff Pickover.

This is a collection of small objects that emulate logic CMOS components, namely the CD4000 series. It currently contains 25 objects of the cd4000 series.

The emulation assumes idealized components, and works in the message domain.

comport is a cross-platform object for Pure Data that allows you to read and write bytes and lists of data to /dev/tty* devices including serial port, USB-serial devices, Bluetooth-serial, etc.

CREB - compl. red. ext. blk.

CREB is a collection of general purpose externals for Pd by Tom Schouten. It includes among other things:

• frequency and time domain dynamic wavetable synthesis (scanned synthesis in the framework of linear and nonlinear state space models)
• several virtual analog oscillators and filters
• oscillators based on explicit complex and quaternion mathematics
• building blocks for the discrete wavelet transform and other spectral transform tools, smallband oscillators and formant synthesis
• several chaotic oscillators

This is the csound6~ object for Pure Data (Pd). It allows you to run and interact with Csound scores/instruments from within Pd.

For more information on Csound or Pd, see the respective packages.

cxc is a library of Pd objects for random numbers, number patterns and a couple errant system tools.

• ixprint: print data on console without prefix (needed for ascwave)
• binshift: binary shift objects (<<,>>)
• ascseq: ascii-sequencer: input anything, which is output again sequentially character by character with a given delay
• ascwave: print funny ascii constructions on console
• bfilt: re-output every argumen-th event, useful for modulo-sequencers
• bfilt2: features internal counter, output just bangs
• cxc_counter: a clone of the counting object from pd-markex
• reson: an interpolating reson filter
• cxc_prepend: prepend stuff with another symbol
• cxc_split: split incoming string at specified delimiter
• utime: output seconds since epoch and microsecond fraction
• random1, random_fl, random_icg, random_tw, dist_normal: PRNG algorithms
• random1~, random_fl~, random_icg~: signal version of above algorithms
• ENV: get and set environment variables and certain defines like RAND_MAX
• proc: get stuff out of the Linux proc directory (so far: cpuinfo, loadavg, version, uptime)
• delta~: emit distance to last sample as signal
• cx.mean, cx.avgdev, cx.stddev: calculate mean, standard and average deviation of a signal in an array

Cyclone is a library of PureData classes, bringing some level of compatibility between Max/MSP and Pd environments.

In its current form, cyclone is mainly for people using both Max and Pd, and thus wanting to develop cross-platform patches. In this respect, cyclone has much in common with Thomas Grill's flext, and flext-based externals. While flext enables developing new cross-platform classes, cyclone makes existing classes cross-platform.

Cyclone also comes handy, somewhat, in the task of importing Max/MSP patches into Pd. Do not expect miracles, though, it is usually not an easy task.

deken is a simple and easy to use package manager for Pure Data (Pd).

The deken-plugin integrates with the Pd user interface, where you can search for externals and install them with a single click. Since Pd-0.47, the deken-plugin is integrated into Pure Data (but the Debian package provides an updated plugin)

Available backends that provide packages are:

• puredata.info (downloads packages via the Pure Data community website and installs them into the per-user installation directory (~/pd-externals))
• apt (installs Pd packages the Debian way; packaged as "pd-deken-apt")

deken is a simple and easy to use package manager for Pure Data (Pd).

The deken-plugin integrates with the Pd user interface, where you can search for externals and install them with a single click.

This addon allows one to additionally use 'apt' for installing Debian provided packages from within the deken-plugin (rather than downloading binaries from the Pure Data community website).

earplug~ is a realtime binaural filter based on KEMAR impulse measurement. It allows you to spatialize a sound in realtime. It basically takes the KEMAR data set, and interpolates 366 locations where HRTF measurement exists in a spherical surface. you get azimuth control 0-360 and elevation -40 - 90.

This library is a collection of objects for analyzing audio to get musical information, like spectrum and peak information, to generate sound based on analysis, like Linear-Predictive Coding, and for working with polyphony.

ext13 is a collection of various externals for Pd

• catch13~, throw13~, send13~, receive13~: alternate versions that accept a set msg
• mandelbrot, mandelbrot~: calculcate mandelbrot data
• wavinfo: get info from WAV files
• strippath: strip the path from a filename
• filesize: get the size of a file
• openpatch: open a patch file with a message
• ftos: convert a float to symbol
• ossmixer: control the OSS mixer
• cdplayer: control the CDROM drive
• kalashnikov: send out many bangs

Extended View Toolkit is a set of Pure Data (Pd) abstractions for combining multiple video or image sources into a panoramic image and for projection setups with multiple projectors or projection environments with challenging geometric forms, better known as video mapping.

Multiple input media (e.g. camera input, video files, image files, 3D renderings) can be processed. It is possible to create imagery or video by either stitching multiple inputs to one continuous, or by unwrapping a 360-degree image taken with a special optical lens system. Such processed media input can then be projected onto even irregular shaped surfaces. It is possible to blend smoothly between multiple projectors, to create seamless immersive media environments.

FFTease is a collection of Pd objects implementing various forms of spectral sound processing. These include an additive-synthesis phase vocoder, noise reduction, cross synthesis, and more unusual forms of spectral processing.

• bthresher~ similar to thresher~ but with more control
• burrow~ a cross-referenced filtering object
• cavoc~ an 8-rule cellular automata that generates spectra
• cavoc27~ a 27-rule cellular automata object
• centerring~ a spectral modulation object
• codepend~ a classic block convolution object
• crossx~ a cross synthesis object with gating
• dentist~ a partial knockout object
• disarrain~ an interpolating version of disarray~
• disarray~ a spectral redistribution object
• drown~ a noise reduction (or increase) object
• ether~ another spectral compositing object
• leaker~ a sieve-based cross fader
• mindwarp~ a spectral formant warping object
• morphine~ a morphing object
• multyq~ a four band filter
• presidency~ a spectral sampler with pitch control
• pvcompand~ a spectral compressor/expander object
• pvgrain~ a spectrum analyzer for granular resynthesis
• pvharm~ a harmonizer
• pvoc~ an additive synthesis phase vocoder
• pvtuner~ a spectrum quantizer for tuning to arbitrary scales
• pvwarp~ a non-linear frequency warper
• reanimator~ an audio texture mapper
• resent~ similar to residency~ but with independent bin control
• residency~ a spectral sampler useful for time scaling
• residency_buffer~ a spectral sampler that writes to an MSP buffer
• scrape~ a noise reduction (or increase) object with frequency control
• shapee~ a frequency shaping object
• swinger~ a phase swapping object
• taint~ a cross synthesis object
• thresher~ an amplitude/frequency sensitive gating object
• vacancy~ a spectral compositing object
• xsyn~ a cross synthesis with compression object

FFTease 2.5 objects will reconfigure themselves in response to changes in FFT size or signal vector size. Therefore, they may now be used in MaxMSP poly~ objects with downsampling or upsampling. Changes in vector size remain subject to limitations imposed by the current poly~ (and Pluggo) architecture.

Caveat: these objects are CPU intensive. A few of these objects in a patch could push your computer to its limits. Be very careful with playback volume as some of the objects produce dramatically different (lower or higher) overall levels.

Flext is a C++ layer for programming externals for Pure Data (Pd) as well as for the proprietary Max/MSP. It provides an object oriented abstraction layer to writing Pd objects.

This package provides the files necessary to compile a Pd external using Flext.

The flite external contains a single Pd class which provides a high-level text-to-speech interface for English based on the 'libflite' library by Alan W Black and Kevin A. Lenzo.

Freeverb is a simple implementation of the standard Schroeder/Moorer reverb model. It uses 8 comb filters on both the left and right channels. Note that this version of Freeverb doesn't contain predelay, or any EQ. It is implemented as a Pd object, so it can easily be inserted into a Pd patch.

ggee is a library for Pure Data by Guenter Geiger with five sections: control, experimental, filters, gui, and signal.

• objects for controlling things:, constant, rl, serial_ms, sl, getdir, rtout serial_mt, stripdir, inv, serial_bird, shell, unserialize, qread, serialize, sinh, unwonk
• experimental synths:, fofsynth~, tabwrite4~, pvocfreq
• objects for controlling filters:, bandpass, highpass, hlshelf, lowshelf, notch, equalizer, highshelf, lowpass, moog~
• GUI objects:, button, fatom, image, sliderh, ticker, envgen, gcanvas, slider, state, toddle
• manipulating signals:, atan2~, mixer~, sfwrite~, streamin~, streamout~

This library provides abstractions to create interactive elements within a 3D-environment (Pd/Gem).

Currently supported visual elements include:

• lines
• circles
• polygons Interaction is mostly clicking, selecting and drag&drop.

The 'hcs' library is a random grabbag of objects that are experiments that sometimes lead to full-fledged libraries. There are objects for getting UNIX file and permissions information (group, gid2group_name, group_name2gid, uid2username, username2uid, hostname, stat, uname, setenv), Pd GUI manipulation (canvas_name, window_name, sys_gui, tcl_version, ce_path, tkconsole, pointer_position, cursor), handling filenames (file_type, folder_list, helppath, split_path), and more.

The default external objects loader of Pure Data (Pd) maps object names to filenames and C-function names. Unfortunately both filenames and C-function names have restrictions (like the impossibility to include a '/').

This library adds an escaping mechanism based on hexadecimal encoding that allows one to write and use objects that would otherwise be impossible.

[hid] is a Pure Data object for reading data from USB HID devices like keyboards, mice, joysticks, gamepads, keypads, and all sorts of other esoteric controllers like USB knobs, touchscreens, Apple IR Remotes, etc. It represents the data with a cross-platform message scheme which is then translated to the underlying native API for input devices (Linux input.h or Mac OS X HID Utilities).

Pure Data (also known as Pd) is a real-time graphical programming environment for audio and graphics processing.

This package installs all packages necessary for the "iem" flavour, a Pd-vanilla based distribution.

This library contains 3 objects, for calculating Ambisonics encoder matrices, rotation matrices and decoder matrices from 1st to 4th order in 3D, or from 1st to 12th order in 2D.

This library contains a collection of very low-level objects for Pd, that are usually used to build higher-level abstractions for dynamic patching and live coding by adding reflection capabilities to the patcher language.

This library is famous for allowing Pd-objects to move around in the patch.

iemlib is a vast (180+) collection of objects dealing with

• digital signal processing and filters.
• message handling utilities targeted at CPU-efficiency.
• abstractions to provide easy to use objects (mainly filters).
• sample-accurate message scheduling.
• mp3-playing capabilities to Pd.

This library contains about 100 objects for matrix manipulation within the dataflow language Pure Data.

The syntax is based on the matrix operators in Octave (and thus Matlab®).

This is a re-implementation of the original pd-net library by Martin Peach, focussing on reliability and performance.

This library adds Pure Data objects that allow one to build a networking infrastructure within Pd on OSI-Layer 4 (transport layer). The objects use threads to allow for non-blocking network communication within an audio-realtime environment.

• [tcpreceive], [tcpsend]: unidirectional communication over TCP/IP
• [tcpserver], [tcpclient]: bidirectional communication over TCP/IP
• [udpreceive], [udpsend]: unidirectional communication over UDP
• [udpclient]: bidirectional communication over UDP

Since these objects only send/receive lists of bytes, you will most likely need to add some glue to implement higher-level protocols (and transmit meaningful data).

This is a collection of high-performance objects to manipulate tables/arrays from within Pd.

It supports:

• setting of constant values
• copy and reverse arrays
• find minimum and maximum values
• basic binops: compare, add, subtract multiplication, division
• unops: square root, power-to-db, db-to-rms
• complex math
• FFT, inverse FFT, convolution, cross-correlation

pd-iemutils consists of a number of independent libraries

• iem_adaptfilt (adaptive filters)
• iem_roomsim (room simluation)
• iem_spec2 (optimized frequency domain processing)
• iem_tab (table manipulation)

• iem16 (16-bit tables and delay lines) and a number of GUI plugins:

• kiosk (run a patch in fullscreen without menubars)

• patch2svg (export a Pd patch as an SVG graphics)
• patcherize (helps with refactoring patches into abstractions/subpatches)
• tclprompt (adds an interactive Tcl/Tk prompt to the Pd screen)
• triggerize (insert [triggers] to avoid fan-outs)
• doublechord (duplicate connections just like objects)

jmmmp is a collection of Pure Data GUI objects for musical performance, including controlling the DAC, volume, debugging, linking up with other programs, etc.

• Granulator - Pure Data port of Robert Henke's Granulator
• appent - like [list append], but trims the 'list' selector from the result
• prepent - like [list prepend], but trims the 'list' selector from the result
• array-edit - edit properties of arrays
• bezier - Transfer function GUI with one cubic bézier curve
• bezier~ - Transfer function GUI with one cubic bézier curve (signal version)
• but - Monochrome bang button
• butt - Color-changing Toggle Button
• cellblock - numeric grid
• change-symbol - like vanilla's [change], but for symbols
• clock - Chronometer with display in seconds
• dacc~ - dynamic dac~ outlet up to 32 channels
• dacm~ - Mono dac~ for lazy people
• datei-o - Sends the message "open ../../"
• datei-r - Sends the message "read ../../"
• datei-w - Sends the message "write ../../"
• ds-color-sel - color selector for data structures
• dsp01 - DSP switch
• f+ - Counter with variable increment
• gui-edit - edit standard GUI objects fast
• jp.coll - store/edit message collections
• jp.dbtofad - a vanilla modelling of [iemlib/dbtofad]
• jp.garble - garble Pd patches
• jp.list-drip - drips (serializes) a list
• jp.menu - dropdown menu
• jp.preset - dropdown preset saver
• jp.sigtovu~ - ignal to rms converter in VU meter format
• jp.split-symb-first - split a symbol, using a character as separator
• jp.split-symb-last - split a symbol, using a character as separator
• jp.symbol-expand - split a symbol into a list with individual elements separated by spaces
• jp.urn - unrepeated random numbers
• lbang - loadbang which can be triggered more often
• liner~ - practical implementation of [line~]
• liner+~ - practical implementation of signal envelopping
• m-i - Automatic conversion of MIDI controller
• mat~ - Level meter with amplitude control
• mat-~ - Level meter with amplitude control, horizontal
• maat~ - Stereo Level meter with amplitude control
• maat-~ - Stereo Level meter with amplitude control, horizontal
• mat4~ - Level meter with amplitude control, 4 channels
• mat4-~ - Level meter with amplitude control, 4 channels, horizontal
• matrixctrl - GUI for [iemmatrix/mtx_*~]
• metrum - Metro with GUI
• met~ - Level meter with amplitude control, with VU
• mk - shows the controller number and MIDI value
• multiarray - store and operate several graphical arrays in one graphical container
• oscD - Counts received OSC messages
• oscS - Interface for sendOSC
• pd-colors - Pd color palettes (Data Structures + Tcl/Tk)
• pix2canvas - Convert Gem images into canvas
• rec-name - Automatic naming for a record/playback engine
• rgb-color - Pick RGB colors for your GUI objects
• scale - maps an input range to an output range
• sguigot - spigot GUI implementation
• shuffle - A no-repeat random number generator. shuffles a number series
• sliders - GUI for incoming midi data
• snaps~ - snapshot~ GUI implementation
• spectrogram~ - Spectrogram with 512 bins resolution
• stoppuhr - Chronometer with two layers
• swatch - Pick a color using the hue-saturation chart
• tastin - Gate for keyboard input
• uhr - Shows the time

jsusfx is an Open Source implementation of the JSFX scripting language that was created by Cockos and is made available with Reaper (a commercial multitrack editor and recorder).

This package provides the Pd support for jsusfx.

KOLLABS is an abstraction library for Pure Data, that covers data management, OSC-, MIDI- and DMX-communication and state saving.

The included state engine allows complex scene management as well as fully programmable scene transitions.

The 'libdir' loader is a Pure Data loader which supports the libdir library format. The libdir library format aims to be a common library format for Pd which works with objects written in any language, including Pd. This library format was designed to be easy to create, install, and use. It should work when installed into the global path (i.e. pd/extra) or when copied locally into a project folder. It should work with objects written in any supported language (i.e. binaries, .pd, and the various loaders like pdlua and tclpd).

list-abs is a Pd library of all sorts of operations for lists of data, ranging from mathematics, sorting, ranging, etc. All of the objects are implemented using Pd, and for the most part only using objects included in Pd-vanilla.

This library adds objects to Pure Data (Pd) that allow one to create printout at various verbosity levels.

The objects can be used as drop-in replacement for the standard [print] object, but the printed messages can be filtered and have a colourful appearance.

pd-lua adds a new loader to Pure Data (Pd), that allows one to load objectclasses written in the popular Lua programming language.

Some programming problems are complicated to express in graphical dataflow languages like Pd, requiring the user to ressort to objectclasses written in more general purpose languages. For those who do not want to use compiled languages like C/C++, this package offers the possibility to write first-class objectclasses in the lightweight programming language "Lua".

This Pd library is a potpourri of objects for working with audio created by Eric Lyon. Here is a listing of all the included objects:

• adsr~ a simple ADSR envelope that can be click triggered
• bashfest~ a click driven buffer player with randomized DSP
• buffet~ provides operations on a stored buffer
• bvplay~ selective playback from a stored buffer with enveloping and increment control
• channel~ access to a precise address in the signal vector
• chopper~ munging loop playback from a buffer
• clean_selector~ like selector~ but crossfades when switching channels
• click2float~ translates a signal click to a float message
• clickhold~ sample and hold a click
• distortion~ lookup function distortion
• dmach~ pattern based sample accurate drum machine prototype
• expflam~ converts a click to an exponential flam click pattern
• flanjah~ simple flanger
• granola~ granular pitch scaling
• granulesf~ granular synthesis module reading from a soundfile in a buffer
• granule~ granular synthesis module reading from a stored waveform in a buffer
• impulse~ converts a bang to a click
• kbuffer~ low sampling rate buffer to capture gestures
• killdc~ DC block filter
• magfreq_analysis~ transforms a time domain signal to a magnitude/frequency spectrum
• markov~ implements a first order Markov chain
• mask~ a click driven pattern sequencer
• oscil~ oscillator with flexible waveform specification
• player~ click driven buffer player that can sustain multiple iterations
• phasemod~ phase modulated waveform
• pulser~ pulse wave generated by additive synthesis
• rtrig~ generates random click triggers
• samm~ sample accurate multiple metronomes, with click signal articulation
• sigseq~ signal level numerical sequencer
• stutter~ a basic buffer stuttering player
• vdb~ a delay line using an MSP buffer for storage (no vector limit on feedback delaytime)
• vdel~ a delay line with built in feedback and oscillator
• vdp~ a more efficient pointer version of vd~
• vd~ a simple, self -contained delay unit
• waveshape~ a Chebychev function lookup waveshaper

The Mapping Library for Pd is a library of mapping primitives for mapping data to controls. Also included are techniques for conditioning sensor data to make it usable in the context of instrument design. It is something like a set of unit generators for mapping, plotting out the most basic building blocks for creating instrument mappings.

Markex is an external library of miscellaneous objects that was begun in 1994 and originally included in GEM. It is largely here for the sake of old projects that might still rely on it. The included functionality has been improved in other libraries.

maxlib is a library of non-tilde externals for Pd. The objects can be very useful to analyse any musical performance. Some of the objects are 'borrowed' from Max (they are not ported but rewritten for Pd cheap immitations). maxlib has been extended by objects of more general use and some which can be use for composition purposes. It also includes some networking objects for writing Pd patches that act as network clients and servers.

This library adds a programmatic interface to Pd (Pure Data) to query the currently available audio and MIDI backends (like alsa, jack, ...) and interfaces (like built-in soundcard, virtual devices, ...), and allows one to enable and configure them from within a Pd patch.

A library of objects for composing music written by Mark Williamson.

There are currently five objects:

• pin~ - randomly delivers the input signal to either the right or left outlet with a given probability
• metroplus - allows complex timing bangs to be delivered
• prob - generates random events with a given probability
• monorhythm - basic rhythm pattern building blocks that allows polyrhthms to be generated quickly and easily
• about - delivers a number that is "about" the same as the input number

Moonlib includes three sub-sections: nilib, which is a kind of wrapper between Pd and Gtk, sublib, which is a collection of gui control objects, and other, which are miscellaneous objects:

• tabenv: like env~, an enveloppe follower, but computing on a table, so possibly much speeder than real-time env~'s computation
• tabsort, tabsort2: returns the indices of the sorted table, tabsort2 is bidimensional
• gamme: one octave of a piano keyboard used to filter/choose notes in a selected scale
• absolutepath/relativepath: to use files (sounds, texts, presets, images, programs...) nested in the patch's directory (and in subdirs)
• sarray and slist: to creates shared dynamic arrays or lists with symbols
• sfread2~ and readsfv~: to pitch the direct-from-disk reading of sound files
• dinlet~: an inlet~ with a default value (when nothing is connected to it)
• mknob: a round knob ala iemgui vslider (with its "properties" window)
• dispatch: creates one bus name for many buttons' buses: from the N pairs (slider1-snd/slider1-rcv) ... (sliderN-snd/sliderN-rcv), creates only one pair of buses named (slider-snd/slider-rcv), in which datas are prepended by the number of the "sub-bus"
• joystik: an improvement of Joseph A. Sarlo's joystick
• image: an improvement of Guenter Geiger's one. Same name, but it's compatible. Here you can share images through different objects, preload a list of images, and animate this list.

A collection of externals from Iain Mott that mostly provide some math functions for Pure Data:

• polygate~ - switch between multiple signal inputs, variable fade rate both linear & equal power
• shuffle - a no-repeat random generator, outputs numbers within a set range
• pan~ - equal power stereo panning
• system - sends a system message to the console
• ln~ - natural log + inverse
• rec2pol~ - convert rectangular coordinates to polar eg. can be used to convert sine & cosine rfft~ output to phase & magnitude
• pol2rec~ - inverse of rec2pol~
• getenv - Sends value of an environment variable argument on bang

mrpeach is a collection of general purpose objects:

• [op~] signal comparison
• [rc~] resistor-capacitor circuit
• [rcosc~] resistor-capacitor oscillator
• [rojo~] red noise generator
• [sqosc~] bandlimited pulse generator
• [runningmean] moving average filter
• [tabfind] find a number in a table
• [f2b] float32 → bytes converter
• [b2f] bytes → float32 converter
• [life2x] game of life

• [which] output path to a Pd-object

• [midifile] play and record MIDI files

• [binfile] read/write raw data files

This library adds Pure Data (Pd) objects that allow one to build a networking infrastructure within Pd on OSI-Layer 4 (transport layer). The objects use threads to allow for non-blocking network communication within an audio realtime environment.

• [tcpreceive], [tcpsend]: unidirectional communication over TCP/IP
• [tcpserver], [tcpclient]: bidirectional communication over TCP/IP
• [udpreceive], [udpsend]: unidirectional communication over UDP
• [udpsndrcv]: bidirectional communication over UDP
• [udpsend~], [udpreceive~]: transmit uncompressed signals via UDP Since these objects only send/receive lists of bytes, you will most likely need to add some glue to implement higher-level protocols (and transmit meaningful data).

The nusmuk library contains object targeted at high-quality audio synthesis like band-limited synthesizers, audio filters and effects and interpolating table lookups. It also includes a number of general purpose utilities, ranging from simple shorthand abstractions to higher mathematics (random generators).

This library allows one to construct and parse OSC messages within Pd. It includes support for ordinary OSC-messages, typetags, timetags and bundles.

These objects are transport-agnostic, so you can use them to transmit OSC over UDP, TCP/IP, serial port, or in fact whatever you want. However, you will have to install additional libraries that will handle the transport layer (like pd-net or pd-comport).

Note however, that OSC is a packet-based protocol, so if you intend to use it with a stream-based transport (like TCP/IP or the serial line), you must use a packetizer (the OSC-specifications suggest to use SLIP, as provided by pd-slip).

A library of stereo panning algorithms from various sources, including equal power panning and linear panning. Panning objects include: equal_power_pan~, gogins_pan~, gpan~, linear_pan~, square_root_pan~, and pan_core~. pan_core~ can be used as a "core" for objects that implement other pan algorithms. All of these objects are implemented in Pd.

This library provides a collection of objects for Pd for making documentation easier and more interactive, providing standard ways of outputting audio, controlling the DSP, and making it possible to embed clickable links.

pdogg is a library of objects for Pd for reading and writing Ogg/Vorbis streams and files. There is a stream player for multichannel audio streams and a streaming source client to send Ogg/Vorbis encoded audio streams over LAN or internet using JRoar, Icecast2 or PeerCast. There are also objects for reading and writing Ogg/Vorbis files.

PDP is an extension library for Pd that allows you to manipulate movies and live video data in realtime. PDP stands for Pd Packet, the data container that is used for images in PDP.

This is a collection of Pure Data external classes to ease the handling with strings by providing a way to convert Pd messages to lists of floats and vice versa. Support for wide character strings is provided together with the locale external.

This package includes a Pd object that allows you to control the Arduino board from Pd without having to program in Arduino's C++.

WARNING! This version of the [arduino] object for Pd will only work with 2.1 versions of Firmata or newer! It will NOT work with older versions of the firmware! You need to get recent version of Firmata (to run on the arduino board) from https://firmata.org (resp. https://github.com/firmata/arduino)

This is a Pd tilde object for hosting LADSPA audio plug-ins. The LADSPA plug-in interface is supported completely. The object will search your LADSPA path for plugins, which are loadable by name as an argument to the plugin~ object.

A library for Pd for modeling the interactions of the physical world. These objects provide real-time simulations, specially physical behaviors. pmpd can be used to create natural dynamic systems, like a bouncing ball, string movement, Brownian movement, chaos, fluid dynamics, sand, gravitation, and more. It can also be used to create displacements thus allowing a completely dynamic approach of pd computing.

[pool] can store and retrieve key/value pairs, where a key can be any atom and the value can be any list of atoms. [pool] can manage folders, a folder name can be any atom. [pool] objects can be named and then share their data space. Clipboard operations are possible in a pool or among several pools. File operations can load/save data from disk.

This collection of abstractions for Pure Data (Pd)are made to facilitate the use of sensors and to create complex relations between input and output of a dynamic system.

Puremapping is based on the (discontinued) 'la-kitchen' library, and the 'mapping' library (shipped in Debian as 'pd-mapping'). Most object of puremapping should be compatible with the 'mapping' library.

This is a library focused on re-implementing existing objects written in C using only objects that are included in puredata. The idea is to provide drop-in replacements for the binary objects usable on any platform that are also understandable to any Pd programmer.

PuREST JSON is a library for Pure Data (Pd) for decoding and encoding JSON data. The library can issue HTTP statements, so consumation of RESTful services is possible, e.g. CouchDB.

This object library provides full integration of the Python scripting language into the Pure Data (Pd) real-time system.

• [py] loads Python modules and allows one to execute functions therein.
• [pyext] uses Python classes to represent full-featured message objects.

Multithreading (‘detaching’) is supported for background operation.

This Pure Data object supports reading from disk as well as from web- resources and decodes a huge variety of audio codecs. Sources with multiple channels and sampling rates different from Pd's can be played back as well.

Check the help-patch for more usage information.

This software library offers the possibility to experiment with a number of compositional techniques, such as serial procedures, permutations and controlled randomness.

Most of these objects are geared towards straightforward processing of data. By using these specialized objects together in a patch, programming becomes much more clear and easy.

Many functions that are often useful in algorithmic composition are provided with this library - therefore the composer could concentrate rather on the composition than the programming aspects.

PDP is an extension library for Pd that allows you to manipulate movies and live video data in realtime. PDP stands for Pd Packet, the data container that is used for images in PDP.

This is a PDP extension lib that contains modules for cellular automata built on a (very) minimal forth-like virtual system (scaf - simple cellular automaton forth) to define update rules. A compiler is included to produce 'scafo' object code that can be dynamically loaded into the [pdp_ca] module. So it is possible to add/change rules without restarting Pd.

A collection of objects for Pd from weiss-archiv that mostly provide some signal processing functions like limiting, distortion, etc. They are called chop~, decimate~, diode~, foldback~, foldover~, freqdiv~, freqshift~, harmgen~, rectify~, round~, saturate~, sieve~, split~, ustep~, and vowel~.

This library implements the Serial Line Internet Protocol (SLIP), a simple protocol for encapsulating packets within a streaming transport protocol such as TCP/IP or on the serial port.

You will need this if you plan to transmit e.g. OSC messages via TCP/IP or the serial line.

Signal processing for Mapping - a LIBrary with vector and number stream processing objects for Pd, enhancing this language with objects for rapid prototyping of gesture analysis. It complements Pd with a set of objects for vector processing, vector analysis, vector synthesis, number stream analysis, number stream filters.

[syslog] takes care of sending arbitrary messages from Pure Data to syslog, tagged with a syslog level you feel appropriate. As such, [syslog] is a replacement for the normal [print] object.

This library allows one to write externals for Pd using the Tcl language. It wraps the Pd API quite closely, and provides a small library of helper functions to be used for writing externals.

Using Tcl for writing objects in Pd has the advantage, the Tcl/Tk is already used as Pd's GUI toolkit, so no additional dependencies are required.

testtools is a collection of objects that help the developer with creating unit tests for Pure Data patches, both in the message domain and in the signal domain.

unauthorized is a Pure Data library of GUI objects and a handful of objects for working with streaming and MP3s.

• audience~: a 2-dimensional audience simulation
• beatify~: modulates amplitude of a sound
• blinkenlight: a blinken lights films player (but also a pixel grid)
• compressor~: a compressor of audio signals
• cooled: a micro sound editor
• disto~: a kind of effect used in pop music, use it elsewhere
• exciter: a bang-events sequencer
• filterbank~: outputs frequency response for a range of filters
• formant~: a formant synthesis generator external for Pd
• grid: a 2-dimensional control object, ala "kaospad"
• mp3amp~: an MPEG-1 Layer III (MP3) Icecast/SHOUTcast client
• mp3cast~: an MPEG-1 Layer III (MP3) streaming external
• mp3streamout~: peer-to-peer MP3 streaming out
• mp3fileout~: peer-to-peer MP3 streaming to a file
• mp3streamin~: peer-to-peer MP3 stream receiving
• mp3write~: an MPEG-1 Layer III (MP3) file writer
• pianoroll: a graphical sequencer controller
• playlist: choose a file in 1 click with space, numeric, characters
• probalizer: outputs integer values according to a drawn probability curve
• samplebox~: an opaque box to record and playback a sound
• scratcher~: records a sound and lets you scratch it with your mouse
• scrolllist: displays and scrolls a text in a patch window
• sonogram~: displays, plays back and lets you modify a recorded sonogram
• speexin~: a voice quality stream receiver using Speex library
• speexout~: a voice quality streamer using Speex library
• spigot~: a signal router
• wahwah~: a kind of effect used in psychedelic music, use it elsewhere

The Universal Polyphonic Player (short UPP) is an infrastructure for all kinds of polyphonic events – be it note-like events, other generated sounds or short grains in granular synthesis. The strengths of the system are a modular, easily extendible design, almost unlimited polyphony, ease of control, DSP load scaling and sample-accurate timing.

This a library for Pure Data that provides objects for realtime Vector Base Amplitude Panning. Vector Base Amplitude Panning (VBAP) is a method for positioning virtual sources to arbitrary directions using a setup of multiple loudspeakers. In VBAP the number of loudspeakers can be arbitrary, and they can be positioned in an arbitrary 2-D or 3-D setups. VBAP produces virtual sources that are as sharp as is possible with current loudspeaker configuration and amplitude panning methods, since it uses at one time the minimum number of loudspeakers needed, one, two, or three.

With 2-D setups VBAP is a reformulation of the existing pair-wise panning method. Different from other panning algorithms, VBAP can be generalized for 3-D loudspeaker setups as a triplet-wise panning method. A sound signal is then applied to one, two, or three loudspeakers simultaneously. VBAP has certain advantages compared to earlier virtual source positioning methods in arbitrary layouts. Previous methods either used all loudspeakers to produce virtual sources, which results in some artefacts, or they used loudspeaker triplets with a non-generalizable 2-D user interface.

The directional qualities of virtual sources generated with VBAP can be stated as follows. Directional coordinates used for this purpose are the angle between a position vector and the median plane (θcc), and the angle between a projection of a position vector to the median plane and frontal direction (Φcc). The perceived θcc direction of a virtual source coincides well with the VBAP panning direction when a loudspeaker set is near the median plane. When the loudspeaker set is moved towards a side of a listener, the perceived θcc direction is biased towards the median plane. The perceived Φcc direction of an amplitude-panned virtual source is individual and cannot be predicted with any panning law.

This Pure Data object adds access to the sensor data from Nintendo's wiimote controller. Also it provides an interface to control the controller's actuators such as LED 1-4 and the rumble vibrator. Furthermore, it supports some of the extensions of the wiimote, such as Nunchuk, Motion Plus, Classic Control.

Check the help-patch for more usage information.