enum unicap_buffer_type_t

typedef enum
{
	UNICAP_BUFFER_TYPE_USER = 0, 
	UNICAP_BUFFER_TYPE_SYSTEM,
} unicap_buffer_type_t;

struct unicap_device_t

struct unicap_device_t {
	char identifier[128];
	char model_name[128];
	char vendor_name[128];
		
	unsigned long long model_id;
	unsigned int vendor_id;
	
	char cpi_layer[1024];
	char device[1024];
		
	unsigned int flags;
};

struct unicap_rect_t

struct unicap_rect_t {
	int x;
	int y;	
	int width;
	int height;
};

A struct defining a rectangle

struct unicap_format_t

struct unicap_format_t {
      char identifier[128];
      
      // default
      unicap_rect_t size;
      
      // min and max extends
      unicap_rect_t min_size;
      unicap_rect_t max_size;
      
      // stepping: 
      // 0 if no free scaling available
      int h_stepping;
      int v_stepping;
      // array of possible sizes
      unicap_rect_t *sizes;
      int size_count;
      
      int bpp;
      unsigned int fourcc;
      unsigned int flags;

      unsigned int buffer_types; // available buffer types
      int system_buffer_count;

      size_t buffer_size;

      unicap_buffer_type_t buffer_type;
};

struct unicap_data_buffer_t

struct unicap_data_buffer_t {
      unicap_format_t format;
      
      int frame_number;
      struct timeval fill_time; //
      struct timeval duration;
      struct timeval capture_start_time;// optional, time of first copy action of image data of this frame
      
      unsigned char *data;
      size_t buffer_size;	

      unicap_buffer_type_t type; // system pointers or user pointers

      unicap_buffer_flags_t flags;
      unsigned int reserved[7];		
};

struct unicap_property_range_t

struct unicap_property_range_t {
	double min;
	double max;
};

struct unicap_property_value_list_t

struct unicap_property_value_list_t {
	double *values;
	int value_count;	
};

struct unicap_property_menu_t

struct unicap_property_menu_t {
	char **menu_items;
	int menu_item_count;
};

enum unicap_property_type_enum_t

typedef enum 
{
	UNICAP_PROPERTY_TYPE_RANGE = 0,
	UNICAP_PROPERTY_TYPE_VALUE_LIST,
	UNICAP_PROPERTY_TYPE_MENU,
	UNICAP_PROPERTY_TYPE_DATA,
	UNICAP_PROPERTY_TYPE_FLAGS, 

	UNICAP_PROPERTY_TYPE_UNKNOWN
} unicap_property_type_enum_t;

struct unicap_property_t

struct unicap_property_t {
      char identifier[128]; //mandatory
      char category[128];
      char unit[128]; // 
      
      // list of properties identifier which value / behaviour may change if this property changes
      char **relations;
      int relations_count;	
      
      union
      {
	    double value; // default if enumerated
	    char menu_item[128]; 
};

FIXME: gtk-doc fails to parse structs with anonymous unions.

      char identifier[128]; //mandatory
      char category[128];
      char unit[128]; // 
      
      // list of properties identifier which value / behaviour may change if this property changes
      char **relations;
      int relations_count;	
      
      union
      {
	    double value; // default if enumerated
	    char menu_item[128]; };
      
      
      union{	
	    unicap_property_range_t range; // if UNICAP_USE_RANGE is asserted
	    unicap_property_value_list_t value_list; // if UNICAP_USE_VALUE_LIST is asserted
	    unicap_property_menu_t menu; };
	    
      
      double stepping;
      
      unicap_property_type_enum_t type;	
      u_int64_t flags;        // defaults if enumerated
      u_int64_t flags_mask;	// defines capabilities if enumerated
      
