Article Published in IEEE Multimedia

Now available online: Joseph Malloch, Stephen Sinclair, and Marcelo M. Wanderley. “Generalized Multi-Instance Control Mapping for Interactive Media Systems”. In IEEE MultiMedia, 25(1), January–March 2018. DOI: 10.1109/MMUL.2018.112140028

We articulate a need for the representation of temporal objects reflecting dynamic, short-lived mapping connections instantiated from a template, in tools for designing and using interactive media systems. A list of requirements is compiled from an examination of existing tools, practical use cases, and abstract considerations of node connectivity and information propagation within a graph of connected devices. We validate the concept through implementation in the open source software libmapper, and explore its application by integration with existing controller/synthesizer software and hardware.

Digital Orchestra Toolbox featured on Cycling74.com

Content You Need: Digital Orchestra Toolboxdot_icon

We tend to focus a lot on new Max objects in the Package Manager, but with Max there are many ways to solve problems without compiling externals. This Package Manager release brings a collection of highly practical Max abstractions from McGill University’s IDMIL, designed with music and digital orchestra projects in mind. Looking at this package, all of the well-organized abstractions are clearly the result of real-world patching that we can all learn a few tricks from.

The Digital Orchestra Toolbox is now available in the Max Package Manager

Article published in MTAP

Now available online: Malloch, J., Sinclair, S., M. M. Wanderley. Distributed tools for interactive design of heterogeneous signal networks. Multimedia Tools and Applications, 73(2),  2014. DOI: 10.1007/s11042-014-1878-5

We introduce libmapper, an open source, cross-platform software library for flexibly connecting disparate interactive media control systems at run-time. This library implements a minimal, openly-documented protocol meant to replace and improve on existing schemes for connecting digital musical instruments and other interactive systems, bringing clarified, strong semantics to system messaging and description. We use automated discovery and message translation instead of imposed system-representation standards to approach “plug-and-play” usability without sacrificing design flexibility. System modularity is encouraged, and data are transported between peers without centralized servers.

CMJ special issue on Mapping

Call for Submissions – CMJ Special Issue: “Advances in the Design of Mapping for Computer Music”, Marcelo M. Wanderley and Joseph Malloch, Guest Editors.

When we use digital tools for making music, the properties and parameters of both sound synthesizers and human interfaces have an abstract representation. One consequence of the digital nature of these signals and states is that gesture and action are completely separable from sound production, and must be artificially associated by the system designer in a process commonly called mapping.

The importance of mapping in digital musical instruments has been studied since the early 1990s, with several works discussing the role of mapping and many related concepts. Since roughly the mid-2000s, several tools have been proposed to facilitate the implementation of mappings, drastically reducing the necessary technical knowledge and allowing a large community to easily implement their ideas. Coupled with the availability of inexpensive sensors and hardware, as well as the emergence of a strong Do-It-Yourself community, the time seems right to discuss the main directions for research on mapping in digital musical instruments and interactive systems.

This call for submissions for a special issue of the Computer Music Journal focuses on recent developments and future prospects of mapping.

Relevant topics include, but are not limited to:

  • Mapping in instrument/installation/interaction design
  • Mapping concepts and approaches
  • Mapping tools
  • Evaluation methodologies
  • Mapping in/as composition
  • Mapping for media other than, or in addition to, sound

Deadline for paper submission is March 15, 2013. The issue will appear in 2014. Submissions should follow all CMJ author guidelines (http://www.mitpressjournals.org/page/sub/comj). Submissions and queries should be addressed to marcelo.wanderley@mcgill.ca, with the subject starting with [CMJ Mapping]

pyo and libmapper

This morning I attended a very interesting presentation on the pyo DSP module for python. From their website:

pyo is a Python module written in C to help digital signal processing script creation.

pyo is a Python module containing classes for a wide variety of audio signal processing types. With pyo, user will be able to include signal processing chains directly in Python scripts or projects, and to manipulate them in real time through the interpreter. Tools in pyo module offer primitives, like mathematical operations on audio signal, basic signal processing (filters, delays, synthesis generators, etc.), but also complex algorithms to create sound granulation and others creative audio manipulations. pyo supports OSC protocol (Open Sound Control), to ease communications between softwares, and MIDI protocol, for generating sound events and controlling process parameters. pyo allows creation of sophisticated signal processing chains with all the benefits of a mature, and wildly used, general programming language.

Here’s an incredibly simple example – it creates and plays a single sine at 200Hz:

from pyo import *

s = Server().boot()
s.start()
a = Sine(freq=200, mul=0.5).out()

Since we already have Python bindings for libmapper, with a few lines of code we can make this example “mappable” and interactive.

from pyo import *
import mapper

s = Server().boot()
s.start()
a = Sine(freq=200, mul=0.5).out()

try:
    dev = mapper.device('pyo_example')
    dev.add_input_signal('/freq', 1, 'f', 'Hz', 200, 500,
                         lambda s, i, v, t: a.setFreq(v))
    dev.add_input_signal('/mul', 1, 'f', 'na', 0, 1,
                         lambda s, i, v, t: a.setMul(v))

    while 1:
        dev.poll(5)

finally:
    s.stop()
    s.shutdown()

*Note: The above code snippet has been updated for compatibility with libmapper v1.0 and greater.