[gmpi] High level milestone plan (long message)

In my company we manage software development on a system of milestones.
We take the entire product cycle and carve it up into a series of
periodic checkpoints.  This approach helps us manage change and keep on
top of exactly where we are in the project.  I'd like to propose we take
a similar approach for GMPI.  

But in the context of GMPI, I have 2 other reasons for wanting to work
this way.

Reason 1:  

At the MMA meeting at NAMM, it was suggested and generally agreed that
the baseline benefit of GMPI is to provide a kind of universal plugin
wrapper for smaller developers who didn't already have one.  The premise
is that bigger companies such as Waves or Native Instruments already
have their own internal framework for "write once, ship many", and that
smaller companies do not.

We've talked about creating wrappers as part of the GMPI SDK.  But we've
never really identified a stage of development where we state that
wrappers exist for all popular formats.  I believe this needs to be one
of our milestones, and an early one at that.

What's attractive about building wrappers early is that we can do this
without first having to design GMPI's packaging or meta-data
architecture.  We can simply create a static library for the GMPI core
object, and then let each specific wrapper handle the format specific
packaging, registration and meta-data issues.  Also, we can defer having
to tackle many UI issues, leaving them up to the wrapper for now.


Reason 2:  

The area of parameter/voice control poses some challenges and
opportunities.  The challenge is we assume that we will be able to
easily wrap GMPI parameters within a VST, AU or DirectX wrapper.  But I
expect there to be unexpected details that will trip us up, and these
may only come to light when we start to develop the wrappers.  

The opportunity is, there may be some interest in the MMA hardware
community for a parameter discovery and control mechanism such as the
one we are planning for GMPI.  It might really help our efforts to get
input from the hardware vendors on this slice of the GMPI protocol.  IMO
it would be a huge design win if something like Chris Grigg's proposed
message format could be massaged into something that hardware vendors
would like to use, too.  Maybe nailing down the final ultimate parameter
mechanism needs to be another milestone?


Based on these musings, I suggest we phase GMPI implementation using in
the following milestones.

M1: Establish coding standards, create basic skeleton modules for Win,
Mac and *nix.  (Currently underway.)

M2: Define base C interface to the GMPI core object.  This interface
will not initially address packaging, registration, meta-data or UI.

M3: Create a simple volume control plugin (headless) using the base C
interface, plus command line test harness.

M4: Implement wrappers for VST (PC), VST (Mac), Audio Units and DirectX.
These wrappers will be constructed as projects in the IDE of choice
(TBD) for each platform.  These wrappers will be headless.  The projects
will statically link to the simple volume control plugin.

M5: Create a simple sine wave synthesizer using the base C interface,
plus command line harness.  This synth will be MIDI controllable only.

M6: Update the wrappers that were created in M4 so that they support a
MIDI controllable software synthesizer.

(***) Note that M1-M6 do not require involvement in the MMA.  By the end
of M6 we wil have created something very close to a universal plugin
wrapper, and that will be significant achievement onto itself.


Thoughts?

Other related posts: