OSC

From Things and Stuff Wiki
Jump to navigation Jump to search


General

  • OSC - a data transport specification (an encoding) for realtime message communication among applications and hardware. OSC was developed by researchers Matt Wright and Adrian Freed during their time at the Center for New Music & Audio Technologies (CNMAT). OSC was originally designed as a highly accurate, low latency, lightweight, and flexible method of communication for use in realtime musical performance. They proposed OSC in 1997 as “a new protocol for communication among computers, sound synthesizers, and other multimedia devices that is optimized for modern networking technology”. OSC can be understood as a more flexible alternative MIDI; OSC clears away many of the ideological and hardware constraints inherent to MIDI in favor of a open-ended, user-defined address-space model that provides arbitrary parametric control via standard networking hardware. The OSC Specification 1.0 was formalized and published in 2002. The 2009 Specification 1.1 update added support for new features and data types. Over the years OSC has been useful in a wide variety of domains beyond musical contexts. Its timing accuracy and flexibility make it a ready solution for any application that requires time-sensitive communication between software and/or hardware endpoints.




  • http://en.wikipedia.org/wiki/Open_Sound_Control - a content format developed at CNMAT by Adrian Freed and Matt Wright comparable to XML, WDDX, or JSON. It was originally intended for sharing music performance data (gestures, parameters and note sequences) between musical instruments (especially electronic musical instruments such as synthesizers), computers, and other multimedia devices. OSC is often used as an alternative to the 1983 MIDI standard, where higher resolution and a richer musical parameter space is desired. OSC messages are commonly transported across the internet and within home and studio subnets using (UDP/IP, Ethernet). OSC messages between gestural controllers are usually transmitted over serial endpoints of USB by being wrapped in the SLIP protocol.



  • PDF: Open SoundControl: A New Protocol for Communicating with Sound Synthesizers - Abstract: Open SoundControl is a new protocol for communication among computers, sound synthesizers, and other multimedia devices that is optimized for modern networking technology. Entities within a system are addressed individually by an open-ended URL-style symbolic naming scheme that includes a powerful pattern matching language to specify multiple recipients of a single message. We provide high resolution time tags and a mechanism for specifying groups of messages whose effects are to occur simultaneously. There is also a mechanism for dynamically querying an Open SoundControl system to find out its capabilities and documentation of its features.
  • PDF: Best Practices for Open Sound Control - Abstract: The structure of the Open Sound Control (OSC) content format is introduced with historical context. The needs for temporal synchronization and dynamic range of audio control data are described in terms of accuracy, precision, bit-depth, bit-rate, and sampling frequency. Specific details are given for the case of instrumental gesture control, spa tial audio control and synthesis algorithm control. The consideration of various transport mechanisms used with OSC is discussed for datagram, serial and isochronous modes. A summary of design approaches for describing audio control data is shown, and the case is argued that multi-layered information-rich representations that support multiple strategies for describing semantic structure are necessary.
  • PDF: Control of VST Plugins using OSC - Abstract: The basic control structure of VST audio plug-ins can limit their usefulness. Control can be improved through the use of Open Sound Control by developing a flexible name space that employs multiple, intuitive parameter names (and aliases), higher-level controls and range mapping, simplifying control for the user. We will demonstrate these ideas with Max/MSP patches that repackage VST plug-ins in a more usable way and also introduce the idea that plug-in interfaces themselves can be improved by building in a well-formed OSC name space. Such a name space would enhance the longevity and flexibility of finished musical works. We will also show that when the plug-in is controlled directly with OSC atomicity and queries, control could be further improved.


  • Csound Journal: Synchronizing a Networked Csound Laptop Ensemble using OSC - In this article, I will describe a method of synchronizing multiple networked computers for interactive musical performance using Csound and Open Sound Control (OSC). I chose to adopt a client/server approach based on the "forward-synchronous" system developed by Roger Dannenberg. The basic idea of this system is that the server maintains a master (global) clock, while the clients keep their local clocks synchronized with the global clock by querying the server at regular intervals. Since all the computers agree on the global time, as well as the current beat, tempo, and meter, they can schedule events to occur at precise moments in the future, even if there are network latencies. Dannenberg's system allows for changes in tempo, but not in meter, so I added that capability. I also created a graphical user interface for the system in CsoundQT and constructed a small set of custom OSC messages for communications between machines.

Programming

