livido.h

Go to the documentation of this file.

/*
    Linux Dynamic Objects header

    This header should be included by filters and by host applications
    using them, in order to be able to use and implement video filters.
 */

#ifndef __LIVIDO_H__
#define __LIVIDO_H__

#include <inttypes.h>

#include <stdlib.h>


/*
  Process this file with doxygen to generate html documentation,
  or read thru it to explore the LiViDO API.
*/

#define LIVIDO_ID "$Id: livido.h 64 2004-11-14 22:53:21Z jaromil $"



#define LIVIDO_HEADER_VERSION 1


struct livido_instance_template;
typedef struct livido_instance_template livido_instance_template_t;

struct livido_channel_template;
typedef struct livido_channel_template livido_channel_template_t;

struct livido_channel;
typedef struct livido_channel livido_channel_t;

struct livido_parameter_template;
typedef struct livido_parameter_template livido_parameter_template_t;

struct livido_parameter;
typedef struct livido_parameter livido_parameter_t;

struct livido_frame;
typedef struct livido_frame livido_frame_t;

struct livido_instance;
typedef struct livido_instance livido_instance_t;



#define LIVIDO_PALETTE_RGB24               1
#define LIVIDO_PALETTE_RGB888              1
#define LIVIDO_PALETTE_RGB32               2
#define LIVIDO_PALETTE_RGBA8888            2
#define LIVIDO_PALETTE_RGB161616           3
#define LIVIDO_PALETTE_RGBA16161616        4
#define LIVIDO_PALETTE_YUV888              5
#define LIVIDO_PALETTE_YUVA8888            6
#define LIVIDO_PALETTE_YUV161616           7
#define LIVIDO_PALETTE_YUVA16161616        8
#define LIVIDO_PALETTE_YUV422P             9
#define LIVIDO_PALETTE_YUV420P             10
#define LIVIDO_PALETTE_YUV444P             11
#define LIVIDO_PALETTE_A8                  12
#define LIVIDO_PALETTE_A16                 13
#define LIVIDO_PALETTE_RGBFLOAT            14
#define LIVIDO_PALETTE_RGBAFLOAT           15
#define LIVIDO_PALETTE_AFLOAT              16
#define LIVIDO_PALETTE_BGR888              17
#define LIVIDO_PALETTE_YUYV8888            18
#define LIVIDO_PALETTE_UYVY8888            19
#define LIVIDO_PALETTE_RGB565              20
#define LIVIDO_PALETTE_RGBX8888            21
#define LIVIDO_PALETTE_A4                  22
#define LIVIDO_PALETTE_A2                  23
#define LIVIDO_PALETTE_A1                  24

#define  LIVIDO_PALETTE_FIRST_CUSTOM 2048


#define LIVIDO_PALETTE_END         (0x0)




#define LIVIDO_PALETTE_BITS(p) ( \
        (p == LIVIDO_PALETTE_RGBAFLOAT)    ?  128 : \
        (p == LIVIDO_PALETTE_RGBFLOAT)     ?  96  : \
        (p == LIVIDO_PALETTE_RGBA16161616) ||       \
        (p == LIVIDO_PALETTE_YUVA16161616) ?  64  : \
        (p == LIVIDO_PALETTE_RGB161616)    ||       \
        (p == LIVIDO_PALETTE_YUV161616)    ?  48  : \
        (p == LIVIDO_PALETTE_RGBA8888)     ||       \
        (p == LIVIDO_PALETTE_RGBX8888)     ||       \
        (p == LIVIDO_PALETTE_YUVA8888)     ||       \
        (p == LIVIDO_PALETTE_AFLOAT)       ||       \
        (p == LIVIDO_PALETTE_YUV444P)      ?  32  : \
        (p == LIVIDO_PALETTE_RGB888)       ||       \
        (p == LIVIDO_PALETTE_BGR888)       ||       \
        (p == LIVIDO_PALETTE_YUV888)       ?  24  : \
        (p == LIVIDO_PALETTE_YUV422P)      ||       \
        (p == LIVIDO_PALETTE_YUYV8888)     ||       \
        (p == LIVIDO_PALETTE_UYVY8888)     ||       \
        (p == LIVIDO_PALETTE_RGB565)       ||       \
        (p == LIVIDO_PALETTE_A16)          ?  16  : \
        (p == LIVIDO_PALETTE_YUV420P)      ?  12  : \
        (p == LIVIDO_PALETTE_A8)           ?  8   : \
        (p == LIVIDO_PALETTE_A4)           ?  4   : \
        (p == LIVIDO_PALETTE_A2)           ?  2   : \
        (p == LIVIDO_PALETTE_A1)           ?  1   : 0)


