module Arts

Interfaces

• interface InterfaceRepo
• interface InterfaceRepoV2
• interface FlowSystemSender
• interface FlowSystemReceiver
• interface FlowSystem
• interface GlobalComm
• interface TmpGlobalComm
• interface TraderOffer
• interface TraderQuery
• interface Object
• interface Loader
• interface SynthModule
• interface Synth_PLAY
• interface Synth_RECORD
• interface Synth_FREQUENCY
• interface Synth_WAVE_SIN
• interface Synth_MULTI_ADD
• interface Synth_ADD
• interface Synth_MUL
• interface Synth_PLAY_WAV
• interface Synth_BUS_UPLINK
• interface Synth_BUS_DOWNLINK
• interface ByteStreamToAudio
• interface StereoEffect
• interface StereoVolumeControl
• interface StereoFFTScope
• interface StereoEffectStack
• interface AudioManagerClient
• interface AudioManager
• interface Synth_AMAN_PLAY
• interface Synth_AMAN_RECORD
• interface SampleStorageEntry
• interface SampleStorage
• interface ByteSoundProducer
• interface SimpleSoundServer
• interface SoundServer
• interface SoundServerV2
• interface WavPlayObject
• interface PlayObject_private
• interface PlayObject
• interface PlayObjectFactory
• interface InputStream
• interface FileInputStream
• interface StdoutWriter
• interface StreamPlayObject
• interface PlayObjectFactoryV2
• interface PortDesc
• interface ModuleDesc
• interface StructureDesc
• interface StructurePortDesc
• interface ObjectFactory
• interface LocalFactory
• interface StructureBuilder
• interface ArtsBuilderLoader
• interface Structure
• interface MidiPort
• interface MidiClient
• interface MidiManager
• interface MidiTest
• interface RawMidiPort
• interface MidiTimer
• interface SystemMidiTimer
• interface AudioMidiTimer
• interface Widget
• interface Button
• interface Poti
• interface LineEdit
• interface GuiFactory
• interface GenericGuiFactory
• interface ObjectCache
• interface MidiReleaseHelper
• interface Synth_CAPTURE_WAV
• interface Synth_NIL
• interface Synth_DEBUG
• interface Synth_DATA
• interface Synth_ATAN_SATURATE
• interface Synth_BRICKWALL_LIMITER
• interface Synth_AUTOPANNER
• interface Synth_DELAY
• interface Synth_CDELAY
• interface Synth_FM_SOURCE
• interface Synth_TREMOLO
• interface Synth_FX_CFLANGER
• interface Synth_NOISE
• interface Synth_WAVE_TRI
• interface Synth_WAVE_SQUARE
• interface Synth_WAVE_PULSE
• interface Synth_WAVE_SOFTSAW
• interface Synth_OSC_SAW
• interface Synth_ENVELOPE_ADSR
• interface Synth_SHELVE_CUTOFF
• interface Synth_XFADE
• interface Synth_MIDI_TEST
• interface Synth_MIDI_DEBUG
• interface Synth_FREEVERB
• interface FreeverbGuiFactory
• interface Synth_CPU_LOAD
• interface Synth_STD_EQUALIZER
• interface Synth_RC
• interface Synth_MOOG_VCF
• interface Synth_PSCALE
• interface Synth_SEQUENCE
• interface Synth_PITCH_SHIFT
• interface Interface_MIDI_NOTE
• interface Synth_STRUCT_KILL

Public Types

• enum HeaderMagic { MCOP_MAGIC = 0x4d434f50 }
• enum MessageType { mcopMessageInvalid = 0, mcopServerHello = 1, mcopClientHello = 2, mcopAuthAccept = 3, mcopInvocation = 4, mcopReturn = 5, mcopOnewayInvocation = 6 }
• struct Header
• struct Invocation
• struct OnewayInvocation
• struct ServerHello
• struct ClientHello
• struct AuthAccept
• struct ObjectReference
• struct ParamDef
• enum MethodType { methodOneway = 1, methodTwoway = 2 }
• struct MethodDef
• enum AttributeType { streamIn = 1, streamOut = 2, streamMulti = 4, attributeStream = 8, attributeAttribute = 16, streamAsync = 32, streamDefault = 64 }
• struct AttributeDef
• struct InterfaceDef
• struct TypeComponent
• struct TypeDef
• struct EnumComponent
• struct EnumDef
• struct ModuleDef
• enum TypeIdentification { tiUnknown = 0, tiVoid = 1, tiLong = 2, tiByte = 3, tiString = 4, tiBoolean = 5, tiFloat = 6, tiEnum = 128, tiType = 129, tiInterface = 130 }
• struct Any
• struct TraderEntry
• enum AutoSuspendState { asNoSuspend, asSuspend, asSuspendStop }
• enum AudioManagerDirection { amPlay, amRecord }
• struct AudioManagerInfo
• enum RealtimeStatus { rtRealtime, rtNoSupport, rtNoWrapper, rtNoRealtime }
• enum poState { posIdle, posPlaying, posPaused }
• enum poCapabilities { capSeek = 1, capPause = 2 }
• struct poTime
• enum PortDirection {input, output}
• enum PortConnType { conn_stream, conn_event, conn_property}
• struct PortType
• struct ModuleInfo
• struct TimeStamp
• enum MidiCommandStatus { mcsCommandMask = 0xf0, mcsChannelMask = 0x0f, mcsNoteOff = 0x80, mcsNoteOn = 0x90, mcsKeyPressure = 0xa0, mcsParameter = 0xb0, mcsProgram = 0xc0, mcsChannelPressure = 0xd0, mcsPitchWheel = 0xe0 }
• enum MidiCommandParameter { mcpSustain = 0x40, mcpAllNotesOff = 0x7b }
• struct MidiCommand
• struct MidiEvent
• enum MidiClientDirection { mcdPlay, mcdRecord }
• enum MidiClientType { mctDestination, mctApplication }
• struct MidiClientInfo

