src/soundplay_includes/pluginproto.h

/* ==================================================
       SoundPlay plugin specification.
 ================================================== */

#ifndef _PLUGIN_PROTO_H
#define _PLUGIN_PROTO_H

#include <SupportDefs.h>
#include "Playlist.h"

/*
        To let SoundPlay know which filetypes you support, you fill in an
        array of these. SoundPlay will add both an uppercase and a lowercase 
        version of the extensions you specify to the mime database.
*/
typedef struct supported_type
{
        char *mimetype;
        char *longdesc;
        char *shortdesc;
        char *extension1;
        char *extension2;
} supported_type;


/*
 Operations that can be performed before the plugin is really active.
 These functions globally affect and describe a plugin. They are
 used to identify and configure the plugin, and to instantiate one
 particular instance of the plugin.
 All types of plugins are handled through this interface.
*/

class SoundPlayController;

typedef struct plugin_info
{
        SoundPlayController *controller;
        entry_ref *ref;
} plugin_info;

typedef void            op_about();
typedef BView*          op_configure(BMessage *config);
typedef void*           op_instantiate(void **data, const char *name, const char *header, uint32 size, plugin_info *pluginfo);
typedef void            op_destroy(void *plugin_ops, void *data);

/* And this structure contains the above functions. */
typedef struct plugin_descriptor
{
        // first some bookkeeping stuff
        uint32                          desc_magic;                             // magic number
        uint32                          desc_version;                   // version of this plugin structure

        const char*                     id;                                     // a unique string identifying your plugin
        uint32                          version;                                // distinguish between different version of the same plugin
        uint32                          flags;                                  // PLUGIN_IS_DECODER, PLUGIN_IS_FILTER, PLUGIN_IS_VISUAL

        const char*                     name;                                   // MUST be filled in
        const char*                     aboutstring;                    // Simple about string, in case you don't want to implement the About() function.

        op_about                        (*About);                               // Leave NULL if not implemented
        op_configure            (*Configure);                   // Leave NULL if not implemented

        op_instantiate          (*Instantiate_Plugin);  // MUST be implemented, instantiates all types of plugins, returns pointer to plugin struct (see below)
        op_destroy                      (*Destroy_Plugin);              // MUST be implemented, destroys the plugin created by Instantiate_Plugin()
} plugin_descriptor;


/*
 Only these function need to be exported.
 They return a pointer to an array of pointers to plugin_descriptor,
 which lists all the plugins in this plugin-file, and a pointer to an
 array of supportedtypes.
*/
extern "C" plugin_descriptor _EXPORT **get_plugin_list(void);
extern "C" supported_type _EXPORT *get_supported_types(void);


/*
 These are the operations that can be performed on a particular instance
 of a decoder-plugin, once it has been instantiated.
 The void* that each function gets as the first argument is the data pointer
 that was filled in by Instantiate_Plugin
*/

struct file_info;

typedef status_t        op_decoder_open(void*,const char *name, const char *header, uint32 size, BMessage *config);
typedef void            op_decoder_close(void*);
typedef status_t        op_decoder_info(void*,file_info*);
typedef int32           op_decoder_read(void *,char *buf, ulong count);
typedef status_t        op_decoder_play(void*);
typedef status_t        op_decoder_stop(void*);
typedef status_t        op_decoder_setvolume(void*,float);
typedef status_t        op_decoder_setspeed(void *,float speed);
typedef status_t        op_decoder_seek(void*, uint32 pos);
typedef uint32          op_decoder_position(void*);
typedef float           op_decoder_bufferamount(void*);

/*
 The following structure contains pointers to the above
 functions. Simply leave NULL if not implemented.
*/

