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; }