liblo

  • liblo - an implementation of the Open Sound Control protocol for POSIX systems, started by Steve Harris and now maintained by Stephen Sinclair. It is released under the GNU Lesser General Public Licence version 2.1 or greater. This means that if it is included in closed-source systems, it must be dynamically linked such that the LibLO code remains freely modifiable.

Oscpack

  • Oscpack - a set of C++ classes for packing and unpacking OSC packets. Oscpack includes a minimal set of UDP networking classes for Windows and POSIX. The networking classes are sufficient for writing many OSC applications and servers, but you are encouraged to use another networking framework if it better suits your needs. Oscpack is not an OSC application framework. It doesn’t include infrastructure for constructing or routing OSC namespaces, just classes for easily constructing, sending, receiving and parsing OSC packets. The library should also be easy to use for other transport methods (e.g. serial).
  • OSC Support - Faust Documentation - Most Faust architectures provide Open Sound Control (OSC) support (the implementation is based internally on the oscpack library by Ross Bencina). This allows applications to be remotely controlled from any OSC-capable application, programming language, or hardware device.

RtOSC

libosc

pyOSC

  • https://trac.v2.nl/wiki/pyOSC - A Simple ​OpenSoundControl implementation, in Pure Python. This module is loosely based on the good old ​SimpleOSC implementation by Daniel Holth & Clinton McChesney. It has been mostly rewritten, and a whole set of new Classes has been added, providing support for OSC-bundles, a simple OSC-client, a simple OSC-server, threading & forking OSC-servers and a more complex 'Multiple-Unicast' OSC-client that supports subscriptions and OSC-address based message-filtering.

python-osc

OscPkt

osc-ruby

JavaOSC

tinyosc

liblo

oscpy

tcposcrouter

osc.js

osc-js

  • osc-js - an Open Sound Control library for JavaScript applications (UMD module for Node, Browser etc.) with address pattern matching and timetag handling. Sends messages via UDP, WebSocket or both (bridge mode) and offers a customizable Plugin API for network protocols.

async-osc

OSCKit

  • https://github.com/sammysmallman/OSCKit - provides the Swift classes needed for your apps to communicate among computers, sound synthesizers, and other multimedia devices via OSC over an IP network.

PyLive / AbletonOSC

  • https://pypi.org/project/pylive - a framework for querying and controlling Ableton Live from a standalone Python script, mediated via Open Sound Control. It is effectively an interface to the Live Control Surfaces paradigm, which means it can do anything that a hardware control surface can do, including: query and modify global parameters such as tempo, volume, pan, quantize, arrangement time; query and modify properties of tracks, clips, scenes and devices; trigger and stop clips and scenes. It can perform most of the operations described in the LiveOSC OSC API.
  • https://github.com/ideoforms/AbletonOSC - a MIDI remote script that provides an Open Sound Control (OSC, interface to control Ableton Live 11. Building on ideas from the older LiveOSC scripts, its aim is to expose the entire Live Object Model API (full API docs), providing comprehensive control over Live's control interfaces using the same naming structure and object hierarchy as LOM. AbletonOSC is currently (2023-01-07) a work-in-progress, and APIs may be subject to change. Many major APIs are now exposed.

VVOSC framework

  • VVOSC framework - an Objective-C framework for quickly and easily working with OSC data. Capable of doing everything necessary to send and receive OSC data. There are also targets for compiling, assembling, and installing an SDK which allows you to link against and use VVOSC on iPhones.

Utils

OscMonitor

sendOSC

  • sendOSC - a text-based OpenSoundControl client. User can enter messages via command line arguments or standard input; sendOSC formats these messages according to the "OpenSoundControl" protocol, then sends the OpenSoundControl packet to an OpenSoundControl server via UDP or Unix protocol. The "sendOSC" program is available as source code and as compiled binaries for Mac OS X. It has been tested under Linux, Mac OS X, and SGI IRIX.

oscprompt

  • https://github.com/fundamental/oscprompt - A generic OSC based prompt for inspecting and manipulating clients. Prompt accepts: - TAB - disconnect - quit - exit - connect 'port number' - general OSC messages sent to the client. It assumes that the client will respond to /path-search:ss for tab completion and field information. This is currently Beta software and as such expect some interesting behavior from time to time.

osc-repl

  • https://github.com/Neurogami/osc-repl - A REPL for sending OSC messages to some configured server.This is a command-line app. When you start it you can optionally provide the path to a config file, as well some OSC messages to pre-populate the Readline history of the REPL.

sendosc

oscchief

  • oscchief - a command line tool for sending and receiving OSC packets. Received packets will be dump to stdout for further inspections.oscchief is written in C and depends only on liblo. It runs on Mac OS X and Linux.