typedef struct decoder_plugin_ops
{
        // first some bookkeeping stuff
        uint32                          ops_magic;                                      // magic number
        uint32                          ops_version;                            // version of this plugin structure

        // and the function pointers.
        op_decoder_open                         (*Open);                        // leave NULL if not implemented
        op_decoder_close                        (*Close);                       // leave NULL if not implemented
        op_decoder_info                         (*Info);                        // MUST be implemented

        op_decoder_read                         (*Read);                        // leave NULL for input filters that don't produce data

        op_decoder_play                         (*Play);                        // leave NULL if you do provide data
        op_decoder_stop                         (*Stop);                        // leave NULL if you do provide data
        op_decoder_setvolume            (*SetVolume);           // leave NULL if you do provide data
        op_decoder_setspeed                     (*SetSpeed);            // leave NULL if you do provide data
        op_decoder_seek                         (*Seek);                        // leave NULL if seeking is not possible (streams)
        op_decoder_position                     (*Position);            // leave NULL if you can't provide position-info
        op_decoder_bufferamount         (*BufferAmount);        // leave NULL if you don't want to display a buffer-indicator
} decoder_plugin_ops;


#define PLUGIN_STRING_LENGTH 256

typedef struct file_info
{
        char                            name[PLUGIN_STRING_LENGTH];             // a nicer name for the file, zero-length if none
        char                            typedesc[PLUGIN_STRING_LENGTH]; // a description of the file
        char                            mimetype[PLUGIN_STRING_LENGTH]; // mimetype

        float                           samplerate;
        float                           bitrate;
        uint32                          numchannels;
        uint32                          granularity;                    // in frames
        uint32                          framecount;
        uint32                          samplesize;
        int32                           byteorder;
        int32                           sampleformat;

        uint64                          flags;                                  // various flags
} file_info;


/*
 These are the operations that can be performed on a particular instance
 of a filter-plugin, once it has been instantiated.
 The void* that each function gets as the first argument is the data pointer
 that was filled in by Instantiate_Plugin
*/

typedef void            op_filter_filechange(void*, const char *name, const char *path);
typedef status_t        op_filter_filter(void*, short *buffer,int32 framecount, void *info);
typedef status_t        op_filter_filter_float(void*, float **input, float **output, int32 framecount, void *info);
typedef BView*          op_filter_configure(void*);
typedef void            op_filter_setconfig(void*,BMessage *config);
typedef void            op_filter_getconfig(void*,BMessage *config);

// The following structure contains pointers to the above
// functions. Simply leave NULL if not implemented.

typedef struct filter_plugin_ops
{
        // first some bookkeeping stuff
        uint32                          ops_magic;                                              // magic number
        uint32                          ops_version;                                    // version of this plugin structure

        // and the function pointers.
        op_filter_filechange            (*FileChange);                  // leave NULL if not implemented
        op_filter_filter                        (*Filter);                              // filter a buffer of data, leave NULL if you implement FilterFloat
        op_filter_configure                     (*Configure);                   // leave NULL if no run-time config
        op_filter_setconfig                     (*SetConfig);                   // leave NULL if no run-time config
        op_filter_getconfig                     (*GetConfig);                   // leave NULL if no run-time config
        op_filter_filter_float          (*FilterFloat);                 // filter floats, leave NULL if you implement Filter
} filter_plugin_ops;

// User Interface Plugin classes

enum {
        FILTER_HOTKEYS  = 1,
        FILTER_REFS             = 2
};

enum {
        CONTROLLER_ADD                          = 'ct\0\1',
        CONTROLLER_REMOVE                       = 'ct\0\2',
        CONTROLLER_PLAYLISTEDITOR       = 'ct\0\3'
};

class SoundPlayController
{
public:
        int32           Version();                      // soundplay version, encoded like this: X.Y.Z -> 0x000XYZ00
        const char *VersionString();    // version as a string, e.g. "3.2"
        
        void            Quit(void);
        void            DisableInterface(const char *id);
        void            HideMainInterface(void);
        void            ShowMainInterface(void);
        bool            IsMainInterfaceHidden(void);

        // You must lock the controller object before doing anything
        // with its tracks, and unlock it afterwards
        // Note that as long as you have a PlaylistPtr for a playlist, 
        // that playlist will remain valid. Its associated controls
        // might go away (i.e. the playlist gets removed from the controller),
        // but you can still work with the files in the playlist, or add it
        // to the controller again.
        void            Lock(void);
        void            Unlock(void);
        uint32          CountPlaylists(void);
        PlaylistPtr     PlaylistAt(uint32 index);
        PlaylistPtr     AddPlaylist();                                          // create a new playlist+controls
        status_t        AddPlaylist(PlaylistPtr playlist);      // add an existing playlist to the controller
        status_t        RemovePlaylist(PlaylistPtr playlist);
        void            OpenEditor(PlaylistPtr playlist);