Detailed Description

This type is sent as header of each MCOP message.

This is sent as start of each normal (twoway) invocation

This is sent as start of each oneway invocation

Body of the mcopServerHello MCOP message

Body of the mcopClientHello MCOP message

The message you get when you connect a MCOP server. The MCOP server can send you some useful information here. Usually, it will send you

GlobalComm=<object reference of a global comm interface> InterfaceRepo=<object reference of an interface repository>

But as this is called "hints" it doesn't necessarily need to happen.

An object reference

The definition of a parameter of a method

hints is reserved for future extensions, such as default, min and maxvalues

Twoway methods are such where the calling process does a call and is suspended until some result (maybe even a void result) gets back.

Oneway methods are one shot and forget methods: you send the invocation, and continue. Maybe it will be received, maybe executed later. You will never hear the result.

The definition of a method.

hints is reserved for future extensions, such as default, min and maxvalues

an attribute

flags should contain things like

• attribute is readonly/writeonly/readwrite
• attribute is incoming/outgoing stream
• if it's a stream, it also should contain the information whether it is asynchronous or synchronous
• NB20000320: see InterfaceDef for the meaning of streamDefault

The definition of an attribute and/or stream

hints is reserved for future extensions, such as default, min and maxvalues

InterfaceDef - interface definition structure

defines what methods/attributes a particular interface supports: these do not contain the methods/attributes of inherited interfaces.

inheritedInterfaces only contains the names of Interfaces that this one inherits in exactly one step. So to see if interface XYZ is inherited from ABC, you need to check the "inheritedInterfaces" of XYZ, and their "inheritedInterfaces" and their "inheritedInterfaces" and so on.

- NB20000320: defaultPorts allows to connect to those port by default if connection is made in the corresponding direction. It cannot be just an attribute flag because of the syntax on a separate line.

hints is reserved for future extensions, such as default, min and maxvalues

One component of a struct

hints is reserved for future extensions, such as default, min and maxvalues

The definition of a struct

hints is reserved for future extensions, such as default, min and maxvalues

One item of an enum value

hints is reserved for future extensions, such as default, min and maxvalues

The definition of an enum

hints is reserved for future extensions, such as default, min and maxvalues

The contents of an idl file

hints is reserved for future extensions, such as default, min and maxvalues

The interface repository

Internal use: implement distributed asynchronous streams.

The FlowSystemSender object transmits the packets that should be sent over the stream via _allocCustomMessage (Object_base).

Internal use: implement distributed asynchronous streams.

The FlowSystemReceiver object receives and extracts the packets sent by the sender object and injects them in the notification system again.

A flow system.

Flow systems handle the streaming between MCOP objects. As this streaming is network transparent (at least for asynchronous streams) they have this remote interface.

A global communication space used to obtain initial object references

MCOP needs a way to connect to initial (global) object references. This is done by these global communication spaces.

global communication based on the /tmp/mcop-<username> directory

