Log of changes for each release of TTBlue (also known as JamomaDSP/JamomaCore).

Version 0.5.5
29 July 2009 -- Rev 1090

This revision begins the process of pulling TTBlue under the umbrella of the Jamoma Platform, rather than being an entirely independent project. As such, the name of TTBlue has changed to Jamoma DSP and many file-references have been updated or changed. Jamoma DSP is a misnomer, however, because this revision also expands the palette of offerings to purely graphical extensions that have nothing to do with audio or dsp. This may be addressed in the near future.

There are a lot of bug smallish fixes in this release not listed below. Check the SVN logs for more details.

  • Added a version of the calculate method for audio objects that can calculate lists of values.
  • All dynamic objects, such as TTAudioSignalArray are now first-class objects.
  • Many fixes and tweaks to the class registration and life-cycle management of objects.
  • New wrapper macros to make it easy to wrap a calculate method inside of a process method (take a look at examples in the FilterLib -- see below).
  • Protection / enforcement for using TTObjectInstantiate() and TTObjectRelease() to manage objects rather than the new and delete operators.
  • all objects now take a single TTValue reference for passing arguments, making the system much more consistent - and in some cases more efficient (not going back and forth between TTValue and other representations along the path to the constructor)
  • names given to class constructors are now a TTSymbolPtr rather than char*,
    since they were just internally converted anyway...
  • fixes for symbolic errant/inconsistent names given to class constructors
    *New Macros for class definition and implementation. In theory, these simplify the process of writing class, registering a class, and instantiating a class. All of the information about a class (such as the name used to instantiate and a classes' tags) are actually in the implementation rather than in a random file located elsewhere.
  • TTObject now holds a pointer to the object's TTClass rather than a pointer to
    the object's name. The name of an object is no longer uselessly passed around
    in constructors.
    *TTList: new 'free' method is like 'clear' except that it actually calls the delete operator on each member before removing the references.

  • New TTGraphics extension
  • New SpatDisplay extension
  • New Hi-Mid-Low Shelf filter
  • Initial version of TTMatrixMixer: a multi-signal, multichannel, matrix mixer.
  • Most non-core units now moved out of the framework and into extension libraries (e.g. FilterLib, FunctionLib, EffectLib, etc.)

  • New BlueButter AU plug-in: implements a lowpass filter with a TTGraphics-based custom UI.
  • Several new Max externals

Version 0.5.4
13 December 2008 -- Rev 925

This release includes lots of housekeeping, cleaning-up, etc. throughout TTBlue, and also includes a number of changes that were desirable to support for the [ Jamoma Multicore] project.

The way all audio processing methods are implemented has changed, and all audio objects have been modified. All audio objects now implement their process methods as taking an array of input audio signals and an array of output audio signals. Sidechains and sidechain process methods have been eliminated. This change is required for allowing the creation of objects that can operate on any number of multichannel
signals, for example to create an audio-mixing matrix object.

Additionally, new thread-safety measures have been taken which require that all objects deriving from TTObject be created and destroyed using the factory methods TTObjectInstantiate() and TTObjectRelease(). Using the new and delete C++ operators is unsupported for these objects and will carry the potential for causing trouble.

  • Now using !PortAudio to interface with audio drivers on the host system.
  • New TTAudioEngine class can manage the processing of dsp graphs by wrapping audio drivers etc for the entire environment.
  • Implemented the registration (and unregistration) of object observers. A notification is sent to observers when freeing objects.
  • All audio processing methods now operate on TTAudioSignalArrayPtr params rather than TTAudioSignalPtr params.
  • Ensuring that on Windows there are no dependencies on the MSVCR DLL.
  • TTObject locks can now function in recursive situations.
  • Fix for major source of memory leaks where all objects created would be leaked because the reference count was being checked on the environment object, not on the actual object whose reference count had reached zero.
  • New TTInfWrap() and TTFold() functions to wrap and fold numbers within a specific range.
  • TTList: new method for sending a message to every object in the list.
  • TTList: new appendUnique method for ensuring added items are unique.
  • TTList: findEquals method now works correctly
  • TTAudioSignal: when copying a signal with more outputs than inputs, the extra outputs are now set to zeros.
  • TTAudioSignal: now has a += operator for mixing a signal vector with another signal vector.
  • TTAudioSignal: bitdepth field is now properly set when a signal is allocated.
  • Log messages now properly make it to the console
  • TTAudioObject::setMaxNumChannels is now publicly accessible.

  • TTOperator: fixed bug where initial operand and operator values were reversed.
  • TTDelay: fixed a variety of major bugs
  • TTLimiter: fixed crash due to improper number of channels being initialized for contained objects.

Version 0.5.3
16 October 2008 -- Rev 784

  • New singleton TTEnvironment class implements an object factory and registry for the global TTBlue environment. The registry can be searched by tags that are associated with the various classes.
  • Created macros for typical access of the TTEnvironment class.
  • Added initial light-weight locking mechanism for objects so that they aren't freed while working in another thread.
  • Implemented a system for defining external classes (extensions). If the built extensions are located in specified directories then they will be loaded automatically when TTBlue is initialized.
  • A variety of improvements to message and error logging facilities.
  • More typedefs for common method arguments.
  • Implemented TTHash class, a hash-based associative container.
  • Implemented TTList class, a linked-list container.
  • Greatly simplified implementation of TTSymbol
  • The symbol table now uses a hash-based implementation for speedy lookup
  • Added message debugging switches that can be toggle on and off at runtime.
  • TTValue now supports strings (the TTString type, which is a typedef of std::string)
  • New method to fetch all of an object's message names.
  • Audio objects inherit a new 'mute' attribute, which sets the process method to output zeros.
  • Improved const clarity/safety
  • Improved and expanded TTErr error codes and type.
  • New "calculate" method for TTAudioObject can be called to compute a single sample of audio. If the subclass defines a calculate method, then that method is used. Otherwise the process method is used to process the single sample.
  • Attributes and Messages of an object are now themselves first-class objects in TTBlue, and thus can have messages and attributes of their own. For clarity, we describe an attribute of an attribute as a "property".
  • New attribute properties: readonly, range, and rangeChecking.
  • TTAudioSignal is now a first-class object in TTBlue.
  • New TTAudioSignal::copy method.
  • New convenience macros for setting/getting vectors in TTAudioSignal.
  • New type-info class creates subsystem by which it is easy and fast to get information about a data type, given its TTBlue type specifier.
  • New methods for TTValue: clip, cliplow, and cliphigh -- these apply range limiting to a value (or array) in-place.
  • Transitioned calls from malloc to new, where appropriate
  • New TTValue::round() method
  • New TTValue::toString() method
  • New TT_ASSERT macro implementing a form of assertions for TTBlue.
  • Added exception handling when creating new objects
  • Made the publicly-used environment calls proper C functions instead of macros.
  • On Windows, the MS C runtime library is now statically linked to avoid various problems with distribution and usage.

  • New TTClipper extension is an extremely simple object intended as a starting point or template for creating new extensions.
  • New TTFunctionLib extension is a port of the Jamoma FunctionLib into TTBlue for applying various functions to data.
  • New TTAudioUnit extension is an audio object that processes sound by hosting a plug-in in Apple's Audio Unit format.

  • TTAllpass class implemented (not done yet)
  • New TTNoise class (is this tested?)
  • TTZerox analysis bug fixes (was always producing a zero at output)

  • A new dynamic class wrapper has been implemented for Max/MSP. This takes an existing TTBlue class and automatically generates the Max/MSP class for it at runtime. A number of examples were updated to take advantage of this, including tt.dcblock~ and tt.degrade~.
  • The tt.overdrive~ Max/MSP example now demonstrates subclassing of a TTBlue unit, registering it as an external class, and using the new dynamic class wrapper.

Version 0.5.2
12 July 2008 -- Rev 560

  • Simplified the interface for code using TTBlue objects by providing a single header file that includes everything that is needed (TTBlueAPI.h).
  • Miscellaneous memory leaks plugged.
  • New convenience macros to make it easier and less error-prone when writing a new TTBlue class.
  • All publically available accessors and methods are now also declared public for direct access by other classes.
  • Various improvements to message logging facilities.
  • TTAudioSignal now has a 'clear' method
  • TTAudioSignal::getMinChannelCount() now works with 3 signals in addition to 2 signals.
  • Audio channel counts and indexes are now all maintained as 16-bit values rather than 8-bit values.
  • TTAudioSignal problems caused by trying to malloc zero-sized memory are fixed.
  • When the maximum number of audio channels for an object changes, that object can properly free the right number of channels now.
  • TTSymbols are now consistently used and passed as pointers rather than references.
  • TTValue now sets and gets TTSymbol members correctly.
  • TTValue is now resized properly, without discarding or corrupting data.
  • TTObject duplicate code for setting and getting attribute values is now largely managed with C++ templates.
  • The compiled TTBlue framework on the Mac can now be included inside of a Mac application bundle.

  • TTCrossfade now processes audio both with a single interleaved audio input, or with 2 separate audio inputs
  • TTGain can now be controlled using MIDI units.
  • TTLimiter - various fixes to improper behavior in the processing routine.
  • TTAdsr now implements 'gain' and 'linearGain' attributes consistent with other objects.
  • New TTBuffer class (ported from the old TTBlue)
  • New TTWavetable class (ported from the old TTBlue)
  • New TTNoise class (ported from the old TTBlue)

  • New tt.xfade~ example for !MaxMSP
  • New tt.gain~ example for !MaxMSP
  • New tt.zerox~ example for !MaxMSP
  • New tt.wavetable~ example for !MaxMSP
  • New tt.op~ example for !MaxMSP
  • Fixed problems with tt.balance~ example for !MaxMSP
  • Added Windows versions of the !MaxMSP projects.
  • New ttlimiter~ example object for Pure Data.
  • New VST plug-in example based on TTOverdrive.
  • New !AudioUnit plug-in example based on a butterworth lowpass filter.

Version 0.5.1
25 May 2008 -- Rev 468

  • Message passing interface rewritten using a new TTMessage class, with definable flags. The flags allow for calling messages whose prototypes do not have any arguments, for example, so that calling such methods directly in C++ isn't excessively cumbersome.
  • Attributes also may now have flags to determine whether or not the TTAttribute object will actually be passed to the accessor.

Version 0.5
22 May 2008 -- Rev 450

Complete re-write. This version merges ideas from the version 0.3 and 0.4 branches, but is overhauled from the ground up in C++.

  • Implemented a system for dynamically created and dynamically bound messaging and parameters.
  • New TTSymbol object and symbol table for fast string comparisons
  • New support for threading and critical regions
  • Optional methods bind to messages to receive notifications of changes to the parent object.
  • New ability to create data objects (based on TTDataObject) in addition to audio objects.
  • All audio objects inherit a number of parameters, including bypass functionality.
  • New multichannel handling (taken in-part from the 0.4.x development).
  • Now compiles into a standalone library (DLL for GCC or VS2008 on Windows, or a Framework on MacOS X), for dynamic linking.
  • All classes are now documented using Doxygen.
  • Many many improvements to the TTValue class.
  • Etc.

Version 0.4

This version featured an entire library re-written in Objective-C. All attribute and value systems were thus handled by Objective-C's Foundation classes. Clearer implementation of multichannel audio input/output than in 0.3.x. Also generating real documentation of the entire library for the first time. Work on this line of development has been abandoned.

Version 0.3

This version introduced a tt_value class for passing values, and the new tt_audio_bundle class for bundles of audio signals instead of individual audio signals. Work on this line of development has halted.

Version 0.2.5
25 February 2007

  • Many incremental improvements, including thread-safety fixes
  • Stub code added for major changes that are coming in version 0.3

Version 0.2.1
21 June 2005

  • objects allocating blocks of memory now, for improved safety, ensure that the pointer is null before trying to allocate the memory. This applies particularly to tt_allpass.
  • clumsy conditional precompiler stuff in clip() removed
  • mem_alloc() now ensures that memory is cleared when allocated
  • minor improvements to mem_free() for non-Max, Macintosh targets
  • when tt_buffer allocates new memory, it now only frees the previous memory if it actually allocated and owns that memory
  • fixed bugs in limit_min() and limit_max()

Version 0.2

  • Naming convention of all classes made consistent (uses "tt_")
  • tt_overdrive: new stereo dsp_vector_calc() routine
  • integrated dc-blocking added to both overdrive and limiter objects

Version 0.1.1

  • Documentation updates

Version 0.1

  • Initial developer release