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 callback,
                          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 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_set_property_value ()

unicap_status_t
unicap_set_property_value (unicap_handle_t handle,
                           char *identifier,
                           double value);

unicap_set_property_manual ()

unicap_status_t
unicap_set_property_manual (unicap_handle_t handle,
                            char *identifier);

Sets a property to manual mode, disabling the automatic mode

unicap_set_property_auto ()

unicap_status_t
unicap_set_property_auto (unicap_handle_t handle,
                          char *identifier);

Sets the property to automatic mode

unicap_set_property_one_push ()

unicap_status_t
unicap_set_property_one_push (unicap_handle_t handle,
                              char *identifier);

Enable one push mode on a property

unicap_get_property ()

unicap_status_t
unicap_get_property (unicap_handle_t handle,
                     unicap_property_t *property);

Get a device property

unicap_get_property_value ()

unicap_status_t
unicap_get_property_value (unicap_handle_t handle,
                           const char *identifier,
                           double *value);

Returns the value of a property

unicap_get_property_menu ()

unicap_status_t
unicap_get_property_menu (unicap_handle_t handle,
                          const char *identifier,
                          char **value);

Returns the menu string of a property. Property must be of UNICAP_PROPERTY_TYPE_MENU type. The returned string is owned by the unicap library and might be overwritten by subsequent calls to unicap_get_property_menu.

unicap_get_property_auto ()

unicap_status_t
unicap_get_property_auto (unicap_handle_t handle,
                          const char *identifier,
                          int *enabled);

Retrieve the current property auto mode

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

enum unicap_buffer_type_t

unicap_device_t

typedef struct {
	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;
} unicap_device_t;

A struct defining a device

unicap_rect_t

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

A struct defining a rectangle

unicap_format_t

typedef struct {
      char identifier[128];
      
      unicap_rect_t size;
      
      unicap_rect_t min_size;
      unicap_rect_t max_size;
      
      int h_stepping;
      int v_stepping;
      unicap_rect_t *sizes;
      int size_count;
      
      int bpp;
      unsigned int fourcc;
      unicap_format_flags_t flags;

      unsigned int buffer_types;
      int system_buffer_count;

      size_t buffer_size;

      unicap_buffer_type_t buffer_type;
} unicap_format_t;

unicap_data_buffer_t

typedef struct {
   unicap_format_t format;
      
   int frame_number;
   struct timeval fill_time;
   struct timeval duration;
   struct timeval capture_start_time;
      
   unsigned char *data;
   size_t buffer_size;	

   unicap_buffer_type_t type;

   unicap_buffer_flags_t flags;
   
   unicap_data_buffer_private_t *priv;
} unicap_data_buffer_t;

enum unicap_property_flags_t

unicap_property_range_t

typedef struct {
	double min;
	double max;
} unicap_property_range_t;

unicap_property_value_list_t

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

unicap_property_menu_t

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

enum unicap_property_type_enum_t

unicap_property_t

typedef struct {
      char identifier[128];
      char category[128];
      char unit[128];
      
      char **relations;
      int relations_count;	
      
      union
	    double value;
	    char menu_item[128]; 
      
      
      union	
	    unicap_property_range_t range;
	    unicap_property_value_list_t value_list;
	    unicap_property_menu_t menu; 
	    
      
      double stepping;
      
      unicap_property_type_enum_t type;	
      unicap_property_flags_t flags;
      unicap_property_flags_t flags_mask;
      
      void *property_data; 
      size_t property_data_size;	
} unicap_property_t;

enum 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)