Gens MDP Plugins

MDP is currently a bit of a mess. I designed it so I could split out post-processing renderers from the main Gens/GS code base, then expanded it a bit to include some other stuff.

The headers are here: http://www.dusers.drexel.edu/gitweb/gitweb.cgi/~korth/gens.git/tree/HEAD:/src/mdp

Basically, an MDP plugin is a DLL (or shared library on Unix systems) that exports a single symbol: "mdp". This symbol is of type mdp_t, defined in mdp.h, and contains the following information:

Code (Text):

1.  
2. typedef struct PACKED _mdp_t
3. {
4.     // Plugin version information.
5.     const uint32_t interfaceVersion;
6.     const uint32_t pluginVersion;
7.  
8.     // CPU flags.
9.     const uint32_t cpuFlagsSupported;
10.     const uint32_t cpuFlagsRequired;
11.  
12.     // UUID - each plugin must have a unique ID.
13.     const unsigned char uuid[16];
14.  
15.     // Description.
16.     mdp_desc_t *desc;
17.  
18.     // Functions.
19.     mdp_func_t *func;
20. } mdp_t;
21.  

I'll probably rework this structure to make more sense in MDP v1.1 in an upcoming release of Gens/GS II (though retaining compatibility). Among other things, the uint32_t values shouldn't be marked const. Anyways, here's what each of these fields are:

• interfaceVersion: MDP interface version. The current version is 1.0, which is defined as MDP_VERSION(1,0,0) [or 0x01000000; use the macro]. The interface is designed such that minor version bumps are usually backwards-compatible, while major version bumps indicate the API has fundamentally changed. Plugins with a major interface version that doesn't match the emulator's version will not be loaded.
• pluginVersion: Plugin version. Indicates the version of your plugin. Use MDP_VERSION(major,minor,revision) here.
• cpuFlagsSupported: CPU flags supported by this plugin, e.g. MMX or SSE2. Flags are bitwise OR'd together and are defined in mdp_cpuflags.h.
• cpuFlagsRequired: CPU flags required by this plugin. Some renderers included with Gens/GS require MMX, so they have the MMX flag set here. The emulator will refuse to load a plugin if it has a required flag set that your CPU doesn't support.
• uuid: UUID uniquely identifying the plugin. Each plugin must have its own UUID, and the UUID should stay the same across plugin version updates.
• desc: Pointer to an mdp_desc_t struct.
• func: Pointer to an mdp_func_t struct.

mdp_desc_t is a struct describing the plugin:

Code (Text):

1.  
2. typedef struct PACKED _mdp_desc_t
3. {
4.     const char* name;
5.     const char* author_mdp;
6.     const char* author_orig;
7.     const char* description;
8.     const char* website;
9.     const char* license;
10.  
11.     /* Filler for alignment purposes. */
12.     const void* reserved1;
13.     const void* reserved2;
14.  
15.     /* Icon data. (PNG format) */
16.     const unsigned char* icon;
17.     const unsigned int iconLength;
18. } mdp_desc_t;
19.  

Fields:

• name: Name of the plugin.
• author_mdp: Author of the plugin, I.e. you.
• author_orig: Author of the original code provided by the plugin. This is typically used when packaging someone else's renderer in MDP format. May be NULL if the entire plugin was written by you.
• description: Description of the plugin.
• website: URL of the plugin's website.
• license: License, e.g. "GPL-2".
• icon: C array containing a PNG-format icon. (32x32)
• iconLength: Size of the icon array.

Finally, mdp_func_t:

Code (Text):

1.  
2. typedef int (MDP_FNCALL *mdp_init_fn)(const mdp_host_t *host_srv);
3. typedef int (MDP_FNCALL *mdp_end_fn)(void);
4.  
5. typedef struct PACKED _mdp_func_t
6. {
7.     // Init/Shutdown functions
8.     mdp_init_fn     init;
9.     mdp_end_fn      end;
10. } mdp_func_t;
11.  

Fields:

• init: Function to call when the plugin is loaded. A parameter containing an mdp_host_t struct is passed to this function. This struct, defined by mdp_host_t, contains function pointers that allow the plugin to register rendering plugins, read/write ROM data, and other things.
• end: Function to call when the plugin is unloaded.

Note that Gens/GS does not currently support dynamic loading of plugins, so init() is always called when the emulator is started, and end() is always called when the emulator is closed.

When I reimplement MDP in Gens/GS II, I'll work on improving the headers to remove some cruft, and I'll include some "sample" plugins that can be used as a starting point.

 

mdp_host_t has functions for reading and writing emulated memory blocks. Unfortunately, MDP 1.0 doesn't have SRAM defined, so you can't access it using an MDP plugin right now.

Some other memory spaces that are currently missing:
- VSRAM
- Sprite Attribute Table cache (probably not needed...)
- /TIME area (for SRAM control)
- TMSS registers

All of these will be added to MDP 1.1 sometime later.

 

The MDP interface is a bunch of headers. You basically need to add them to a project, then write some code that makes use of it.

You can read and write to the exposed memory. There's no watch functionality right now.

The Gens/GS r7+ code base does have plugin source included, but it's a bit of a mess right now.

MDP plugins are standard DLLs (or shared libraries on Linux). They have the same access to the host that the main program has.

 

I don't have any ready-to-use "example" projects for MDP right now. I'll consider making one when I reimplement MDP in Gens/GS II.

Incidentally, since you don't seem to know what a "project" is: Have you done any programming before, and if so, in what languages?