unicap_handle_t open_imagingsource_camera ()
{
unicap_device_t imaging_source_dev;
int dev_count = 0;
unicap_enumerate_devices(NULL, &imaging_source_dev, dev_count);
printf("Open %s\n", imaging_source_dev.identifier);
unicap_handle_t handle;
unicap_open (&handle, &imaging_source_dev);
return handle;
}
unicap_handle_t
getHandle (void)
{
unicap_device_t imaging_source_dev;
int dev_count = 0;
unicap_enumerate_devices(NULL, &imaging_source_dev, dev_count);
unicap_handle_t handle;
if(!SUCCESS(unicap_open (&handle, &imaging_source_dev)))
{
fprintf(stderr, "could not open device");
return NULL;
}
return handle;
}
/** @copydoc CameraApi::EnumerateCameras()
*
*/
const CameraApi::CameraList LibUnicapCameraApi::EnumerateCameras() const
{
CameraApi::CameraList cameraList;
unicap_device_t device;
int i = 0;
while( SUCCESS( unicap_enumerate_devices( NULL, &device, i++ ) ) )
{
cameraList.push_back( CameraDescription( *this )
.WithName ( Convert::ToStdWString( device.model_name ) )
.WithDescription( Convert::ToStdWString( device.vendor_id ) )
.WithUniqueId ( Convert::ToStdWString( device.identifier ) )
);
}
return cameraList;
}
//--------------------------------------------------------------------
void ofUCUtils::listUCDevices() {
int status = STATUS_SUCCESS;
int dev_count;
unicap_device_t devices[MAX_DEVICES];
printf("listing available capture devices\n");
printf("---\n");
for (dev_count = 0; SUCCESS (status) && (dev_count < MAX_DEVICES); dev_count++) {
status = unicap_enumerate_devices (NULL, &devices[dev_count], dev_count);
if (SUCCESS (status))
printf ("Video device %d: %s\n", dev_count,
devices[dev_count].identifier);
}
printf("---\n");
}
//--------------------------------------------------------------------
void ofUCUtils::open_device(int d) {
if (!SUCCESS(unicap_enumerate_devices (NULL, &device, d))) {
printf ("Unicap : Error selecting device %d\n", d);
} else {
if (!SUCCESS(unicap_open (&handle, &device))) {
printf ("Unicap : Error opening device %d: %s\n", d,
device.identifier);
}
}
if(verbose){
printf("Unicap : Using device %s \n",device.device);
printf("Unicap : Using module %s\n",device.vendor_name);
}
}
//--------------------------------------------------------------------
bool ofUCUtils::open_device(int d) {
if (!SUCCESS(unicap_enumerate_devices (NULL, &device, d))) {
ofLog(OF_ERROR,"ofUCUtils: Error selecting device %d", d);
return false;
} else {
if (!SUCCESS(unicap_open (&handle, &device))) {
ofLog(OF_ERROR,"ofUCUtils: Error opening device %d: %s", d, device.identifier);
return false;
}
deviceReady = true;
}
ofLog(OF_NOTICE,"ofUCUtils: Using device %s",device.device);
ofLog(OF_NOTICE,"ofUCUtils: Using module %s",device.vendor_name);
return true;
}
/*
device_change_cb:
callback called when the user selected a video capture device
*/
static
void device_change_cb( UnicapgtkDeviceSelection *selection, gchar *device_id, GtkWidget *ugtk_display )
{
unicap_device_t device;
unicap_handle_t handle;
GtkWidget *property_dialog;
GtkWidget *format_selection;
GtkWidget *_window;
property_dialog = g_object_get_data( G_OBJECT( ugtk_display ), "property_dialog" );
g_assert( property_dialog );
format_selection = g_object_get_data( G_OBJECT( ugtk_display ), "format_selection" );
g_assert( format_selection );
_window = g_object_get_data( G_OBJECT( ugtk_display ), "app-window" );
g_assert( _window );
unicap_void_device( &device );
strcpy( device.identifier, device_id );
if( !SUCCESS( unicap_enumerate_devices( &device, &device, 0 ) ) ||
!SUCCESS( unicap_open( &handle, &device ) ) )
{
// device is not available anymore
g_printerr( "*** TODO: device rescan*** device not available!\n" );
return;
}
if( unicap_is_stream_locked( &device ) )
{
// could not acquire lock
unicap_close( handle );
g_printerr( "*** TODO: device rescan*** device is locked\n" );
return;
}
unicapgtk_video_display_set_handle( UNICAPGTK_VIDEO_DISPLAY( ugtk_display ), handle );
unicapgtk_property_dialog_set_handle( UNICAPGTK_PROPERTY_DIALOG( property_dialog ), handle );
unicapgtk_video_format_selection_set_handle( UNICAPGTK_VIDEO_FORMAT_SELECTION( format_selection ), handle );
unicap_close( handle );
gtk_window_set_title( GTK_WINDOW( _window ), device.identifier );
}
static unicap_handle_t
open_device ()
{
int dev_count;
int status = STATUS_SUCCESS;
unicap_device_t devices[MAX_DEVICES];
unicap_handle_t handle;
int d = -1;
for (dev_count = 0; SUCCESS (status) && (dev_count < MAX_DEVICES);
dev_count++)
{
// (1)
status =
unicap_enumerate_devices (NULL, &devices[dev_count], dev_count);
if (SUCCESS (status))
{
printf ("%d: %s\n", dev_count, devices[dev_count].identifier);
}
else
{
break;
}
}
if (dev_count == 0)
{
// no device selected
return NULL;
}
while ((d < 0) || (d >= dev_count))
{
printf ("Open Device: ");
scanf ("%d", &d);
}
unicap_open (&handle, &devices[d]);
return handle;
}
int main( int argc, char **argv )
{
unicap_handle_t handle;
unicap_device_t device;
unicap_device_t device_spec;
unicap_property_t property;
unicap_property_t property_spec;
int list_only = 0;
int get_property = 0;
int value_set = 0;
int i;
int c = 0;
unicap_void_device( &device_spec );
unicap_void_property( &property );
while( c != -1 )
{
c = getopt( argc, argv, "gp:M:v:m:l" );
switch( c )
{
case 'p':
if( optarg )
{
strcpy( property.identifier, optarg );
}
break;
case 'M':
if( optarg )
{
printf( "Model: %s\n", optarg );
strcpy( device_spec.model_name, optarg );
}
else
{
print_usage( argv[0] );
exit( 1 );
}
break;
case 'v':
if( optarg )
{
sscanf( optarg, "%f", &property_spec.value );
value_set = 1;
}
else
{
print_usage( argv[0] );
exit( 1 );
}
break;
case 'm':
if( optarg )
{
strcpy( property.menu_item, optarg );
}
else
{
print_usage( argv[0] );
exit( 1 );
}
break;
case 'l':
list_only = 1;
break;
case 'g':
get_property = 1;
break;
case -1:
printf( "optind: %d\n", optind );
break;
default:
print_usage( argv[0] );
exit( 1 );
break;
}
}
//
// Enumerate all video capture devices; if more than 1 device present, ask for which device to open
//
for( i = 0; SUCCESS( unicap_enumerate_devices( &device_spec, &device, i ) ); i++ )
{
printf( "%i: %s\n", i, device.identifier );
}
if( --i > 0 )
{
printf( "Select video capture device: " );
scanf( "%d", &i );
}
if( !SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ) )
{
fprintf( stderr, "Failed to get info for device '%s'\n", device.identifier );
exit( 1 );
}
/*
Acquire a handle to this device
*/
if( !SUCCESS( unicap_open( &handle, &device ) ) )
{
fprintf( stderr, "Failed to open device: %s\n", device.identifier );
exit( 1 );
}
printf( "Opened video capture device: %s\n", device.identifier );
// Initialize a property specifier structure
unicap_void_property( &property_spec );
strcpy( property_spec.identifier, property.identifier );
printf( "Supported properties: \n" );
printf( "\tName\t\tValue\n" );
//
// Print a list of all properties matching the specifier. For a "void" specifier, this matches all
// properties supported by the device
// If more than 1 property is supported, ask for which property to modify
for( i = 0; SUCCESS( unicap_enumerate_properties( handle, &property_spec, &property, i ) ); i++ )
{
unicap_get_property( handle, &property );
printf( "%i: \t%s\t\t", i, property.identifier );
switch( property.type )
{
case UNICAP_PROPERTY_TYPE_RANGE:
case UNICAP_PROPERTY_TYPE_VALUE_LIST:
printf( "%f", property.value );
break;
case UNICAP_PROPERTY_TYPE_MENU:
printf( "%s", property.menu_item );
break;
case UNICAP_PROPERTY_TYPE_FLAGS:
{
int j;
const char *flags[] =
{ "MANUAL",
"AUTO",
"ONE_PUSH",
"READ_OUT",
"ON_OFF",
"READ_ONLY",
"FORMAT_CHANGE"
};
for( j = 0; j < ( sizeof( flags ) / sizeof( char* ) ); j++ )
{
if( ( property.flags & ( 1<<j ) ) == ( 1<<j ) )
{
printf( "%s ",flags[j] );
}
}
}
break;
default:
break;
}
printf( "\n" );
}
if( --i > 1 )
{
printf( "Select a property to edit: " );
scanf( "%d", &i );
}
// Now get the description of the requested property. unicap_enumerate_property gives the
// property structure initialized to the default values. So just change the value of the
// returned property to the new one and set it using 'unicap_set_property'
if( !SUCCESS( unicap_enumerate_properties( handle, &property_spec, &property, i ) ) )
{
printf( "Failed to enumerate property\n" );
exit( -1 );
}
switch( property.type )
{
case UNICAP_PROPERTY_TYPE_RANGE:
case UNICAP_PROPERTY_TYPE_VALUE_LIST:
{
if( !value_set )
{
double new_value;
printf( "Enter new value for property '%s' ( floating point value ): ", property.identifier );
scanf( "%lf", &new_value );
property.value = new_value;
property.flags = UNICAP_FLAGS_MANUAL;
}
else
{
property.value = property_spec.value;
}
}
break;
case UNICAP_PROPERTY_TYPE_MENU:
{
printf( "Enter new value for property '%s' ( string ): ", property.identifier );
scanf( "%128s", property.menu_item );
}
break;
case UNICAP_PROPERTY_TYPE_FLAGS:
{
int i;
char buf[128];
char *str;
printf( "Enter new flags for property '%s' ( out of ", property.identifier );
for( i = 0; i < ( sizeof( property_flag_strings ) / sizeof( struct flag_string ) ); i++ )
{
if( property.flags_mask & property_flag_strings[i].flag )
{
printf( "%s ", property_flag_strings[i].name );
}
}
printf( "): " );
scanf( "%128s", buf );
str = strtok( buf, " " );
property.flags = 0;
while( str )
{
for( i = 0; i < ( sizeof( property_flag_strings ) / sizeof( struct flag_string ) ); i++ )
{
if( !strcmp( str, property_flag_strings[i].name ) )
{
property.flags |= property_flag_strings[i].flag;
break;
}
}
if( i == ( sizeof( property_flag_strings ) / sizeof( struct flag_string ) ) )
{
printf( "Unknown flag: %s\n", str );
break;
}
str = strtok( NULL, " " );
}
}
}
if( !get_property )
{
if( !SUCCESS( unicap_set_property( handle, &property ) ) )
{
printf( "Failed to set property!\n" );
}
}
else
{
char buffer[512];
int s = sizeof( buffer );
if( !SUCCESS( unicap_get_property( handle, &property ) ) )
{
printf( "Failed to set property!\n" );
}
unicap_describe_property( &property, buffer, &s );
printf( "%s\n", buffer );
}
unicap_close( handle );
return 0;
}
int main (int argc, char *argv [])
{
unicap_handle_t handle;
unicap_device_t device;
unicap_format_t src_format;
unicap_format_t dest_format;
unicap_data_buffer_t src_buffer;
unicap_data_buffer_t dest_buffer;
unicap_data_buffer_t *returned_buffer;
if (argc != 4) {
fprintf (stderr, "Usage: sender <hostname> <camera name> "
"<interface>\n");
exit (1);
}
// Initialise 0MQ infrastructure
// 1. Set error handler function (to ignore disconnected receivers)
zmq::set_error_handler (error_handler);
// 2. Initialise basic infrastructure for 2 threads
zmq::dispatcher_t dispatcher (2);
// 3. Initialise local locator (to connect to global locator)
zmq::locator_t locator (argv [1]);
// 4. Start one working thread (to send data to receivers)
zmq::poll_thread_t *pt = zmq::poll_thread_t::create (&dispatcher);
// 5. Register one API thread (the application thread - the one that
// is being executed at the moment)
zmq::api_thread_t *api = zmq::api_thread_t::create (&dispatcher, &locator);
// 6. Define an entry point for the messages. The name of the entry point
// is user-defined ("camera name"). Specify that working thread "pt"
// will be used to listen to new connections being created as well as
// to send frames to existing connections.
int e_id = api->create_exchange (argv [2], zmq::scope_global, argv [3],
pt, 1, &pt);
// Open first available video capture device
if (!SUCCESS (unicap_enumerate_devices (NULL, &device, 0))) {
fprintf (stderr, "Could not enumerate devices\n");
exit (1);
}
if (!SUCCESS (unicap_open (&handle, &device))) {
fprintf (stderr, "Failed to open device: %s\n", device.identifier);
exit (1);
}
printf( "Opened video capture device: %s\n", device.identifier );
// Find a suitable video format that we can convert to RGB24
bool conversion_found = false;
int index = 0;
while (SUCCESS (unicap_enumerate_formats (handle, NULL, &src_format,
index))) {
printf ("Trying video format: %s\n", src_format.identifier);
if (ucil_conversion_supported (FOURCC ('R', 'G', 'B', '3'),
src_format.fourcc)) {
conversion_found = true;
break;
}
index++;
}
if (!conversion_found) {
fprintf (stderr, "Could not find a suitable video format\n");
exit (1);
}
src_format.buffer_type = UNICAP_BUFFER_TYPE_USER;
if (!SUCCESS (unicap_set_format (handle, &src_format))) {
fprintf (stderr, "Failed to set video format\n");
exit (1);
}
printf ("Using video format: %s [%dx%d]\n",
src_format.identifier,
src_format.size.width,
src_format.size.height);
// Clone destination format with equal dimensions, but RGB24 colorspace
unicap_copy_format (&dest_format, &src_format);
strcpy (dest_format.identifier, "RGB 24bpp");
dest_format.fourcc = FOURCC ('R', 'G', 'B', '3');
dest_format.bpp = 24;
dest_format.buffer_size = dest_format.size.width *
dest_format.size.height * 3;
// Initialise image buffers
memset (&src_buffer, 0, sizeof (unicap_data_buffer_t));
src_buffer.data = (unsigned char *)malloc (src_format.buffer_size);
src_buffer.buffer_size = src_format.buffer_size;
memset (&dest_buffer, 0, sizeof (unicap_data_buffer_t));
dest_buffer.data = (unsigned char *)malloc (dest_format.buffer_size);
dest_buffer.buffer_size = dest_format.buffer_size;
dest_buffer.format = dest_format;
// Start video capture
if (!SUCCESS (unicap_start_capture (handle))) {
fprintf (stderr, "Failed to start capture on device: %s\n",
device.identifier);
exit (1);
}
// Loop, sending video to defined exchange
while (1) {
// Queue buffer for video capture
if (!SUCCESS (unicap_queue_buffer (handle, &src_buffer))) {
fprintf (stderr, "Failed to queue a buffer on device: %s\n",
device.identifier);
exit (1);
}
// Wait until buffer is ready
if (!SUCCESS (unicap_wait_buffer (handle, &returned_buffer))) {
fprintf (stderr, "Failed to wait for buffer on device: %s\n",
device.identifier);
exit (1);
}
// Convert colorspace
if (!SUCCESS (ucil_convert_buffer (&dest_buffer, &src_buffer))) {
// TODO: This fails sometimes for unknown reasons,
// just skip the frame for now
fprintf (stderr, "Failed to convert video buffer\n");
}
// Create ZMQ message
zmq::message_t msg (dest_format.buffer_size + (2 * sizeof (uint32_t)));
unsigned char *data = (unsigned char *)msg.data();
// Image width in pixels
zmq::put_uint32 (data, (uint32_t)dest_format.size.width);
data += sizeof (uint32_t);
// Image height in pixels
zmq::put_uint32 (data, (uint32_t)dest_format.size.height);
data += sizeof (uint32_t);
// RGB24 image data
memcpy (data, dest_buffer.data, dest_format.buffer_size);
// Send message
api->send (e_id, msg);
}
return 0;
}
int main( int argc, char **argv )
{
unicap_handle_t handle;
unicap_device_t device;
unicap_format_t format_spec;
unicap_format_t format;
unicap_data_buffer_t buffer;
unicap_data_buffer_t *returned_buffer;
int i;
SDL_Surface *screen;
SDL_Overlay *overlay;
int quit=0;
/*
Enumerate available video capture devices
*/
printf( "select video device\n" );
for( i = 0; SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ); i++ )
{
printf( "%i: %s\n", i, device.identifier );
}
if( --i > 0 )
{
printf( "Select video capture device: " );
scanf( "%d", &i );
}
if( !SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ) )
{
fprintf( stderr, "Failed to get info for device '%s'\n", device.identifier );
exit( 1 );
}
/*
Acquire a handle to selected device
*/
if( !SUCCESS( unicap_open( &handle, &device ) ) )
{
fprintf( stderr, "Failed to open device: %s\n", device.identifier );
exit( 1 );
}
printf( "Opened video capture device: %s\n", device.identifier );
unicap_void_format( &format_spec );
/*
Get the list of video formats
*/
for( i = 0; SUCCESS( unicap_enumerate_formats( handle,
NULL,
&format, i ) );
i++ )
{
printf( "%d: %s\n",
i,
format.identifier );
}
if( --i > 0 )
{
printf( "Select video format: " );
scanf( "%d", &i );
}
if( !SUCCESS( unicap_enumerate_formats( handle, &format_spec, &format, i ) ) )
{
fprintf( stderr, "Failed to get video format %d\n", i );
exit( 1 );
}
/*
If a video format has more than one size, ask for which size to use
*/
if( format.size_count )
{
for( i = 0; i < format.size_count; i++ )
{
printf( "%d: %dx%d\n", i, format.sizes[i].width, format.sizes[i].height );
}
do
{
printf( "Select video format size: " );
scanf( "%d", &i );
}while( ( i < 0 ) && ( i > format.size_count ) );
format.size.width = format.sizes[i].width;
format.size.height = format.sizes[i].height;
}
/*
Set this video format
*/
if( !SUCCESS( unicap_set_format( handle, &format ) ) )
{
fprintf( stderr, "Failed to set video format\n" );
exit( 1 );
}
/*
Initialize the image buffer
*/
memset( &buffer, 0x0, sizeof( unicap_data_buffer_t ) );
/**
Init SDL & SDL_Overlay
**/
if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
{
fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
screen = SDL_SetVideoMode( format.size.width, format.size.height, 32, SDL_HWSURFACE);
if ( screen == NULL ) {
fprintf(stderr, "Unable to set video mode: %s\n", SDL_GetError());
exit(1);
}
overlay = SDL_CreateYUVOverlay( format.size.width,
format.size.height,
format.fourcc,
screen );
if( overlay == NULL )
{
fprintf( stderr, "Unable to create overlay: %s\n", SDL_GetError() );
exit( 1 );
}
/*
Pass the pointer to the overlay to the unicap data buffer.
*/
buffer.data = overlay->pixels[0];
buffer.buffer_size = format.size.width * format.size.height * format.bpp / 8;
/*
Start the capture process on the device
*/
if( !SUCCESS( unicap_start_capture( handle ) ) )
{
fprintf( stderr, "Failed to start capture on device: %s\n", device.identifier );
exit( 1 );
}
while( !quit )
{
SDL_Rect rect;
SDL_Event event;
rect.x = rect.y = 0;
rect.w = format.size.width;
rect.h = format.size.height;
/*
Queue the buffer
The buffer now gets filled with image data by the capture device
*/
if( !SUCCESS( unicap_queue_buffer( handle, &buffer ) ) )
{
fprintf( stderr, "Failed to queue a buffer on device: %s\n", device.identifier );
exit( 1 );
}
/*
Wait until the image buffer is ready
*/
if( !SUCCESS( unicap_wait_buffer( handle, &returned_buffer ) ) )
{
fprintf( stderr, "Failed to wait for buffer on device: %s\n", device.identifier );
}
/*
Display the video data
*/
SDL_UnlockYUVOverlay( overlay );
SDL_DisplayYUVOverlay( overlay, &rect );
SDL_LockYUVOverlay(overlay);
while( SDL_PollEvent( &event ) )
{
if( event.type == SDL_QUIT )
{
printf( "Quit\n" );
quit=1;
}
}
}
/*
Stop the device
*/
if( !SUCCESS( unicap_stop_capture( handle ) ) )
{
fprintf( stderr, "Failed to stop capture on device: %s\n", device.identifier );
}
/*
Close the device
This invalidates the handle
*/
if( !SUCCESS( unicap_close( handle ) ) )
{
fprintf( stderr, "Failed to close the device: %s\n", device.identifier );
}
SDL_Quit();
return 0;
}
int UnicapCamera::Open()
{
unicap_device_t device;
unicap_handle_t handle;
unicap_format_t format;
//Initialisation
if (m_Device == NULL)
{
m_Device = (unicap_device_t *)malloc(sizeof(unicap_device_t));
if (m_Device == NULL)
{
printf("UnicapCamera::Open: Error, no memory!\n");
return ERROR_NO_MEMORY;
}
}
if (m_Handle == NULL)
{
m_Handle = (unicap_handle_t *)malloc(sizeof(unicap_handle_t));
if (m_Handle == NULL)
{
printf("UnicapCamera::Open: Error, no memory!\n");
return ERROR_NO_MEMORY;
}
}
if (m_Format == NULL)
{
m_Format = (unicap_format_t *)malloc(sizeof(unicap_format_t));
if (m_Format == NULL)
{
printf("UnicapCamera::Open: Error, no memory!\n");
return ERROR_NO_MEMORY;
}
}
// Search camera devices
if( !SUCCESS( unicap_enumerate_devices( NULL, &device, 0 ) ) )
{
printf("UnicapCamera::Open: No device found!\n");
return ERROR_NO_CAMERAS_FOUND;
}
else
{
*m_Device = device;
printf("UnicapCamera::Open: Device %s found, vendor: %s, controlled by %s, %s\n", m_Device->identifier, m_Device->vendor_name, m_Device->device, m_Device->cpi_layer);
}
/*
Acquire a handle to this device
*/
if( !SUCCESS( unicap_open( &handle, m_Device ) ) )
{
printf("UnicapCamera::Open: Failed to open device %s: %s\n", m_Device->identifier, strerror(errno));
return ERROR_CAMERA_COULD_NOT_BE_OPENED;
}
else
{
*m_Handle = handle;
m_CameraActive = true;
printf("DUnicapCamera::Open:evice %s successfully opened!\n", m_Device->identifier);
}
//Set format according to specified resolution
if( !SUCCESS( unicap_enumerate_formats( *m_Handle, NULL, &format, m_Resolution ) ) )
{
printf("UnicapCamera::Open: Failed to get video format, setting to default\n" );
//return UNSPECIFIED_ERROR;;
}
else
{
*m_Format = format;
printf("UnicapCamera::Open: Format %s chosen\n", format.identifier );
printf("UnicapCamera::Open: Setting video format: \nwidth: %d\nheight: %d\nbpp: %d\nFOURCC: %c%c%c%c\n\n", \
m_Format->size.width,\
m_Format->size.height,\
m_Format->bpp, \
m_Format->fourcc & 0xff, \
( m_Format->fourcc >> 8 ) & 0xff, \
( m_Format->fourcc >> 16 ) & 0xff, \
( m_Format->fourcc >> 24 ) & 0xff \
);
/*
Set this video format
*/
if( !SUCCESS( unicap_set_format( *m_Handle, m_Format ) ) )
{
printf("UnicapCamera::Open: Failed to set video format\n" );
return UNSPECIFIED_ERROR;
}
}
unicap_property_t property;
// Set white balance mode to auto
strcpy( property.identifier, "white_balance_mode" );
if( !SUCCESS( unicap_get_property( *m_Handle, &property ) ) )
{
fprintf( stderr, "UnicapCamera::Open: Failed to get WB mode property\n" );
exit( 1 );
}
// Set auto on this property
property.flags = UNICAP_FLAGS_AUTO;//UNICAP_FLAGS_MANUAL;
unicap_set_property( handle, &property );
if( !SUCCESS( unicap_set_property( *m_Handle, &property ) ) )
{
printf( "UnicapCamera::Open: Failed to set property!\n" );
return UNSPECIFIED_ERROR;
}
if( !SUCCESS( unicap_get_property( *m_Handle, &property ) ) )
{
fprintf( stderr, "UnicapCamera::Open: Failed to get WB mode property\n" );
exit( 1 );
}
printf( "UnicapCamera::Open: Current white balance mode: %s\n", property.flags & UNICAP_FLAGS_AUTO ? "AUTO" : "MANUAL" );
if( !SUCCESS( unicap_start_capture( *m_Handle ) ) )
{
printf( "UnicapCamera::Open: Failed to start capture on device %s\n", m_Device->identifier );
return UNSPECIFIED_ERROR;
}
return OK;
}
unicap_handle_t user_config_try_restore( void )
{
GKeyFile *keyfile = NULL;
gchar *config_path;
gchar *ini_path;
unicap_handle_t handle = NULL;
config_path = get_config_path();
ini_path = g_build_path( G_DIR_SEPARATOR_S, config_path, "default.ini", NULL );
g_free( config_path );
keyfile = g_key_file_new( );
if( !g_key_file_load_from_file( keyfile,
ini_path,
G_KEY_FILE_NONE,
NULL ) )
{
g_free( ini_path );
ini_path = g_build_path( G_DIR_SEPARATOR_S, UCVIEW_GLOBAL_CONFIGDIR, "default.ini", NULL );
if( !g_key_file_load_from_file( keyfile,
ini_path,
G_KEY_FILE_NONE,
NULL ) )
{
g_warning( "failed\n" );
g_key_file_free( keyfile );
keyfile = NULL;
}
}
g_free( ini_path );
if( keyfile )
{
gchar *devid = NULL;
gchar *vendor_name = NULL;
gchar *model_name = NULL;
unicap_device_t devspec;
unicap_device_t device;
unicap_void_device( &devspec );
devid = g_key_file_get_string( keyfile, "Device", "Identifier", NULL );
if( devid )
{
strcpy( devspec.identifier, devid );
}
else
{
vendor_name = g_key_file_get_string( keyfile, "Device", "Vendor", NULL );
model_name = g_key_file_get_string( keyfile, "Device", "Model", NULL );
if( vendor_name && model_name )
{
strncpy( device.vendor_name, vendor_name, sizeof( device.vendor_name ) - 1 );
strncpy( device.model_name, model_name, sizeof( device.model_name ) - 1 );
}
}
// Only call unicap_open if a matching device was found,
// otherwise we would always open any device
if( devid || ( vendor_name && model_name ) )
{
if( SUCCESS( unicap_enumerate_devices( &devspec, &device, 0 ) ) )
{
if( SUCCESS( unicap_open( &handle, &device ) ) )
{
unicapgtk_load_device_state( handle, keyfile, UNICAPGTK_DEVICE_STATE_VIDEO_FORMAT | UNICAPGTK_DEVICE_STATE_PROPERTIES );
}
}
}
if( devid )
{
g_free( devid );
}
if( vendor_name )
{
g_free( vendor_name );
}
if( model_name )
{
g_free( model_name );
}
g_key_file_free( keyfile );
}
return handle;
}
/**
* unicapgtk_device_selection_rescan:
* @combo: an #UnicapgtkDeviceSelection
*
* Tiggers rescan of available video capture devices and updates the
* combo box.
*
* Returns: number of available devices
*/
gint
unicapgtk_device_selection_rescan( UnicapgtkDeviceSelection *combo )
{
unicap_device_t device;
GtkListStore *store;
GtkTreeIter iter;
gint i;
g_return_val_if_fail( UNICAPGTK_IS_DEVICE_SELECTION( combo ), 0 );
store = GTK_LIST_STORE( gtk_combo_box_get_model( GTK_COMBO_BOX( combo ) ) );
g_return_val_if_fail( GTK_IS_LIST_STORE( store ), 0 );
if( GTK_WIDGET_REALIZED( combo ) )
{
gdk_window_set_cursor( GTK_WIDGET( combo )->window, combo->busy_cursor );
gdk_display_sync( gtk_widget_get_display( GTK_WIDGET( combo ) ) );
}
gtk_list_store_clear( store );
gtk_combo_box_set_active( GTK_COMBO_BOX( combo ), -1 );
unicap_reenumerate_devices( NULL );
for( i = 0; SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ); i++ )
{
gchar *label;
gboolean available = !unicap_is_stream_locked( &device );
label = format_device_label( combo->label_fmt_string, &device );
gtk_list_store_append( store, &iter);
gtk_list_store_set( store, &iter,
UNICAPGTK_DEVICE_ID, device.identifier,
UNICAPGTK_DEVICE_MODEL, device.model_name,
UNICAPGTK_DEVICE_VENDOR, device.vendor_name,
LABEL, label,
SENSITIVE, available,
-1);
g_free( label );
}
if( i == 0 )
{
device_combo_box_add_none_entry( store );
}
if( combo->include_rescan_entry )
{
device_combo_box_add_rescan_entry( store );
}
if( combo->active_device )
{
unicapgtk_device_selection_set_by_id( combo, combo->active_device );
}
if( GTK_WIDGET_REALIZED( combo ) )
{
gdk_window_set_cursor( GTK_WIDGET( combo )->window, NULL );
}
return i;
}
int main( int argc, char **argv )
{
unicap_handle_t handle;
unicap_device_t device;
unicap_format_t format_spec;
unicap_format_t format;
unicap_data_buffer_t buffer;
unicap_data_buffer_t *returned_buffer;
int width, height;
int i;
SDL_Surface *screen;
SDL_Overlay *overlay;
int quit=0;
int imgcnt = 0;
printf( "select video device\n" );
for( i = 0; SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ); i++ )
{
printf( "%i: %s\n", i, device.identifier );
}
if( --i > 0 )
{
printf( "Select video capture device: " );
scanf( "%d", &i );
}
if( !SUCCESS( unicap_enumerate_devices( NULL, &device, i ) ) )
{
fprintf( stderr, "Failed to get info for device '%s'\n", device.identifier );
exit( 1 );
}
/*
Acquire a handle to this device
*/
if( !SUCCESS( unicap_open( &handle, &device ) ) )
{
fprintf( stderr, "Failed to open device: %s\n", device.identifier );
exit( 1 );
}
printf( "Opened video capture device: %s\n", device.identifier );
/*
Create a format specification to limit the list of formats returned by
unicap_enumerate_formats to the ones with the color format 'UYVY'
*/
unicap_void_format( &format_spec );
format_spec.fourcc = FOURCC('U','Y','V','Y');
/*
Get the list of video formats of the colorformat UYVY
*/
for( i = 0; SUCCESS( unicap_enumerate_formats( handle, &format_spec, &format, i ) ); i++ )
{
printf( "%d: %s [%dx%d]\n",
i,
format.identifier,
format.size.width,
format.size.height );
}
if( --i > 0 )
{
printf( "Select video format: " );
scanf( "%d", &i );
}
if( !SUCCESS( unicap_enumerate_formats( handle, &format_spec, &format, i ) ) )
{
fprintf( stderr, "Failed to get video format\n" );
exit( 1 );
}
/*
If a video format has more than one size, ask for which size to use
*/
if( format.size_count )
{
for( i = 0; i < format.size_count; i++ )
{
printf( "%d: %dx%d\n", i, format.sizes[i].width, format.sizes[i].height );
}
do
{
printf( "Select video format size: " );
scanf( "%d", &i );
}while( ( i < 0 ) && ( i > format.size_count ) );
format.size.width = format.sizes[i].width;
format.size.height = format.sizes[i].height;
}
/*
Set this video format
*/
if( !SUCCESS( unicap_set_format( handle, &format ) ) )
{
fprintf( stderr, "Failed to set video format\n" );
exit( 1 );
}
/*
Initialize the image buffer
*/
memset( &buffer, 0x0, sizeof( unicap_data_buffer_t ) );
/**
Init SDL & SDL_Overlay
**/
if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
{
fprintf(stderr, "Failed to initialize SDL: %s\n", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
/*
Make sure the video window does not get too big.
*/
width = MIN( format.size.width, 800 );
height = MIN( format.size.height, 600 );
screen = SDL_SetVideoMode( width, height, 32, SDL_HWSURFACE);
if ( screen == NULL ) {
fprintf(stderr, "Unable to set video mode: %s\n", SDL_GetError());
exit(1);
}
overlay = SDL_CreateYUVOverlay( format.size.width,
format.size.height, SDL_UYVY_OVERLAY, screen );
if( overlay == NULL )
{
fprintf( stderr, "Unable to create overlay: %s\n", SDL_GetError() );
exit( 1 );
}
/*
Pass the pointer to the overlay to the unicap data buffer.
*/
buffer.data = overlay->pixels[0];
buffer.buffer_size = format.size.width * format.size.height * format.bpp / 8;
/*
Start the capture process on the device
*/
if( !SUCCESS( unicap_start_capture( handle ) ) )
{
fprintf( stderr, "Failed to start capture on device: %s\n", device.identifier );
exit( 1 );
}
while( !quit )
{
SDL_Rect rect;
SDL_Event event;
rect.x = 0;
rect.y = 0;
rect.w = width;
rect.h = height;
/*
Queue the buffer
The buffer now gets filled with image data by the capture device
*/
if( !SUCCESS( unicap_queue_buffer( handle, &buffer ) ) )
{
fprintf( stderr, "Failed to queue a buffer on device: %s\n", device.identifier );
exit( 1 );
}
/*
Wait until the image buffer is ready
*/
if( !SUCCESS( unicap_wait_buffer( handle, &returned_buffer ) ) )
{
fprintf( stderr, "Failed to wait for buffer on device: %s\n", device.identifier );
}
/*
Display the video data
*/
SDL_UnlockYUVOverlay( overlay );
SDL_DisplayYUVOverlay( overlay, &rect );
while( SDL_PollEvent( &event ) )
{
switch( event.type )
{
case SDL_QUIT:
quit = 1;
break;
case SDL_MOUSEBUTTONDOWN:
{
unsigned char *pixels;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE *outfile;
JSAMPROW row_pointer[1];
int row_stride;
char filename[128];
struct timeval t1, t2;
unsigned long long usecs;
sprintf( filename, "%04d.jpg", imgcnt++ );
cinfo.err = jpeg_std_error(&jerr);
/* Now we can initialize the JPEG compression object. */
jpeg_create_compress(&cinfo);
if ((outfile = fopen( filename, "wb" ) ) == NULL )
{
fprintf(stderr, "can't open %s\n", "file");
exit(1);
}
jpeg_stdio_dest(&cinfo, outfile);
cinfo.image_width = format.size.width; /* image width and height, in pixels */
cinfo.image_height = format.size.height;
cinfo.input_components = 3; /* # of color components per pixel */
cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
jpeg_set_defaults(&cinfo);
pixels = malloc( format.size.width * format.size.height * 3 );
uyvy2rgb24( pixels, returned_buffer->data,
format.size.width * format.size.height * 3,
format.size.width * format.size.height * 2 );
gettimeofday( &t1, NULL );
jpeg_start_compress(&cinfo, TRUE);
while( cinfo.next_scanline < cinfo.image_height )
{
row_pointer[0] = &pixels[cinfo.next_scanline * format.size.width * 3 ];
(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
}
jpeg_finish_compress(&cinfo);
gettimeofday( &t2, NULL );
usecs = t2.tv_sec * 1000000LL + t2.tv_usec;
usecs -= ( t1.tv_sec * 1000000LL + t1.tv_usec );
printf( "Compression took: %lld usec\n", usecs );
/* After finish_compress, we can close the output file. */
fclose(outfile);
jpeg_destroy_compress(&cinfo);
free( pixels );
}
break;
default:
break;
}
}
SDL_LockYUVOverlay(overlay);
}
/*
Stop the device
*/
if( !SUCCESS( unicap_stop_capture( handle ) ) )
{
fprintf( stderr, "Failed to stop capture on device: %s\n", device.identifier );
}
/*
Close the device
This invalidates the handle
*/
if( !SUCCESS( unicap_close( handle ) ) )
{
fprintf( stderr, "Failed to close the device: %s\n", device.identifier );
}
SDL_Quit();
return 0;
}