      // optional data
      void *property_data; 
      size_t property_data_size;	


identifier:   unique textual identifier of this properties
category:     a category for this property, for example: 'Lens Control' for zoom and focus properties
unit:         optional unit, for example: 's' for Exposure
denoting the Exposure time in seconds
relations:    properties that might their state or value when
changing this property
relations_count: size of the relations array
value:           for UNICAP_PROPERTY_TYPE_RANGE and
UNICAP_PROPERTY_TYPE_VALUE_LIST properties: current value
menu_item:       for UNICAP_PROPERTY_TYPE_MENU properties: selected menu entry
range:           for UNICAP_PROPERTY_TYPE_RANGE properties: valid range for value
value_list:      for UNICAP_PROPERTY_TYPE_VALUE_LIST properties: list
of valid values
menu:            for UNICAP_PROPERTY_TYPE_MENU properties: menu
stepping:        for UNICAP_PROPERTY_TYPE_RANGE properties: stepping 
type: 
flags: 
flags_mask:
property_data:
property_data_size:
 

enum unicap_event_t

typedef enum 
{
	UNICAP_EVENT_FIRST = 0,
	UNICAP_EVENT_DEVICE_REMOVED = 0, 
	UNICAP_EVENT_NEW_DEVICE,
	UNICAP_EVENT_NEW_FRAME, 
	UNICAP_EVENT_DROP_FRAME, 
	UNICAP_EVENT_LAST
} unicap_event_t;

UNICAP_FLAGS_MANUAL

#define UNICAP_FLAGS_MANUAL    (1ULL)

UNICAP_FLAGS_AUTO

#define UNICAP_FLAGS_AUTO      (1ULL<<1ULL)

UNICAP_FLAGS_ONE_PUSH

#define UNICAP_FLAGS_ONE_PUSH  (1ULL<<2ULL)

UNICAP_FLAGS_READ_OUT

#define UNICAP_FLAGS_READ_OUT  (1ULL<<3ULL)

UNICAP_FLAGS_ON_OFF

#define UNICAP_FLAGS_ON_OFF    (1ULL<<4ULL)

UNICAP_FLAGS_READ_ONLY

#define UNICAP_FLAGS_READ_ONLY (1ULL<<5ULL)

UNICAP_FLAGS_FORMAT_CHANGE

#define UNICAP_FLAGS_FORMAT_CHANGE (1ULL<<6ULL)

unicap_callback_t ()

void                (*unicap_callback_t)                (unicap_event_t event,
                                                         ...);

unicap_new_frame_callback_t ()

void                (*unicap_new_frame_callback_t)      (unicap_event_t event,
                                                         unicap_handle_t handle,
                                                         unicap_data_buffer_t *buffer,
                                                         void *user_ptr);

unicap_drop_frame_callback_t ()

void                (*unicap_drop_frame_callback_t)     (unicap_event_t event,
                                                         unicap_handle_t handle,
                                                         void *user_ptr);

unicap_new_device_callback_t ()

void                (*unicap_new_device_callback_t)     (unicap_event_t event,
                                                         unicap_device_t *device,
                                                         void *user_ptr);

unicap_check_version ()

unicap_status_t     unicap_check_version                (unsigned int major,
                                                         unsigned int minor,
                                                         unsigned int micro);

Checks that the unicap library version is compatible with given version

unicap_reenumerate_devices ()

unicap_status_t     unicap_reenumerate_devices          (int *count);

Rebuild internal list of devices.

unicap_enumerate_devices ()

unicap_status_t     unicap_enumerate_devices            (unicap_device_t *specifier,
                                                         unicap_device_t *device,
                                                         int index);

Enumerates currently connected video capture devices

unicap_open ()

unicap_status_t     unicap_open                         (unicap_handle_t *handle,
                                                         unicap_device_t *device);

Acquire a handle to a device.

unicap_register_callback ()

unicap_status_t     unicap_register_callback            (unicap_handle_t handle,
                                                         unicap_event_t event,
                                                         unicap_callback_t func,
                                                         void *user_ptr);

unicap_close ()

unicap_status_t     unicap_close                        (unicap_handle_t handle);

Clsoing a handle decrements the reference count on the device. If the reference count is 0, all resources associated with the device get freed.

unicap_get_device ()

unicap_status_t     unicap_get_device                   (unicap_handle_t handle,
                                                         unicap_device_t *device);

Gets the device controled by handle

unicap_clone_handle ()

unicap_handle_t     unicap_clone_handle                 (unicap_handle_t old_handle);

Copies the handle, increment the reference count

unicap_reenumerate_formats ()

unicap_status_t     unicap_reenumerate_formats          (unicap_handle_t handle,
                                                         int *count);

Re-create the list of formats supported by the device. Invalidates all data returned by prior calls to unicap_emumerate_formats() and unicap_get_format().

unicap_enumerate_formats ()

unicap_status_t     unicap_enumerate_formats            (unicap_handle_t handle,
                                                         unicap_format_t *specifier,
                                                         unicap_format_t *format,
                                                         int index);

Enumerate formats known to the device

unicap_set_format ()

unicap_status_t     unicap_set_format                   (unicap_handle_t handle,
                                                         unicap_format_t *format);

Set a format.

unicap_get_format ()

unicap_status_t     unicap_get_format                   (unicap_handle_t handle,
                                                         unicap_format_t *format);

Get the current format

unicap_reenumerate_properties ()

unicap_status_t     unicap_reenumerate_properties       (unicap_handle_t handle,
                                                         int *count);

Re-create the list of properties supported by the device. This invalidates all data returned by prior calls to unicap_enumerate_properties() and unicap_get_property()

unicap_enumerate_properties ()

unicap_status_t     unicap_enumerate_properties         (unicap_handle_t handle,
                                                         unicap_property_t *specifier,
                                                         unicap_property_t *property,
                                                         int index);

Enumerate properties matching "specifier"

unicap_set_property ()

unicap_status_t     unicap_set_property                 (unicap_handle_t handle,
                                                         unicap_property_t *property);

Set a device property

unicap_get_property ()

unicap_status_t     unicap_get_property                 (unicap_handle_t handle,
                                                         unicap_property_t *property);

Get a device property

unicap_start_capture ()

unicap_status_t     unicap_start_capture                (unicap_handle_t handle);

Start the capture device. After this call, unicap_wait_buffer calls are allowed

unicap_stop_capture ()

unicap_status_t     unicap_stop_capture                 (unicap_handle_t handle);

Stop the capture device

unicap_queue_buffer ()

unicap_status_t     unicap_queue_buffer                 (unicap_handle_t handle,
                                                         unicap_data_buffer_t *data_buffer);

Queue a buffer to be filled by the capture device. The queued buffer must not be touched ( especially not be freed ) until it is in the ready queue or dequeued. Supplied buffer must be at least of the buffer size returned by get_format

unicap_dequeue_buffer ()

unicap_status_t     unicap_dequeue_buffer               (unicap_handle_t handle,
                                                         unicap_data_buffer_t **data_buffer);

Removes the first buffer from the queue. Depending on the device:Can only be called if the capture device is stopped.

unicap_wait_buffer ()

unicap_status_t     unicap_wait_buffer                  (unicap_handle_t handle,
                                                         unicap_data_buffer_t **data_buffer);

Removes a buffer from the ready queue. If no buffer is available, this function blocks until a buffer got filled.

unicap_poll_buffer ()

unicap_status_t     unicap_poll_buffer                  (unicap_handle_t handle,
                                                         int *count);

Poll for buffers in the fill queue