oscc

  • https://github.com/7890/oscc - a Java program that allows to "play around" with OSC (UDP). It can be useful to manually interact with another OSC program. Using mappings and JavaScript methods, oscc supports to quickly develop and test inter-process communication models, OSC APIs and prototypes. oscc should be run only in trustful private subnets, since it can be configured to run native commands.

osccli

  • https://github.com/madskjeldgaard/osccli - a simple and fast tool for sending OSC messages from the command line. It is written in Rust and among other things it lets you send custom messages and choose a type for them, the program will then try and parse the message you have passed to it as the type you have defined.

sendkeys

oscfile

udp repeater / dumper

  • udp repeater / dumper - dump UDP data from a port to stdout, forward/relay UDP data to one or more UDP ports.

oscbridge

XOSC

  • XOSC - an OSC-controllable router for OSC messages. Connect different OSC capable programs, considering the situation where you have two programs talking via OSC, but then want to have a third or fourth application to also use OSC from those same applications without having to rewrite code.

oscgroups

  • http://www.rossbencina.com/code/oscgroups - a system for routing OSC messages between a group of collaborating users. It is designed to make joining and leaving a group simple, and to overcome the problem of connecting multiple users behind different NAT routers using a NAT traversal server with the usual “NAT hole punching” scheme (you can put that into google for more info). OSCgroups also implements basic group functionality similar to the concept of channels in internet relay chat.

oscmux

  • https://github.com/OpenMusicKontrollers/oscmux - redirects Open Sound Control messages coming from an arbitrary number of local ports to an arbitrary number of host ports with arbitrary delays and filtering according to path and format strings.

scosc

aclock

flosc

  • https://github.com/benchun/flosc - standalone application written in Java that sends and receives OSC packets via UDP, translates bidirectionally between binary OSC packets and an XML encoding of OSC packets, and sends and receives XML entities via TCP in a way that’s compatible with Flash’s XMLSocket feature.

legato

  • https://github.com/OSCModulator/legato - a small node.js library written in coffeescript, but that doesn't really matter. legato is designed to let you create beautifully simple connections between devices and software, regardless of environment. There is built-in support for OSC, MIDI, and some other stuff. It's easily extensible. To use it, just write a (really, small program that maps inputs to outputs.

Duration

  • https://github.com/YCAMInterlab/Duration - controls change over time. With a simple one window approach, the cross platform stand alone application manages lists of tracks to compose changing data over a fixed duration. The application sends values over OSC and can be configured through OSC messages.

libmapper

OSCMorph

osc-simulator

json2osc

extOSC

brOSColi

  • https://github.com/holoplot/broscoli - a simple executor of local commands, triggered by OSC messages. It can be used to run local scripts or other executables when a configured OSC messages is received.

BPM-to-OSC

Headitude

FaceOSC

  • https://github.com/kylemcdonald/ofxFaceTracker/releases - track a face and send its pose and gesture data over OSC, as well as the raw tracked points (when selected in the GUI). A previous version of FaceOSC for MacOS supported streaming of Syphon video, but this feature has been removed. FaceOSC is developed with openFrameworks and ofxFaceTracker, built on top of Jason Saragih's FaceTracker. The windows build of FaceOSC was prepared by Dan Moore on the CreativeInquiry fork of ofxFaceTracker.

PoseOSC

Plugins

OomphSC

osccontrol-light

Controls are tied to OSC messages directly in the host environment without encoding the control data as MIDI CC messages. This way, control automation can be sent and received via OSC at full resolution, and all time sequencing, automation recording, modulation and side-chaining functionality of the host environment can be used for external OSC control. We provide an interactive GUI version, as a plugin as well as a standalone application, that enables prototyping of control presets by quick switching and reloading of preset definitions. To integrate a preset into a host environment with automatable controls, the non-GUI version of the plugin can be pre-built to load a specific preset definition at runtime.

osc.lv2

Not a plugin, a specification (contained in an LV2 bundle like an LV2 plugin is).

eteroj.lv2

  • https://git.open-music-kontrollers.ch/~hp/eteroj.lv2 - This LV2 plugin bundle allows you to handle OSC (Open Sound Control, bundles and messages in modular hosts. Insert/dispatch OSC from/to UDP, TCP (IPv4/6) and serial sockets; Pack/unpack MIDI into OSC; Pack/unpack OSC into MIDI

Not a plugin, a specification (contained in an LV2 bundle like an LV2 plugin is).

Android

OSCDisplay

Control surfaces

Open Stage Control

OSCAR

  • https://github.com/trafalmejo/OSCAR - a tool to create beautiful graphic user interaces (GUIs) to send OSC messages and control interactive installations (Resolume arena, Touch Designer, Ableton, Processing, PD, UNITY, Unreal, etc). Let's create beautiful, responsive and touchable interfaces.

kvGhislame

  • https://github.com/AMMD/kvGhislame - OSC Touchscreen controller (multitouch) based on Kivy libs (Open source Python library for rapid development of applications that make use of innovative user interfaces, such as multi-touch apps.)

oscpad

Control

AndrOSC

Mrmr

  • http://ecumedesjours.com/Mrmr/ - an ongoing open-source research project to develop a standardized set of protocols and syntax conventions to control live installations and multimedia performances via mobile devices. The project is currently spearheaded by Eric Redlinger, researcher-in-residence at Brooklyn Polytechnic University’s Integrated Digital Media Institute. macOS.

OSControl

  • OSControl - a general purpose OSC sending/receiving user interface toolkit. Different types of Controls like Knob, Fader, Button and more can be used and configured for custom needs. Windows.

Mouse to OSC

  • Mouse to OSC - A simple mouse-based control panel for controlling Open Sound Control interfaces. Can convert MIDI CCs to OSC messages now. Also written using JUCE.

OSC and MIDI Foot Controller

  • OSC and MIDI Foot Controller - a foot controller implemented by using only a webcam and the image processing resources provided by OpenCV library. The basic idea is to track an specific object (with a defined colour) and to implement a virtual foot controller, so when the tracked object goes from an idle zone to a button area, that is like a real button were pressed. The command banks and expression option are still implemented, like on previous designs. In this video appears an example of usage.

sisyfos-audio-controller

https://github.com/olzzon/sisyfos-audio-controller - Audiomixer control build for intelligent automation.

TWO

  • TWO - enables the interactive combination of digital media control signals (currently OSC & MIDI) from several simultaneous sources – be it live signals, recorded and key-framed sequences, or your own live changes using on-screen controls. Crucially, TWO is a user-friendly GUI Application, not a programming environment.


TouchOSC




  • https://github.com/NicoG60/TouchMCU - a python project generating a TouchOSC layout that is Mackie Control Compatible, meaning you can connect it to your DAW using TouchOSC Bridge as a MIDI device and make full use of Mackie Control features from your iPad.

griptools.io

  • griptools.io - visual design software for motion-graphics and mechatronics projects. It's all about connecting and controlling: virtual-3D to physical and vice versa, even physical to physical.griptools.io has build-in support for game HID devices, MIDI, OSC, motors, external controllers, lighting, mobile devices plus 2-way support for the 3D-graphics application CINEMA 4D. - Windows/Mac - $

Vezér

  • Vezér - timeline based MIDI/OSC/DMX sequencer software for audiovisual artist - $

Sequencing

See also Sequencer

seqzero

fiddle

minimal

KuStudio

Chataigne

  • Chataigne - tool for artists, technicians and developers who wish to use technology and synchronize softwares for shows, interactive installations or prototyping. It aims to be as simple as possible for basic interactions, but can be easily extended to create complex interactions. While Chataigne won't do much by itself, its purpose is to be the central hub in a project involving multiple interfaces, softwares, devices and sensors. You can see it as a Conductor, which will control all the softwares with the big picture in mind. Chataigne as been designed to fit both linear shows and realtime/interactive project needs.

TimeLine OSC Sequencer

  • TimeLine OSC Sequencer - individual OSC events are programmed onto timelines, the OSC messages are used to control any OSC enabled software. Java.

Duration

  • https://github.com/YCAMInterlab/Duration - Duration controls change over time. With a simple one window approach, the cross platform stand alone application manages lists of tracks to compose changing data over a fixed duration. The application sends values over OSC and can be configured through OSC messages.

MIDI

jack_osc

  • https://github.com/ventosus/jack_osc - Routing Open Sound Control messages via vanilla JACK MIDI to build low-latency event translator/filter chains and map unconventional controller data to musical events

MidiOSC

OSC2MIDI

osc2midi-utils

  • https://bitbucket.org/agraef/osc2midi-utils - contains two utilities to be used with osc2midi and/or TouchOSC: to2omm is a little helper script which extracts the MIDI assignments from a TouchOSC layout (.touchosc) file and converts them to a corresponding osc2midi map (.omm); gosc2midi is a GTK2-based GUI frontend for osc2midi. It lets you load both plain midi2osc map files or TouchOSC layouts (the latter are converted to the former on the fly, using the to2omm program).

midi2osc

jackmidi2osc

oscmidi

osmid

ommo

bot

MidiGyver

Eteroj

  • Eteroj - Open Sound Control for LV2. (De)Cloak - Embed OSC in MIDI Sysex messages. Control - translate OSC messages directly to LV2 Control ports and features automatic range detection. Disk Record/Playback of OSC to/from disk. IO A plugin able to inject/eject OSC packets into/from the plugin graph to/from network and serial lines. Ninja Embed Turtle RDF in OSC as string. (Un)Pack Embed arbitrary 1-3 byte MIDI commands (but Sysex) in OSC messages.

illucia

  • illucia - a patchbay controller by chris novello. It lets you use physical cables to connect things like videogames, music software, text editors, synthesizers, and more. It has a free suite of interconnectable games and software, plus it speaks OSC so it works with many existing programs.

pilink

  • https://github.com/asb2m10/pilink - a simple python script that enable to route OSC messages to midi. It has been designed to be run headless on a Raspberry Pi to avoid to setup a computer between a device that sends OSC messages (like a iPad running TouchOSC) and a midi instrument.

midi-mapper

jackmidiosc

  • https://github.com/piegamesde/jackmidiosc - Midi to OSC bridge using JACK audio. It can be used to tunnel MIDI connections over the internet.In send mode, it will wrap all MIDI events into OSC events. In receive mode, it will do the opposite.

osc2midi

midiosch

midi-osc

oscii-bot

Birdhouse

Querying

OSCQuery

  • Introducing OSCQuery Protocol — VDMX - an agreed upon specification that extends the base functionality of OSC to make it easier to construct impromptu or improvisational interfaces between different systems. For those who are already familiar with OSC, the idea is very exciting: using OSCQuery, you can ask a piece of software for a description of its Address Space along with other useful information about the method such as its expected range and datatype. This makes it possible for applications such as VDMX to both automatically generate interface controls for remote systems and publish its own local controls so that they can be accessed by other software in the same way.








minuit

Hardware

  • https://os.mbed.com/users/tobyspark/code/OSC - An Open Sound Control library for the mbed, created to be compatible with Recotana's OSCClass library (http://recotana.com, for the Arduino with Ethernet shield. It also uses parts of the OSC Transceiver(Sender/Receiver) code by xshige written by: Alvaro Cassinelli, October 2011 tweaked by: Toby Harris / *spark audio-visual, March




Web


Audio


  • https://github.com/essej/aoo -"Audio over OSC" aka AoO is aimed to be a message based audio system inspired by Open Sound Control OSC as a syntax format. It is dedicated to send audio in real time from arbitrary sources to arbitrary sinks on demand.


Commercial

  • The Ardour Manual - Controlling Ardour with OSC - lets synthesizers and other devices communicate with Ardour. OSC devices can send commands relating to playback (such as play or stop), performance (such as volume, play, stop), and almost any other function (such as Edit, or Undo). Ardour is probably one of the most OSC-controllable audio applications around, but as with all OSC-controllable apps, you can't do much without knowing what messages can be sent. This document describes the various categories of messages that Ardour understands. It is subject to change, particularly the "Actions" part below, since this relates to the GTK GUI for Ardour rather than the backend.



  • OSC Plugin Overview | Unreal Engine 4.27 Documentation - an open protocol commonly used in many areas of the audio industry. It is primarily used to network generic audio data between clients, although it can also be used for non-audio data. The OSC plugin provides an intuitive, type-safe Blueprint library that a developer can use to quickly iterate networked audio (and potentially other domain) data in Unreal Engine. When this plugin is enabled, you can send and receive OSC events through a simple API in either C++ or Blueprint. It supports sending and receiving messages and bundles, or combinations of bundles and messages.


Other

  • O2 - a new communication protocol and implementation for music systems that aims to replace Open Sound Control (OSC). Many computer musicians routinely deal with problems of interconnection in local area networks, unreliable message delivery, and clock synchronization. O2 solves these problems, offering named services, automatic network address discovery, clock synchronization, and a reliable message delivery option, as well as interoperability with existing OSC libraries and applications. Aside from these new features, O2 owes much of its design to OSC and is mostly compatible with and similar to OSC. O2 addresses the problems of inter-process communication with a minimum of complexity.



Retrieved from "https://wiki.thingsandstuff.org/index.php?title=OSC&oldid=64260"