TraderOffer - this contains an offer of an object (which is usually returned as result of a query.

TraderQuery - this is a query against the trader. The idea is simple: you say what you need, and the trader offers you components that do what you want.

Arts::Object is the base object that every interface implicitely inherits

it is also the source for generation of the Object_stub stuff (use mcopidl -e Arts::Object to avoid code generation for this interface)

a simple struct which can hold any other type

TraderEntries as produced by the loader

loader to load plugins (implemented in some language/binary format)

The SynthModule interface is the base for all modules containing streams.

There are two goals achieved by this interface. On one side, there is functionality which users of stream carrying modules want to use (which is: start streaming, stop streaming).

On the other hand, there is functionality which the flow system will use to achieve these goals.

Plays a stream of audio data to the soundcard

Records a stream of audio data from the soundcard

A frequency generator

This kind of object is used to create frequencies. Oscillators are connected at the output of this object

A sine wave

A module which mixes an arbitary number of audio streams

A module which adds two audio streams

Multiplies two audio streams

This plays a wave file

sends data to a bus - busses are dynamic N:M connections - all signals from all uplinks are mixed together, and sent to all downlinks

receives data from a bus - busses are dynamic N:M connections - all signals from all uplinks are mixed together, and sent to all downlinks

Byte stream to audio conversion object

Converts an asynchronous byte stream to a synchronous audio stream

Base interface for all stereo effects

this is a simple clipping stereo volume control

A funny FFT scope

A stack of stereo effects

Information structure for audio manager clients

an audio manager client

The audio manager interface

This is a virtual output port, which you use to play data. Where exactly this data gets played is managed by the audiomanager.

Creation: there are two ways to initialize a Synth_AMAN_PLAY - one is to set title and autoRestoreID to sensible (non empty) values. The other is to pass an already initialized AudioManagerClient on the constructor.

This is a virtual input port, which you use to record data. Where this data comes from is in turn managed by the audiomanager.

Creation: there are two ways to initialize a Synth_AMAN_RECORD - one is to set title and autoRestoreID to sensible (non empty) values. The other is to pass an already initialized AudioManagerClient on the constructor.

One entry of the sample storage - initially, you'll need to fill the entry.

To do so, call write repeatedly to fill it with data, and finish() when you are done. After that you can use the filename attribute to get the name of the file on the server that has stored the data. You can use this filename for other things (i.e. SimpleSoundServer::play).

Interface for storing files on the sound server

Producer of byte sound

This is used inside the sound server interface

This is a very simple sound server interface

WARNING: This currently inherits a KMedia2 PlayObjectFactory for test purposes, but don't rely on that

This is an enhanced sound server interface which can be used to query status information or suspend the soundserver right away

This is an even more enhanced sound server interface that supports changing the autosuspend time, and returning more information about the server settings.

A KMedia2 Wave PlayObject

KMedia2 time information

This is a time value which contains either milliseconds & seconds, or a custom unit or both. It is a flexible time base.

If a value isn't there, it is set to -1.

private part of the PlayObject API (don't use)

KMedia2 PlayObject - these can be used by Kaiman for instance

use this to create new PlayObjects for media

UNSTABLE/EXPERIMENTAL!

UNSTABLE/EXPERIMENTAL! Example stream for files.

Extended Version of PlayObjectFactory

ConnType (maybe obsolete)

ConnType: (connection type) this is wether this value is used

- once (such as a filename of a waveplugin) -> property this implies that the allowed connection is only value

- event based (such as midi events) -> event when events arrive, they are processed, when no events arrive, don't care

- stream based (such as audio streams) -> stream every calculation of the module consumes/creates a sample that means: no data = no calculation possible

WARNING: This is part of the artsbuilder dynamic programming interface as the MCOP port isn't there yet, this stuff may change

PortType (maybe obsolete)

isMultiPort specifies if the port can take multiple incoming connections or not. This is only relevant/allowed for input ports, the output of all output ports may be connected to any amount of receivers.

Ports which can take multiple connections are handled differently internally. (Also, artsbuilder needs to know whether to allow multi- connections or not).

WARNING: This is part of the artsbuilder dynamic programming interface as the MCOP port isn't there yet, this stuff may change

an absolute timestamp

different status of a midi command

the following are to be used once status is (mcsParameter|channel):

a midi command

a midi event

a midi port

information about a midi client

a midi manager client

Some general notes to the understanding of the midi manager. The midi manager has the task to intelligently assign applications to destinations.

It is important to understand what it actually does to understand the distinction first, which is expressed through the "MidiClientType" of each client.

APPLICATIONS: An application is a user visible application, that produces or records midi data. It is important for the understanding of an application, that an application actually *wants* to be supplied with data, or wants to get its data played. Thus, adding an application to the midi manager is an implicit request: "go and find a place where to put the events to (or get the events from)".

Examples for applications would be games or midi players.

DESTINATIONS: A destination is a system service that plays or supplies midi data. The characteristic here is that a destination is something that is there if you need it.

Examples for destinations might be might be a hardware device or an emulation of a hardware device (such as a virtual sampler).

So the process is as follows: - destinations register themselves at the midi manager, and provide system services in that way

- when the user starts an application (such as a midi player), the midi manager's task is to assign it to a suitable destination

- the user can interact with the process by changing the way applications are assigned to destinations - the midi manager will try to learn what the user wants, and next time do a better job while assigning

To actually record or play some data, you need to register a client first, and after that, you can add Input or Output "MidiPort"s to your client, so that you can actually send or receive events with them.

Midi Timer - can be used to provide timing for midi ports that have no "native" timing.

Uses the system time (i.e. gettimeofday() and similar) to provide midi timing

Uses the audio time (i.e. samples rendered to /dev/dsp) to provide midi timing

A gui factory is an object that can create a Widget which provides a user interface for a running object (for instance, you might have an effect running somewhere, and a gui factory

TODO: do we need another argument (or other arguments) to specify style or other parameters?

Convenience gui factory, which knows how and whether to

- build a gui out of hints? - create an artsbuilder built gui? - create a gui composed of other widgets? - create a completely custom gui?

this interface currently has probably a problem - usually, if you are using such a module, you would expect that you can specify the filename with it - BUT, if you allow this, then any instrument definition file (.arts) and similar might overwrite every file the user can access, which might not be what you want, so I currently save it to a file in /tmp/mcop-<username>/capture.wav (which might be unlucky since the user might not have too much space there)