        void            AddWindow(BWindow*, int32 filterflags=FILTER_HOTKEYS|FILTER_REFS);              // tell SoundPlay about your window(s) so that SP can do some hotkey-management for it and accept dropped files
        status_t        AddListener(BHandler *handler);
        status_t        RemoveListener(BHandler *handler);
        
        // plugins can use these functions to store and retrieve preferences as BMessages
        status_t        StorePreference(const char *name, const BMessage *message);
        status_t        RetrievePreference(const char *name, BMessage *message);

private:
#ifdef CONTROLLER_SECRET_INNER_WORKINGS
CONTROLLER_SECRET_INNER_WORKINGS
#endif
};


typedef status_t        op_ui_show(void*);
typedef void            op_ui_hide(void*);
typedef void            op_ui_setconfig(void*,BMessage *config);
typedef void            op_ui_getconfig(void*,BMessage *config);

// send a message with this constant to SoundPlay to enable
// an interface. Specify the interface by adding a string 
// called "interface" containing the plugin-id to the message.
const uint32 ENABLE_INTERFACE= '!int';

typedef struct interface_plugin_ops
{
        // first some bookkeeping stuff
        uint32                          ops_magic;                              // magic number
        uint32                          ops_version;                    // version of this plugin structure

        op_ui_show                      (*Show);
        op_ui_hide                      (*Hide);
        op_ui_setconfig         (*SetConfig);                   // leave NULL if not implemented
        op_ui_getconfig         (*GetConfig);                   // leave NULL if not implemented
} interface_plugin_ops;


/*
Typical sequence of events for a decoder plugin:
        - get_plugin_list is called to get the list of plugins in the imagefile
          (typically returns a single plugin_descriptor, but could return multiple)
        - plugin_descriptor::SupportedTypes is called to find the supported types and add them to the mime database
        - plugin_descriptor::Instantiate_Plugin is called to get a new decoder_plugin_ops
        if successful:
        - decoder_plugin_ops::Open is called to open the file
        - decoder_plugin_ops::Info is called to get information about the file
        - decoder_plugin_ops::Read is called to read data from the file   -OR-  decoder_plugin_ops::Play is called to start playback of a non data-producing file
        - decoder_plugin_ops::Seek/Position/etcetera get called multiple times during the playback
        - decoder_plugin_ops::Close is called to close the file
        - plugin_descriptor::Destroy_Plugin is called to free the plugin_ops structure
*/


/*
Typical sequence of events for a filter plugin:
        - get_plugin_list is called to get the list of plugins in the imagefile
          (typically returns a single plugin_descriptor, but could return multiple)
        - plugin_descriptor::Instantiate_Plugin is called to get a new filter_plugin_ops
        - filter_plugin_ops::SetConfig is called to set the configuration
        - filter_plugin_ops::Filter is called a number of times to filter buffers of data
        - plugin_descriptor::Destroy_Plugin is called to free the filter_plugin_ops structure
*/


// These are the "magic values" used to recognize structures
enum plugin_magic {
        PLUGIN_DESCRIPTOR_MAGIC='desc',
        PLUGIN_DECODER_MAGIC='inpt',
        PLUGIN_FILTER_MAGIC='filt',
        PLUGIN_VISUAL_MAGIC='visu',
        PLUGIN_INTERFACE_MAGIC='face',
        PLUGIN_PLAYLIST_MAGIC='edit'
};

// The current version of the structures
enum plugin_version {
        PLUGIN_DESCRIPTOR_VERSION=3,
        PLUGIN_DECODER_VERSION=3,
        PLUGIN_FILTER_VERSION=4,
        PLUGIN_VISUAL_VERSION=3,
        PLUGIN_INTERFACE_VERSION=4,
        PLUGIN_PLAYLIST_VERSION=4
};


// flags for the plugin descriptor structures
enum plugin_type {
        PLUGIN_IS_DECODER=1,
        PLUGIN_IS_FILTER=2,
        PLUGIN_IS_VISUAL=4,
        PLUGIN_IS_INTERFACE=16,                 // old interface (8) was dropped after 3.6
        PLUGIN_IS_SINGLE_CONTEXT=0x10000000
};

// The following are reported in file_info::flags
const uint64 PLUGIN_POSITION_IS_RELATIVE
                =0x0000000200000000LL;  // Seek() and Position() are not absolute positions, but
                                                                // relative to whatever the plugin reported as framecount.
                                                                // Setting this bit implies that playing backwards is not
                                                                                                                                                // possible.
const uint64 PLUGIN_REQUIRES_CONTIGUOUS_PHYSICAL_MEMORY 
                =0x0000000100000000LL;  // plugin cannot load into memory consisting of 
                                                                // multiple areas. Should only be needed by plugins that
                                                                // do DMA. Doesn't work well with relative positioning
                                                                // or granularity!=1

const uint64 PLUGIN_MINIMAL_BUFFERING
                =0x0000000400000000LL;  // do less read-ahead. Use this only for "realtime" data, e.g.
                                                                // data captured live from an audio input

const uint64 PLUGIN_FILELENGTH_UNKNOWN
                =0x0000000000000001LL;  // same as CL-Amp's INPLUG_NO_TOTTIME
const uint64 PLUGIN_NO_ELAPSEDTIME
                =0x0000000000000002LL;  // same as CL-Amp's INPLUG_NO_CURRTIME

#endif

Revision:	1.1
Committed:	2001-01-14T13:17:35Z (23 years, 3 months ago) by cebix
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	now also works as a SoundPlay plugin under BeOS
#	User	Rev	Content
1	cebix	1.1	/* ==================================================
2			SoundPlay plugin specification.
3			================================================== */
4
5			#ifndef _PLUGIN_PROTO_H
6			#define _PLUGIN_PROTO_H
7
8			#include <SupportDefs.h>
9			#include "Playlist.h"
10
11			/*
12			To let SoundPlay know which filetypes you support, you fill in an
13			array of these. SoundPlay will add both an uppercase and a lowercase
14			version of the extensions you specify to the mime database.
15			*/
16			typedef struct supported_type
17			{
18			char *mimetype;
19			char *longdesc;
20			char *shortdesc;
21			char *extension1;
22			char *extension2;
23			} supported_type;
24
25
26			/*
27			Operations that can be performed before the plugin is really active.
28			These functions globally affect and describe a plugin. They are
29			used to identify and configure the plugin, and to instantiate one
30			particular instance of the plugin.
31			All types of plugins are handled through this interface.
32			*/
33
34			class SoundPlayController;
35
36			typedef struct plugin_info
37			{
38			SoundPlayController *controller;
39			entry_ref *ref;
40			} plugin_info;
41
42			typedef void op_about();
43			typedef BView* op_configure(BMessage *config);
44			typedef void* op_instantiate(void *data, const char name, const char header, uint32 size, plugin_info pluginfo);
45			typedef void op_destroy(void plugin_ops, void data);
46
47			/* And this structure contains the above functions. */
48			typedef struct plugin_descriptor
49			{
50			// first some bookkeeping stuff
51			uint32 desc_magic; // magic number
52			uint32 desc_version; // version of this plugin structure
53
54			const char* id; // a unique string identifying your plugin
55			uint32 version; // distinguish between different version of the same plugin
56			uint32 flags; // PLUGIN_IS_DECODER, PLUGIN_IS_FILTER, PLUGIN_IS_VISUAL
57
58			const char* name; // MUST be filled in
59			const char* aboutstring; // Simple about string, in case you don't want to implement the About() function.
60
61			op_about (*About); // Leave NULL if not implemented
62			op_configure (*Configure); // Leave NULL if not implemented
63
64			op_instantiate (*Instantiate_Plugin); // MUST be implemented, instantiates all types of plugins, returns pointer to plugin struct (see below)
65			op_destroy (*Destroy_Plugin); // MUST be implemented, destroys the plugin created by Instantiate_Plugin()
66			} plugin_descriptor;
67
68
69			/*
70			Only these function need to be exported.
71			They return a pointer to an array of pointers to plugin_descriptor,
72			which lists all the plugins in this plugin-file, and a pointer to an
73			array of supportedtypes.
74			*/
75			extern "C" plugin_descriptor _EXPORT **get_plugin_list(void);
76			extern "C" supported_type _EXPORT *get_supported_types(void);
77
78
79			/*
80			These are the operations that can be performed on a particular instance
81			of a decoder-plugin, once it has been instantiated.
82			The void* that each function gets as the first argument is the data pointer
83			that was filled in by Instantiate_Plugin
84			*/
85
86			struct file_info;
87
88			typedef status_t op_decoder_open(void,const char name, const char header, uint32 size, BMessage config);
89			typedef void op_decoder_close(void*);
90			typedef status_t op_decoder_info(void,file_info);
91			typedef int32 op_decoder_read(void ,char buf, ulong count);
92			typedef status_t op_decoder_play(void*);
93			typedef status_t op_decoder_stop(void*);
94			typedef status_t op_decoder_setvolume(void*,float);
95			typedef status_t op_decoder_setspeed(void *,float speed);
96			typedef status_t op_decoder_seek(void*, uint32 pos);
97			typedef uint32 op_decoder_position(void*);
98			typedef float op_decoder_bufferamount(void*);
99
100			/*
101			The following structure contains pointers to the above
102			functions. Simply leave NULL if not implemented.
103			*/
104
105			typedef struct decoder_plugin_ops
106			{
107			// first some bookkeeping stuff
108			uint32 ops_magic; // magic number
109			uint32 ops_version; // version of this plugin structure
110
111			// and the function pointers.
112			op_decoder_open (*Open); // leave NULL if not implemented
113			op_decoder_close (*Close); // leave NULL if not implemented
114			op_decoder_info (*Info); // MUST be implemented
115
116			op_decoder_read (*Read); // leave NULL for input filters that don't produce data
117
118			op_decoder_play (*Play); // leave NULL if you do provide data
119			op_decoder_stop (*Stop); // leave NULL if you do provide data
120			op_decoder_setvolume (*SetVolume); // leave NULL if you do provide data
121			op_decoder_setspeed (*SetSpeed); // leave NULL if you do provide data
122			op_decoder_seek (*Seek); // leave NULL if seeking is not possible (streams)
123			op_decoder_position (*Position); // leave NULL if you can't provide position-info
124			op_decoder_bufferamount (*BufferAmount); // leave NULL if you don't want to display a buffer-indicator
125			} decoder_plugin_ops;
126
127
128			#define PLUGIN_STRING_LENGTH 256
129
130			typedef struct file_info
131			{
132			char name[PLUGIN_STRING_LENGTH]; // a nicer name for the file, zero-length if none
133			char typedesc[PLUGIN_STRING_LENGTH]; // a description of the file
134			char mimetype[PLUGIN_STRING_LENGTH]; // mimetype
135
136			float samplerate;
137			float bitrate;
138			uint32 numchannels;
139			uint32 granularity; // in frames
140			uint32 framecount;
141			uint32 samplesize;
142			int32 byteorder;
143			int32 sampleformat;
144
145			uint64 flags; // various flags
146			} file_info;
147
148
149			/*
150			These are the operations that can be performed on a particular instance
151			of a filter-plugin, once it has been instantiated.
152			The void* that each function gets as the first argument is the data pointer
153			that was filled in by Instantiate_Plugin
154			*/
155
156			typedef void op_filter_filechange(void, const char name, const char *path);
157			typedef status_t op_filter_filter(void, short buffer,int32 framecount, void *info);
158			typedef status_t op_filter_filter_float(void, float input, float output, int32 framecount, void info);
159			typedef BView* op_filter_configure(void*);
160			typedef void op_filter_setconfig(void,BMessage config);
161			typedef void op_filter_getconfig(void,BMessage config);
162
163			// The following structure contains pointers to the above
164			// functions. Simply leave NULL if not implemented.
165
166			typedef struct filter_plugin_ops
167			{
168			// first some bookkeeping stuff
169			uint32 ops_magic; // magic number
170			uint32 ops_version; // version of this plugin structure
171
172			// and the function pointers.
173			op_filter_filechange (*FileChange); // leave NULL if not implemented
174			op_filter_filter (*Filter); // filter a buffer of data, leave NULL if you implement FilterFloat
175			op_filter_configure (*Configure); // leave NULL if no run-time config
176			op_filter_setconfig (*SetConfig); // leave NULL if no run-time config
177			op_filter_getconfig (*GetConfig); // leave NULL if no run-time config
178			op_filter_filter_float (*FilterFloat); // filter floats, leave NULL if you implement Filter
179			} filter_plugin_ops;
180
181			// User Interface Plugin classes
182
183			enum {
184			FILTER_HOTKEYS = 1,
185			FILTER_REFS = 2
186			};
187
188			enum {
189			CONTROLLER_ADD = 'ct\0\1',
190			CONTROLLER_REMOVE = 'ct\0\2',
191			CONTROLLER_PLAYLISTEDITOR = 'ct\0\3'
192			};
193
194			class SoundPlayController
195			{
196			public:
197			int32 Version(); // soundplay version, encoded like this: X.Y.Z -> 0x000XYZ00
198			const char *VersionString(); // version as a string, e.g. "3.2"
199
200			void Quit(void);
201			void DisableInterface(const char *id);
202			void HideMainInterface(void);
203			void ShowMainInterface(void);
204			bool IsMainInterfaceHidden(void);
205
206			// You must lock the controller object before doing anything
207			// with its tracks, and unlock it afterwards
208			// Note that as long as you have a PlaylistPtr for a playlist,
209			// that playlist will remain valid. Its associated controls
210			// might go away (i.e. the playlist gets removed from the controller),
211			// but you can still work with the files in the playlist, or add it
212			// to the controller again.
213			void Lock(void);
214			void Unlock(void);
215			uint32 CountPlaylists(void);
216			PlaylistPtr PlaylistAt(uint32 index);
217			PlaylistPtr AddPlaylist(); // create a new playlist+controls
218			status_t AddPlaylist(PlaylistPtr playlist); // add an existing playlist to the controller
219			status_t RemovePlaylist(PlaylistPtr playlist);
220			void OpenEditor(PlaylistPtr playlist);
221
222			void AddWindow(BWindow*, int32 filterflags=FILTER_HOTKEYS\|FILTER_REFS); // tell SoundPlay about your window(s) so that SP can do some hotkey-management for it and accept dropped files
223			status_t AddListener(BHandler *handler);
224			status_t RemoveListener(BHandler *handler);
225
226			// plugins can use these functions to store and retrieve preferences as BMessages
227			status_t StorePreference(const char name, const BMessage message);
228			status_t RetrievePreference(const char name, BMessage message);
229
230			private:
231			#ifdef CONTROLLER_SECRET_INNER_WORKINGS
232			CONTROLLER_SECRET_INNER_WORKINGS
233			#endif
234			};
235
236
237			typedef status_t op_ui_show(void*);
238			typedef void op_ui_hide(void*);
239			typedef void op_ui_setconfig(void,BMessage config);
240			typedef void op_ui_getconfig(void,BMessage config);
241
242			// send a message with this constant to SoundPlay to enable
243			// an interface. Specify the interface by adding a string
244			// called "interface" containing the plugin-id to the message.
245			const uint32 ENABLE_INTERFACE= '!int';
246
247			typedef struct interface_plugin_ops
248			{
249			// first some bookkeeping stuff
250			uint32 ops_magic; // magic number
251			uint32 ops_version; // version of this plugin structure
252
253			op_ui_show (*Show);
254			op_ui_hide (*Hide);
255			op_ui_setconfig (*SetConfig); // leave NULL if not implemented
256			op_ui_getconfig (*GetConfig); // leave NULL if not implemented
257			} interface_plugin_ops;
258
259
260
261			/*
262			Typical sequence of events for a decoder plugin:
263			- get_plugin_list is called to get the list of plugins in the imagefile
264			(typically returns a single plugin_descriptor, but could return multiple)
265			- plugin_descriptor::SupportedTypes is called to find the supported types and add them to the mime database
266			- plugin_descriptor::Instantiate_Plugin is called to get a new decoder_plugin_ops
267			if successful:
268			- decoder_plugin_ops::Open is called to open the file
269			- decoder_plugin_ops::Info is called to get information about the file
270			- decoder_plugin_ops::Read is called to read data from the file -OR- decoder_plugin_ops::Play is called to start playback of a non data-producing file
271			- decoder_plugin_ops::Seek/Position/etcetera get called multiple times during the playback
272			- decoder_plugin_ops::Close is called to close the file
273			- plugin_descriptor::Destroy_Plugin is called to free the plugin_ops structure
274			*/
275
276
277			/*
278			Typical sequence of events for a filter plugin:
279			- get_plugin_list is called to get the list of plugins in the imagefile
280			(typically returns a single plugin_descriptor, but could return multiple)
281			- plugin_descriptor::Instantiate_Plugin is called to get a new filter_plugin_ops
282			- filter_plugin_ops::SetConfig is called to set the configuration
283			- filter_plugin_ops::Filter is called a number of times to filter buffers of data
284			- plugin_descriptor::Destroy_Plugin is called to free the filter_plugin_ops structure
285			*/
286
287
288			// These are the "magic values" used to recognize structures
289			enum plugin_magic {
290			PLUGIN_DESCRIPTOR_MAGIC='desc',
291			PLUGIN_DECODER_MAGIC='inpt',
292			PLUGIN_FILTER_MAGIC='filt',
293			PLUGIN_VISUAL_MAGIC='visu',
294			PLUGIN_INTERFACE_MAGIC='face',
295			PLUGIN_PLAYLIST_MAGIC='edit'
296			};
297
298			// The current version of the structures
299			enum plugin_version {
300			PLUGIN_DESCRIPTOR_VERSION=3,
301			PLUGIN_DECODER_VERSION=3,
302			PLUGIN_FILTER_VERSION=4,
303			PLUGIN_VISUAL_VERSION=3,
304			PLUGIN_INTERFACE_VERSION=4,
305			PLUGIN_PLAYLIST_VERSION=4
306			};
307
308
309			// flags for the plugin descriptor structures
310			enum plugin_type {
311			PLUGIN_IS_DECODER=1,
312			PLUGIN_IS_FILTER=2,
313			PLUGIN_IS_VISUAL=4,
314			PLUGIN_IS_INTERFACE=16, // old interface (8) was dropped after 3.6
315			PLUGIN_IS_SINGLE_CONTEXT=0x10000000
316			};
317
318			// The following are reported in file_info::flags
319			const uint64 PLUGIN_POSITION_IS_RELATIVE
320			=0x0000000200000000LL; // Seek() and Position() are not absolute positions, but
321			// relative to whatever the plugin reported as framecount.
322			// Setting this bit implies that playing backwards is not
323			// possible.
324			const uint64 PLUGIN_REQUIRES_CONTIGUOUS_PHYSICAL_MEMORY
325			=0x0000000100000000LL; // plugin cannot load into memory consisting of
326			// multiple areas. Should only be needed by plugins that
327			// do DMA. Doesn't work well with relative positioning
328			// or granularity!=1
329
330			const uint64 PLUGIN_MINIMAL_BUFFERING
331			=0x0000000400000000LL; // do less read-ahead. Use this only for "realtime" data, e.g.
332			// data captured live from an audio input
333
334			const uint64 PLUGIN_FILELENGTH_UNKNOWN
335			=0x0000000000000001LL; // same as CL-Amp's INPLUG_NO_TOTTIME
336			const uint64 PLUGIN_NO_ELAPSEDTIME
337			=0x0000000000000002LL; // same as CL-Amp's INPLUG_NO_CURRTIME
338
339			#endif
340