[gmpi] Re: Requirements evaluation

  • From: eric <dilvie@xxxxxxxxxx>
  • To: gmpi@xxxxxxxxxxxxx
  • Date: Fri, 07 Nov 2003 23:28:09 -0700



Tim Hockin wrote:

On Fri, Nov 07, 2003 at 07:13:17PM -0700, eric wrote:


OMS native plugins. Please have a look. I've raised a few points which may or may not have been discussed on the list, but I think they are important (at least to me), and should be given some consideration.



I'm reading it now.


Re: your assertion that any DSP (including video) should be allowed

GMPI V2.  Or 3 or 4.  We can't be everything to everyone.  Our mandate is to
do a Music/Audio plugin format.  Certainly it would be nice to encompass
video.  Later.  Maybe.

I believe it's possible to separate the basic plugin spec into different layers, including one that handles things like port datatypes, memory buffers, whatever. So we start with the generic spec, and create an audio datatype for GMPI V1, and then when video is added in 2, 3, or 4, we can stay pretty much backwards-compatible with v1. This will also help resolve potential GMPI version transition issues, allowing smooth transitions similar to w3 standard versions.

Re: Networking

Distributed rendering does not always or necessarily make sense.  It is very
dependant on the graph structure.  To date, we have assumed that anything
outside the local graph is outside GMPI.  What exactly are your proposed
requirements in this area?

Let me clarify: It would be cool to keep multiple hosts in perfect sync over a network, and allow plugins on one system to communicate with plugins on another. I do NOT think that the networking details should be specifically addressed by plugin standard, but it should be fairly easy to create a network sync plugin that will bus clock and plugin data back and forth. This would allow render-farm-like functionality not for a single plugin, but to allow a single project to use many hundreds, or even thousands of plugins in a single rendering network. This would be especially useful in high-end studio productions, and a portable standard like GMPI could make it easy to create very powerful render farms on comodity hardware.

Also, on complex multi-media projects, (such as movies), people may want to be able to edit the entire project (including audio effects) and collaborate over distances. It would be cool if everybody could download project assets from a central repository, and work collaboratively (and non-destructively in terms of shared assets) in such a way that everybody is essentially always working on the same version of the project. I don't think this should be specifically designed and implemented in the GMPI spec, BUT, I don't think we should make GMPI choices that would interefere with this goal (a real goal for OMS).

Re: thin layers of architecture

Explain more what you want to see?

For example, a plugin description language (like one I've envisioned that I was calling the Open Media Plugin Language) could describe a host or plugin's capabilities, and list parameters and services. I envisioned that to work something like this:

library - the file in which machines are stored.. this supplies the core plugin interface/services for all included machines
machine - this is what the user sees in the ap as a synth or effect plugin..
parameter group - a logical grouping of parameters, ie, A, D, S, R on a synth.
parameter - defined well in the summary
service - a function that is callable by the host or other plugins... a plugin may exist explicitly to provide services such as loading/saving non-native file formats
capabilities - a list of sub-spec implementations (instrument, effect processor, etc...)


Another layer of the spec might be a specification of spacific parameter types in groups, such as music communication spec (similar to MIDI, or even MIDI itself). Each of these event-based layers might be listed in the capabilities section of the plugin description.

Another layer might be clock/sync signals.

Another layer might be the standard services supplied by the host, and standard services that may be supplied by plugins... such services might be file I/O, memory allocation, shared memory/resource access, etc..

By separating different types of needs into different layers of the specification, we can allow for future extensibility without working out all of the details right now. It also keeps each layer as SIMPLE as possible (requirement #1 for a lot of people seems to be that the spec on the whole must be EASY to implement).

IMO, these abstractions do not complicate the design.. they simplify it, and allow it to conform more with best oo design practices.

Re: NSPR

Thanks! Bookmarked.

Good stuff. However, we may still have to deal with technical issues such as timer granularity. I haven't tested it yet. At any rate, it could provide us a very good starting point, and the licensing is very flexible.

Re: notifying CPU hungry plugins

What is the mechanism you want to see, and what do you expect a plugin to do
about it?

I don't know.. this is just a requirement collection doc, not implementation details.. =) I figured if a plugin is using too much time, the host sends it a signal (via the standard event system, perhaps through a dedicated host/plugin communication parameter), and the plugin takes whatever measures the plugin developer deems necessary to fix the problem.. if the plugin continues to use too much time, the host developer can decide what they'd like to do about it. I don't know if we should dictate exactly what goes on, because the apropriate action might vary from one situation to another.

Re: Time

Can you explain more? I'm not clear..

Which specific requirement needs more explanation? I thought I'd been fairly clear. Anyway, I think that all of my requirements can be satisfied with the currently proposed solutions:
ABSTIME
USTIME
MUSTIME
METRTIME


For my relative position mini-sequences, the sequencer can convert the relatively stamped events into ABSTIME (or whatever plugins need to see) before sending them down the parameter pipe.

Re: Parameters

I agree more or less about using generic parameters for many things.  I
don't know that making it totally extensible is worth the effort.

What effort? Do you agree that parameter types should be extensible?

 Over
categorization is bad.

Can you describe a specific problem you are envisioning? Maybe we're just not speaking the same language yet. =)

 A plugin that provides the well-known parameters for
a particular interface (say the instrument interface) can be said to
implement that interface.  I think that is what you mean by thin layers.

In this context, that's exactly what I mean.

However, I don't think I want to see a plugin saying "I am an instrument".
The fact that a plugin implements the instrument API should be sufficient.

I would agree, but how does a plugin announce it's capabilities? =) I suggest the capabilities declarition in the plugin description spec (another thin layer). =)

That said, if an API is sufficiently complex, maybe it is easier to provide
a list of interfaces the plugin implements?  Anyone have comments?

Exactly what I propose.

Re: save/restore state

Can you provide concrete examples of what you need to save besides
parameters?

Wave-tables, for instance, but plugin developers may want to save stuff that we can't predict, and we should allow them to. Perhaps this should not be implemented via the stata mechanism that was proposed, but I know that at a minimum, I'd like to be able to store my currently loaded wave-table set for a sampler, and my current sequence for things like little beat-sequencers. These things are state-related, and not tied to parameter settings, from where I'm sitting.

I DON'T think that creating specific hacks for wave-tables and mini-sequences is the way to make this happen. It should be generic and usable for just about anything the developer dreams up.

re: fully extensible parameter types

We have to balance simplicity vs extensibility.  Convince me this level of
complexity is needed.

I'm not sure it's required in this particular situation, but if it's not implemented in the spec, and somebody needs something different, we're going to have hosts and plugin developers creating cheap hacks to get arround my lack of vision. IMO, that's worse than the added complexity at an early stage, as long as we still satisfy the #1 requirement: keep it simple. =) When I start doing test implementations, I'll let you know if I come up with a brilliant mechanism to make it happen. ;)

Thanks for the doc!  I've taken a number of notes from it, and if we can
answer these questions, I'll have more.

No worries. I'm doing this work anyway.. I might as well share.

- Eric

--
~
<http://www.dilvie.com/>



----------------------------------------------------------------------
Generalized Music Plugin Interface (GMPI) public discussion list
Participation in this list is contingent upon your abiding by the
following rules:  Please stay on topic.  You are responsible for your own
words.  Please respect your fellow subscribers.  Please do not
redistribute anyone else's words without their permission.

Archive: //www.freelists.org/archives/gmpi
Email gmpi-request@xxxxxxxxxxxxx w/ subject "unsubscribe" to unsubscribe

Other related posts: