= Technical Specification = I forked this version of the spec on 19/08/05 because of some areas of disagreement with certain of the other developers. The specs were re-merged on 14/09/05 following some discussions. For now, this is the spec I will use in LiVES, until my doubts about the issues have been resolved. Note: the spec was remerged again on 3/10/05 Following this, Niels began making unauthorised, inconsistent changes. = Technical Specification = == LIVIDO FILTER == A livido_filter has 5 port sets: * 1 info port * 1 in_channels port array * 1 out_channels port array * 1 in_parameters port array * 1 out_parameters port array {{{ typedef struct livido_filter { livido_port_t *info; livido_port_t **in_channels; livido_port_t **out_channels; livido_port_t **in_parameters; livido_port_t **out_parameters; } livido_filter_t; }}} == PORTS == A port has a linked list of properties: {{{ typedef livido_property_t * livido_port_t; }}} Some properties are mandatory, some are optional.[[BR]] For each port type/port hint, there is a mandatory set of properties and an optional set of properties.[[BR]] Each port has a mandatory property "type". "type" can be one of: * LIVIDO_PORT_TYPE_FILTER_LIST : One or more filters in the plugin * LIVIDO_PORT_TYPE_INFO : Descriptive information about each filter * LIVIDO_PORT_TYPE_CHANNEL * LIVIDO_PORT_TYPE_PARAMETER * LIVIDO_PORT_TYPE_KEYFRAME : used in interpolate_func() [see below].[[BR]] * LIVIDO_PORT_TYPE_GUI : described in the livido GUI extension (TODO) Port type is a single valued property with atom_type LIVIDO_ATOM_TYPE_INT. The port_type is passed as a parameter in the livido_port_new function as {{{ livido_port_t *livido_port_new( int port_type ); }}} After intialization the "type" property should be set read-only by Plugin. == PROPERTIES == Each port is a linked list of properties A property has: * a key (which is a non-NULL string - (const char *)) * a value (which is a livido_storage) * a next_pointer to the next property in the list (or a NULL for the last property) {{{ typedef struct livido_property { const char *key; ///< unique type: min,max,value,step_size,page_size,decimals livido_storage_t *data; ///< either 1 atom or N atoms livido_property_t *next; } livido_property_t; }}} Some type/hint/property combinations can take only one type of atom. Others allow an initial choice for atom types.[[BR]] For example if the "value" property of a parameter port with LIVIDO_PORT_HINT_COLORKEY is set to take an atom_type of LIVIDO_ATOM_TYPE_INT, then the "min" and "max" properties of that port must also take a LIVIDO_ATOM_TYPE_INT atom_type.[[BR]] The livido_storage_t structure: {{{ struct livido_storage { int num_elements; ///< if its 1 or 0, it's an ATOM, otherwise its an ARRAY int atom_type; union { livido_atom_t *atom; // NULL if num_elements==0 livido_atom_t **array; } data; int flags; }; }}} The union "data" contains an atom * if number of elements == 1 otherwise it containts a atom **[[BR]] Number_of_elements can be set to 0, in which case this will hold a NULL pointer. This is useful for plugins which want to set the atom_type of a property without setting its value explicitly. [[BR]] "flags" is a bit field. One bit represents "read-only", and it can be set/cleared at any time. [[BR]] The livido library functions to set properties will check the state of the "read-only" bit, and if it is set then the function will return an error code and not change the parameter value.[[BR]] By convention, once the atom_type of a property is set, the atom_type of that property is constant for the life of that port.[[BR]] == LIVIDO ATOMS == The Atoms in livido represent the fundemental types in the system. This is the lowest level of data in livido, and one or more of these are used in a livido_storage for providing a generic mechanism to store and retrieve runtime data. A livido_atom has: * a type id int * a size of type size_t * a void * value {{{ typedef struct livido_atom { int type; size_t size; void *value; } livido_atom_t; }}} LiViDO offers the following fundemental types:[[BR]] * LIVIDO_ATOM_TYPE_INT * LIVIDO_ATOM_TYPE_FLOAT * LIVIDO_ATOM_TYPE_LONG * LIVIDO_ATOM_TYPE_BOOLEAN * LIVIDO_ATOM_TYPE_STRING Pointer types: * LIVIDO_ATOM_TYPE_VOIDPTR * LIVIDO_ATOM_TYPE_UINT8PTR * LIVIDO_ATOM_TYPE_INT8PTR * LIVIDO_ATOM_TYPE_UINT16PTR * LIVIDO_ATOM_TYPE_INT16PTR * LIVIDO_ATOM_TYPE_UINT32PTR * LIVIDO_ATOM_TYPE_INT32PTR * LIVIDO_ATOM_TYPE_FLOATPTR * LIVIDO_ATOM_TYPE_FILTERPTR : livido_filter_t* * LIVIDO_ATOM_TYPE_PORTPTR : livido_port_t * [[BR]] Mandatory functions for a plugin to implement:[[BR]] * typedef int process_func( livido_filter_t *filter ); * typedef int init_func( livido_filter_t *filter ); * typedef int deinit_func( livido_filter_t *filter ); [[BR]] === PORT TYPE FILTER LIST === * "type" == LIVIDO_PORT_TYPE_FILTER_LIST Optional properties:[[BR]] * "maintainer" : LIVIDO_ATOM_TYPE_STRING : maintainer of plugin package * "url" : LIVIDO_ATOM_TYPE_STRING : URL of plugin package * "license" : LIVIDO_ATOM_TYPE_STRING : license of plugin package * "version" : LIVIDO_ATOM_TYPE_STRING : package version Required properties:[[BR]] * "filters" : LIVIDO_ATOM_TYPE_FILTERPTR : atom or array of livido_filter_t === PORT TYPE INFO === "type" == LIVIDO_PORT_TYPE_INFO Mandatory properties: [[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING : the filter name * "author" : LIVIDO_ATOM_TYPE_STRING * "version" : LIVIDO_ATOM_TYPE_INT : filter verison * "api_version" : LIVIDO_ATOM_TYPE_INT : livido api verison * "license" : LIVIDO_ATOM_TYPE_STRING : license of filter * "flags" : LIVIDO_ATOM_TYPE_INT : bitmap of instance_flags * "init_func" : LIVIDO_ATOM_TYPE_INIT_FUNC : pointer to a livido_init_f * "process_func" : LIVIDO_ATOM_TYPE_PROCESS_FUNC : pointer to a livido_process_f * "deinit_func" : LIVIDO_ATOM_TYPE_DEINIT_FUNC : pointer to a livido_deinit_f * "num_in_channels" : LIVIDO_ATOM_TYPE_INT : total number of input channel * "num_out_channels" : LIVIDO_ATOM_TYPE_INT : total number of output channels * "num_in_parameters" : LIVIDO_ATOM_TYPE_INT : total number of input parameters * "num_out_parameters" : LIVIDO_ATOM_TYPE_INT : total number of output parameters Optional properties: [[BR]] * "description" : LIVIDO_ATOM_TYPE_STRING : filter description * "url" : LIVIDO_ATOM_TYPE_STRING * "scale_x" : LIVIDO_ATOM_TYPE_FLOAT : * "scale_y" : LIVIDO_ATOM_TYPE_FLOAT : * "num_threads" : LIVIDO_ATOM_TYPE_INT : (==1 if not present) * "fps" : LIVIDO_ATOM_TYPE_FLOAT : plugin can set this in the setup function if it requires fixed FPS. * "internal" : LIVIDO_ATOM_TYPE_VOIDPTR : the plugin can set this in its init() function to store internal data. The plugin should free() it in its deinit() function. === PORT TYPE CHANNEL === * "type" == LIVIDO_PORT_TYPE_CHANNEL Mandatory properties: [[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING : name of the channel * "flags" : LIVIDO_ATOM_TYPE_INT : bitmap of channel_flags * "timecode" : LIVIDO_ATOM_TYPE_LONG : absolute timecode Mandatory properties for a video channel:[[BR]] * "width" : LIVIDO_ATOM_TYPE_INT : frame width in pixels, plugin can set this in setup() to a non-zero value (zero means any) * "height" : LIVIDO_ATOM_TYPE_INT : frame height in pixels, plugin can set this in setup() to a non-zero value (zero means any) * "palette_list" : LIVIDO_ATOM_TYPE_INT : the plugin sets this to an array of allowed palettes for the channel. Its order is plugin's preference for a palette * "current_palette" : LIVIDO_ATOM_TYPE_INT: the host sets this to the chosen palette, which must be one of the palettes contained in "palette_list". * "pixel_data" : LIVIDO_ATOM_TYPE_*PTR : number of elements varies depending on "current_palette" * "rowstrides" : LIVIDO_ATOM_TYPE_INT : length of one row in bytes (include padding) : same number of elements as "pixel_data" Optional properties: [[BR]] * "description" : LIVIDO_ATOM_TYPE_STRING : description of this channel * "viewport" : LIVIDO_ATOM_TYPE_INT or FLOAT : Area on image to be used for drawing (Unit: pixels (screencoordinates). Y axis points down * "v_shift" : LIVIDO_ATOM_TYPE_INT : used for YUV planar * "h_shift" : LIVIDO_ATOM_TYPE_INT : used for YUV planar * "interlacing" : LIVIDO_ATOM_TYPE_INT : Progressive,None (default) ,Topfirst,Bot.first - if not present, the image must be NON INTERLACED * "fps" : LIVIDO_ATOM_TYPE_FLOAT * "same_as_size" : LIVIDO_ATOM_TYPE_PORTPTR : plugin can set this to indicate that this channel must match height/width with another channel. The pointer points to another in/out channel. * "same_as_palette" : LIVIDO_ATOM_TYPE_PORTPTR : plugin can set this to indicate that this channel must match current_palette with another channel. The pointer points to another in/out channel. * "disabled" : LIVIDO_ATOM_TYPE_BOOLEAN : the plugin may set this to TRUE in setup(), host may set its value to FALSE before calling init(). TODO:[[BR]] * Audio channel : This will be described in the Livido Audio Extension. === PORT TYPE PARAMETER === The parameter port is used for a filter's parameters. All parameter ports can have the optional properties: * interpolate_func : LIVIDO_ATOM_TYPE_INTERPOLATE_FUNC * num_points : LIVIDO_ATOM_TYPE_INT : Number of in_keyframes desired by the plugin in interpolate_func, either side of the calculated value. A zero means "send as many as possible". * changed : LIVIDO_ATOM_TYPE_BOOLEAN : Empty property. Plugin sets this if it changes a parameter "value" during process(). In this case the plugin should also have set the filter flag LIVIDO_PROPERTY_SELF_ANIMATION. * flags : LIVIDO_ATOM_TYPE_INT : Plugin sets this to LIVIDO_PARAMETER_NEEDS_REINIT if a change in the "value" of this parameter requires the host to call deinit()/init() again. * description : LIVIDO_ATOM_TYPE_STRING : utf-8 description * disabled : LIVIDO_ATOM_TYPE_BOOLEAN : indicates that the parameter is not used * label : LIVIDO_ATOM_TYPE_STRING : (utf-8) label to display for the parameter. * use_mnemonic : LIVIDO_ATOM_TYPE_BOOLEAN : if set to TRUE, then a utf-8 underscore in the "label" should be considered to mark a mnemonic accelerator ==== Property PORT HINT ==== Ports of type parameter also have an optional property, "hint". This is a single valued property with atom_type LIVIDO_ATOM_TYPE_INT. Each hint defines a set of properties for commonly used parameter types. "hint" may be one of:[[BR]] * NUMBER * TEXT * SWITCH * LIST * CHOICE * COLORKEY * COORDINATE[[BR]] If property "hint" is not set, the atom type denotes the type of the parameter. The other mandatory and optional properties for each type/hint are shown below. ==== PARAMETER PORTHINT NUMBER ==== * "type" = LIVIDO_PORT_TYPE_PARAMETER * "hint" = NUMBER Mandatory properties: [[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT * "min" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT * "max" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT Optional properties: [[BR]] * "decimals" : LIVIDO_ATOM_TYPE_INT : this property is mandatory if the atom_type of "value" is LIVIDO_ATOM_TYPE_FLOAT * "step_size" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT * "page_size" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT * "wrap" : LIVIDO_ATOM_TYPE_BOOLEAN : indicates whether values wrap-around min->max/max->min [[BR]] [[BR]] ==== PARAMETER PORTHINT TEXT ==== * "type" == LIVIDO_PORT_TYPE_PARAMETER * "hint" == TEXT Mandatory properties: [[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_STRING Optional properties: [[BR]] * "max_length" : LIVIDO_ATOM_TYPE_INT [[BR]] [[BR]] ==== PARAMETER PORTHINT COLORKEY ==== * "type" = LIVIDO_PORT_TYPE_PARAMETER * "hint" = COLORKEY Mandatory properties: [[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT or LIVIDO_ATOM_TYPE_STRING : multivalued * "min" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT or LIVIDO_ATOM_TYPE_STRING * "max" : LIVIDO_ATOM_TYPE_INT or LIVIDO_ATOM_TYPE_FLOAT or LIVIDO_ATOM_TYPE_STRING * "colorspace": LIVIDO_ATOM_TYPE_INT. Possible values are listed below. Optional properties: [[BR]] * "decimals" : LIVIDO_ATOM_TYPE_INT : this property is mandatory if the atom_type of "value" is LIVIDO_ATOM_TYPE_FLOAT [[BR]] [[BR]] ==== PARAMETER PORTHINT (CHOICE, LIST) ==== * "type" == LIVIDO_PORT_PARAMETER * "hint" == LIST or CHOICE Mandatory properties: * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_* : array of n values. Can only be one of Livido's fundemental non-pointer types. Optional properties: * "index" : LIVIDO_ATOM_TYPE_INT : current selected index in list. The list of values is 0 based. (List used as Choice/Pulldown) [[BR]] [[BR]] ==== PARAMETER PORTHINT TRANSITION ==== * "type" = LIVIDO_PORT_PARAMETER * "hint" = TRANSITION Mandatory properties:[[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_FLOAT : This is a float value with min 0.0 and max 1.0. When all transition parameters in a filter are at 0.0 the transition is off. When all are at 1.0 the transition is on (finished). Optional properties: "group" : LIVIDO_ATOM_TYPE_INT : if >1 transition parameters in a filter are in the same group, only one in that group needs to be at 1.0 for the transtion to be complete. [[BR]] ==== PARAMETER PORTHINT SWITCH ==== * "type" = LIVIDO_PORT_PARAMETER * "hint" = SWITCH Optional properties:[[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_BOOLEAN [[BR]] [[BR]] ==== PARAMETER PORTHINT COORDINATE ==== * "type" = LIVIDO_PORT_PARAMETER * "hint" = COORDINATE Mandatory properties:[[BR]] * "name" : LIVIDO_ATOM_TYPE_STRING * "value" : LIVIDO_ATOM_TYPE_FLOAT or LIVIDO_ATOM_TYPE_INT * "min" : LIVIDO_ATOM_TYPE_FLOAT or LIVIDO_ATOM_TYPE_INT * "max" : LIVIDO_ATOM_TYPE_FLOAT or LIVIDO_ATOM_TYPE_INT Optional properties:[[BR]] * "geometry" : LIVIDO_ATOM_TYPE_STRING (e.g. "cartesian", "logarithm", "polar") : "cartesian" assumed if not set [[BR]] [[BR]] ==== PARAMETER PORT KEYFRAME ==== Keyframe ports are used in interpolate_func() to allow plugins to do complex interpolation of paramters. Mandatory properties:[[BR]] * timecode : LIVIDO_ATOM_TYPE_LONG : timecode that the "value" corresponds to * value : LIVIDO_ATOM_TYPE_* : value of the parameter at timecode. interpolate_func is an optional property of a parameter. Its template is: {{{ int interpolate_func (livido_port_t **in_keyframes, livido_port_t *out_keyframe, livido_port_t *parameter); }}} The host fills in_keyframes with a NULL terminated array of in keyframes, sets "timecode" of out_keyframe, and then calls the interpolate_func(). Plugin sets "value" in out_keyframes. == LIVIDO PLUGIN == {{{ int init_func(livido_filter_t *) }}} The host calls this and passes back the desired filter (or a copy of it), with some values changed. Prior to this, the host can change the "value" property of parameters. It returns an int livido error code. The init function allows the plugin to create any internal memory structures it needs; these can be referred to in the info port, property "internal" which takes a void * atom_type. The host must also attend to "disabled" in the channel ports, and set the "current_palette" property in the channel ports, and set the channel sizes, "width" and "height". {{{ int process_func(livido_filter_t *) }}} host calls this for each processing cycle; the plugin can do its frame processing here. {{{ int deinit_func(livido_filter_t *) }}} host calls this allow the plugin to free any internal memory held in the info port "internal" property. Following this the host may free the livido_filter. The plugin does not need to free any ports or paramters, the host should take care of this. [[BR]] == Getting/setting values == The plugin programmer does not need to worry about allocating and freeing memory for the data to store. The model (or more precisely the Mediation layer) will take care of that for you. If you store an object the model will make a copy and store that. Later, when you set a new value in this object the model will automatically free the old value and make a copy of the new value and store the the copy. The exception to this note is any atom type of type PTR. If you allocate a chunk of data or a complex structure only the pointer value is stored (!). The model does not know anything about the size or content of the data your pointer refers to so it wil not make a copy. Instead, you need to allocate and free the memory yourself in this case. The plugin programmer can use the property 'internal' to store the pointer to its internal (complex) data structure. The plugin and host programmer can both retrieve and set values by Key. On get_value Livido will return a copy of the value in the property, except for pointer types. For pointer types only the reference to the memory block is returned. This prevents unnecessary memcopy()s (e.g. when getting address of "pixel_data".) On set_value, the (previously) allocated property will be destroyed and a new one is allocated and set; host should care of discarding all references to the old value. Except for pointer types, where only the reference is stored. For setting pointer types, host/plugin must pass in a size_t array with the atom sizes. == LIVIDO SETUP == Each plugin must implement the function: {{{ livido_port_t *livido_setup(void); }}} This function returns a FILTER_LIST port with a filter or filters The FILTER_LIST port is created by the plugin using livido_port_new() == LIVIDO FUNCTION OVERVIEW == LOW LEVEL (Internal only):[[BR]] * livido_atom_t *livido_atom_new () - only used internally by livido * void livido_atom_free () - only used internally by livido MEDIATION LEVEL (Internal only):[[BR]] * livido_storage_t *livido_storage_new() * void livido_storage_free() - only used internally by livido HIGH LEVEL (Host and Plugin): [[BR]] * livido_port_t *livido_port_new (int port_type) * void livido_port_free (livido_port_t *port) * char **livido_list_properties (livido_port_t *port) * livido_property_t *livido_property_new (livido_port_t *port, const char *key, int atom_type); . * void livido_property_free (livido_property_t *property); * int livido_property_set (livido_port_t *port, const char *key, int atom_type, int num_elems, void *value , size_t *sizes) * int livido_property_get (livido_port_t *port, const char *key, int idx, void *value) * int livido_property_num_elements (livido_port_t *port, const char *key) * int livido_property_get_element_size (livido_port_t *port, const char *key, int idx) * int livido_property_get_atom_type(livido_port_t *port, const char *key) * int livido_set_readonly (livido_property_t *property) * int livido_get_readonly (livido_property_t *property) Low level and mediation level functions should never be called directly by host/plugin. livido_property_new() can be called with the port set to NULL. With a NULL port, it will return a "standalone" property (not part of any port). This can be used by the host to backup/restore parameter "value"s, etc. livido_property_set() will call livido_property_new() to create the property if the property does not exist. For livido_property_set(), num_elems can be 0 and value can then be NULL. In this way, just the atom_type of the property can be set. livido_property_get() will return LIVIDO_ERROR_NOSUCH_PROPERTY if a property does not exist. In this way the existence of a property can be determined. == LIVIDO PROCESS FLOW OVERVIEW == * Host loads plugin * Host calls the livido_setup() function. * For each filter in the plugin, the plugin creates the livido_filter, initialises an info port, an array of in_channel ports, an array of out_channel ports, an array of in_parameter ports and an array of out_parameter ports and stores the resulting filter_t in the port 'Filter'. * Host examines the in_channel and out_channel ports, and clears the "disabled" flag for any optional channels it wishes to use. It also checks "palette_list", selects a palette it would like to start using on that channel and sets the chosen value in the "current_palette" property. It also sets the sizes ("width" and "height" properties) if the plugin left them as zero. * Host can change "value" for any non-disabled in_parameter, thus overriding the plugin's default. * Host calls init() in the plugin, passing in a filter it would like to use. * Plugin now knows the channel sizes, palettes and which are in use, and can check if the plugin has changed any parameter "value" properties. The plugin may now malloc internal data if it wishes and set a pointer to this in the info port property "internal" * Host may now change parameter values (respecting "max" and "min" properties) and it after that it may call process() in the plugin, passing in the initialised filter. * When the host has finished with the filter, or if it needs to re-initialise it, the host must call deinit() in the plugin, passing in the filter. The plugin can now free any internal data which it allocated. * Host can now either free the filter, or re-initialise it by calling init() in the plugin again. Note: host can optionally copy the filter returned from livido_setup to create a new instance before calling init(). The instance should be free()d by the host after it calls deinit(), or may be reused. == Livido Palettes == TODO: Consider using 'bits per pixel' property and documentation of signed/unsignedness of pixel format instead of using this clumpsy list of colorspaces. To be updated by Niels. * LIVIDO_PALETTE_RGB24 * LIVIDO_PALETTE_RGB888 * LIVIDO_PALETTE_RGB32 * LIVIDO_PALETTE_RGBA8888 * LIVIDO_PALETTE_RGB161616 * LIVIDO_PALETTE_RGBA16161616 * LIVIDO_PALETTE_YUV888 * LIVIDO_PALETTE_YUVA8888 * LIVIDO_PALETTE_YUV161616 * LIVIDO_PALETTE_YUVA16161616 * LIVIDO_PALETTE_YUV422P * LIVIDO_PALETTE_YUV420P * LIVIDO_PALETTE_YUV444P * LIVIDO_PALETTE_RGBFLOAT * LIVIDO_PALETTE_RGBAFLOAT * LIVIDO_PALETTE_BGR888 * LIVIDO_PALETTE_YUYV8888 * LIVIDO_PALETTE_UYVY8888 * LIVIDO_PALETTE_RGB565 * LIVIDO_PALETTE_RGBX8888 * LIVIDO_PALETTE_A4 * LIVIDO_PALETTE_A2 * LIVIDO_PALETTE_A1 * LIVIDO_PALETTE_A8 * LIVIDO_PALETTE_A16 * LIVIDO_PALETTE_AFLOAT == Livido flags and types == ==== Filter flags ==== * LIVIDO_FILTER_NON_REALTIME[[BR]] non-realtime filter property * LIVIDO_FILTER_CAN_DO_INPLACE[[BR]] If this property is set, the filter can do inplace operations. Hosts can select this mode by setting "pixel_data" for the first out_channel to NULL. Plugin will then return the output in "pixel_data" of the first in_channel. This can save a memcpy() in the host. * LIVIDO_FILTER_CAN_DO_SCALED[[BR]] The plugin knows how to scale the parameters when drawing previews/thumbnails. Host can use scale_x and scale_y in this case. * LIVIDO_FILTER_CAN_DO_VIEWPORT[[BR]] Host may use the "viewport" property of channels to define a polygon in which the effect should be applied. * LIVIDO_FILTER_SELF_AUTOMATION[[BR]] plugin can self-animate - it may change parameter "value"s during process(); all other plugins may only change "value"s during init() The plugin sets the property "changed" to TRUE in a parameter port after changing a ports' value. * LIVIDO_FILTER_FPS_NEEDED[[BR]] The plugin absolutely needs frames_per_second information, don't try to use it without * LIVIDO_FILTER_STATELESS[[BR]] plugin is stateless ; it has no information about what occured previously. ==== Channel flags ==== * LIVIDO_CHANNEL_MASK[[BR]] tell host that channel is a mask * LIVIDO_CHANNEL_HOST_CAN_RESIZE[[BR]] tell *host* that this channel can be resized without calling deinit/init, SAME_AS rules must still be followed * LIVIDO_CHANNEL_HOST_CAN_CHANGE_PALETTE[[BR]] tell *host* that current_palette can be changed for this channel without calling deinit/init, SAME_AS rules must still be followed ==== Parameter flags ==== * LIVIDO_PARAMETER_NEEDS_REINIT[[BR]] set by plugin: host needs to re-init the filter after changing the "value" property of this parameter. ==== Property flags ==== * LIVIDO_PROPERTY_READONLY ==== Interlace types ==== * LIVIDO_INTERLACE_NONE * LIVIDO_INTERLACE_TOPFIRST * LIVIDO_INTERLACE_BOTTOMFIRST * LIVIDO_INTERLACE_PROGRESSIVE ==== Colorkey colorspaces ==== * LIVIDO_COLORKEY_RGB * LIVIDO_COLORKEY_HSV * LIVIDO_COLORKEY_HSL * LIVIDO_COLORKEY_CMYK == Livido errors == * LIVIDO_NO_ERROR[[BR]] return code means no problem * LIVIDO_ERROR_TOO_MANY_INSTANCES[[BR]] can't create: plugin allows only limited number of filter instances, returned from init() * LIVIDO_ERROR_MEMORY_ALLOCATION[[BR]] memory allocation by the filter has failed * LIVIDO_ERROR_PROPERTY_READONLY[[BR]] plugin/host tried to set readonly property; returned from livido_property_set() * LIVIDO_ERROR_WRONG_ELEMENTS[[BR]] plugin/host tried to read value or size of an invalid element number in a storage * LIVIDO_ERROR_NOSUCH_PROPERTY[[BR]] property does not exist for the specified port; returned from livido_property_get() * LIVIDO_ERROR_HARDWARE[[BR]] there was an error initialising hardware for the filter; returned from livido_setup() or init() For utility functions: * LIVIDO_ERROR_WRONG_ATOM_TYPE[[BR]] mismatch between atom/storage type