#define LIVIDO_PALETTE_IS_PLANAR(p) ( \
        (p == LIVIDO_PALETTE_YUV444P)      ||       \
        (p == LIVIDO_PALETTE_YUV422P)      ||       \
        (p == LIVIDO_PALETTE_YUV420P)      ?  1   : 0 )


#define LIVIDO_PALETTE_IS_CUSTOM(p) ( \
        (p&2048) ? 1 : 0 )





struct livido_channel_template {

  char *name; 

  int flags; 

  int *palettes; 

  int same_as; 


  int width;  
  int height; 

  struct livido_channel_template *next;

  char reserved[64]; 

};

#define LIVIDO_CHANNEL_OPTIONAL (1<<0)


#define LIVIDO_CHANNEL_MASK (1<<1)


#define LIVIDO_CHANNEL_SAME_AS_SIZE (1<<2)


#define LIVIDO_CHANNEL_SAME_AS_PALETTE (1<<3)


#define LIVIDO_CHANNEL_RESIZABLE (1<<4)


















typedef int (livido_init_f) (livido_instance_t*);

typedef int (livido_deinit_f) (livido_instance_t*);

typedef int (livido_process_f) (livido_instance_t*,
                                livido_frame_t*, livido_frame_t*);


#define LIVIDO_NO_ERROR                         0


#define LIVIDO_ERROR_TOO_MANY_INSTANCES         1


#define LIVIDO_ERROR_MEMORY_ALLOCATION          2


#define LIVIDO_ERROR_OOB_PARAMETERS             3


#define LIVIDO_ERROR_OOB_CHANNELS               4


#define LIVIDO_ERROR_PHERIPHERY                 5


#define LIVIDO_ERROR_INTERNAL                   6


#define LIVIDO_ERROR_AUXILIARY                  7


#define LIVIDO_ERROR_GET_PARAMETER              8


#define LIVIDO_ERROR_SET_PARAMETER              9















// parameters data types
#define LIVIDO_PARAM_SWITCH             0x10  
#define LIVIDO_PARAM_NUMBER             0x11  
#define LIVIDO_PARAM_RGBA32             0x13  
#define LIVIDO_PARAM_RGB24              0x14  
#define LIVIDO_PARAM_COORD2D            0x15  
#define LIVIDO_PARAM_STRING             0x16  
#define LIVIDO_PARAM_POINTER            0x17  
#define LIVIDO_PARAM_CUSTOM             0x18  




#define LIVIDO_PARAMETER_NEEDS_INIT (1<<0) 

#define LIVIDO_PARAMETER_INTERPOLATED (1<<1) 


struct livido_parameter_template {
  const char *name; 
  
  const char *description; 
  
  const char *format; 

  const int type; 

  const int flags; 

  const int decimals; 

  const char *list_values; 

  const char *def; 
  
  const double min; 
  const double max; 
  const double step; 


  const char *hint;        

  const void *extra; 

  struct livido_parameter_template* next;

  char reserved[64]; 
};


struct livido_parameter {

  struct livido_parameter_template *templ;

  char *value; 

  int flags;   

  void *extra; 
  
  struct livido_parameter *next;

  char reserved[64]; 
};



#include <stdio.h>
#include <stdarg.h>
#include <string.h>

int livido_set_parameter(livido_parameter_t *parameter, ...) {
  char tmp[1024];
  int len;
  va_list arg;
  int res;
  
  va_start(arg, parameter);
  
  res = vsnprintf(tmp, 1023, parameter->templ->format, arg);

  if(res<0) res = LIVIDO_ERROR_SET_PARAMETER;
  else {
    res = LIVIDO_NO_ERROR;
    if(parameter->value) free(parameter->value);

    len = strlen(tmp);
    parameter->value = calloc( len+1, sizeof(char) );
    strncpy(parameter->value, tmp, len);

  }

  va_end(arg);
  
  return res;
}

int livido_get_parameter(livido_parameter_t *parameter, ...) {
  va_list arg;
  const char *fmt;
  float *f;
  char *s;
  va_start(arg, parameter);

  fmt = parameter->templ->format;
  while (*fmt)
    switch(*fmt++) {
    case 's':           /* string */
      s = va_arg(arg, char *);
      sscanf(parameter->value, parameter->templ->format, s);
      //      fprintf(stderr,"get_parameter: string %s\n", s);
      break;
    case 'f':           /* int */
      f = va_arg(arg, float*);
      sscanf(parameter->value, parameter->templ->format, f);
      //      fprintf(stderr,"get_parameter: int %f\n", *f);
      break;
    }
  

  //  if(res == 0 || res == EOF) res = LIVIDO_ERROR_GET_PARAMETER;
  //  else res = LIVIDO_NO_ERROR;

  va_end(arg);

  return 0;
}









struct livido_instance_template {

  char *name; 
  char *author; 
  char *description; 

  int version; 

  int livido_api_version; 

  int flags;




  struct livido_parameter_template *in_parameter_templates;

  struct livido_parameter_template *out_parameter_templates;


  struct livido_channel_template *in_channel_templates;

  struct livido_channel_template *out_channel_templates;


  /* function pointers follow */
  livido_init_f                 *init;
  livido_deinit_f               *deinit;
  livido_process_f              *process;

  char *hints; 

  void *extra; 

  struct livido_instance_template *next;

  char reserved[64]; 
};


typedef struct livido_instance_template *(livido_setup_f) (void);


/*
  The flags that can be set in livido_instance_template::flags
  define aspects of the filter functioning, they are flags set by the
  plugin on the filter template, the host should always check them
  carefully (i.e: if(property&LIVIDO_PROPERTY_*)

*/

#define LIVIDO_PROPERTY_REALTIME (1<<0x0)


#define LIVIDO_PROPERTY_CAN_DO_INPLACE (1<<0x1)


#define LIVIDO_PROPERTY_TRANSITION (1<<0x2)


#define LIVIDO_PROPERTY_CAN_DO_SCALED (1<<0x3)


#define LIVIDO_PROPERTY_CAN_DO_WINDOWED (1<<0x4)



#define LIVIDO_PROPERTY_SELF_AUTOMATION (1<<0x5)


#define LIVIDO_PROPERTY_FPS_NEEDED (1<<0x6)


#define LIVIDO_PROPERTY_HOST_CAN_RESIZE (1<<0x7)


#define LIVIDO_PROPERTY_HOST_CAN_CHANGE_PALETTE (1<<0x8)


















struct livido_channel {

  struct livido_channel_template *templ;

  int flags; 

  int palette;

  int width; 
  int height; 

  int shift_h; 
  int shift_v; 

  int rowstrides[4]; 

  struct livido_channel *next;

  char reserved[64]; 
};


#define LIVIDO_CHANNEL_DISABLED (1<<0)










typedef double livido_timecode_t;

struct livido_frame {

  void *pixel_data[4];         
  
  struct livido_channel *channel;   

  livido_timecode_t timecode;

  void *extra;                 

  char reserved[64]; 
};












typedef void *(livido_malloc_f)(size_t); 
typedef void  (livido_free_f)(void*); 
typedef void *(livido_memcpy_f)(void*, const void*, size_t); 
typedef void *(livido_memset_f)(void*, int, size_t); 

typedef int (get_keyframe_cb)(void *ctx, livido_instance_t *instance, livido_parameter_t *p,
                              livido_timecode_t pos, livido_timecode_t keyframe );



struct livido_instance {
  
  struct livido_instance_template *templ;


  struct livido_channel *in_channels; 

  struct livido_channel *out_channels; 


  struct livido_parameter *in_parameters; 
  
  struct livido_parameter *out_parameters; 


  get_keyframe_cb *keyframe_next; 

  get_keyframe_cb *keyframe_prev; 

                                 
  float fps; 

  float scale_x; 
  float scale_y; 

  float window_x;  
  float window_y; 
  float window_w; 
  float window_h; 

  int threads; 


  livido_malloc_f *malloc; 
  livido_free_f   *free;   
  livido_memcpy_f *memcpy; 
  livido_memset_f *memset; 


  void *internal; 

  char *error; 

  char reserved[64]; 
};










#endif // __LIVIDO_H__

---