/*
format_change_cb:
Callback called when the user selected a new video format
*/
static
void format_change_cb( GtkWidget *ugtk, unicap_format_t *format, GtkWidget *ugtk_display )
{
GtkWidget *property_dialog;
property_dialog = g_object_get_data( G_OBJECT( ugtk_display ), "property_dialog" );
g_assert( property_dialog );
unicapgtk_video_display_stop( UNICAPGTK_VIDEO_DISPLAY( ugtk_display ) );
unicapgtk_video_display_set_format( UNICAPGTK_VIDEO_DISPLAY( ugtk_display ), format );
unicapgtk_video_display_start( UNICAPGTK_VIDEO_DISPLAY( ugtk_display ) );
// reset the property dialog since some properties ( eg. frame rate ) might change when the format changes
unicapgtk_property_dialog_reset( UNICAPGTK_PROPERTY_DIALOG( property_dialog ) );
}
static void unicapgtk_video_display_compute_child_allocation( GtkFrame *frame, GtkAllocation *child_allocation )
{
UnicapgtkVideoDisplay *ugtk = UNICAPGTK_VIDEO_DISPLAY( frame );
GTK_FRAME_CLASS( parent_class )->compute_child_allocation( frame, child_allocation );
if( child_allocation->width < 0 )
{
child_allocation->width = ugtk->crop_width;
}
if( child_allocation->height < 0 )
{
child_allocation->height = ugtk->crop_height;
}
if( ugtk->scale_to_fit )
{
return;
}
if( child_allocation->width > ugtk->crop_width )
{
child_allocation->x += GTK_ASPECT_FRAME( frame )->xalign *
(child_allocation->width - ugtk->crop_width);
child_allocation->width = ugtk->crop_width;
}
if( child_allocation->height > ugtk->crop_height )
{
child_allocation->y += GTK_ASPECT_FRAME( frame )->yalign *
(child_allocation->height - ugtk->crop_height);
child_allocation->height = ugtk->crop_height;
}
}
static void unicapgtk_video_display_get_property( GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec )
{
UnicapgtkVideoDisplay *ugtk = UNICAPGTK_VIDEO_DISPLAY( object );
switch( property_id )
{
case PROP_SCALE_TO_FIT:
g_value_set_boolean( value, ugtk->scale_to_fit );
break;
case PROP_BACKEND:
g_value_set_string( value, ugtk->backend );
break;
case PROP_FOURCC:
g_value_set_uint( value, ugtk->backend_fourcc );
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec );
break;
}
}
int main( int argc, char *argv[] )
{
/* GtkWidget *display_window; */
GtkWidget *video_display;
GtkWidget *device_selection;
GtkWidget *widget;
GTimer *fps_timer;
g_thread_init(NULL);
gdk_threads_init();
gtk_init (&argc, &argv);
//
// Create the main application window
//
display_window = create_application_window( );
video_display = g_object_get_data( G_OBJECT( display_window ), "ugtk_display" );
g_assert( video_display );
device_selection = g_object_get_data( G_OBJECT( video_display ), "device_selection" );
g_assert( device_selection );
fps_timer = g_timer_new();
unicapgtk_video_display_set_new_frame_callback( UNICAPGTK_VIDEO_DISPLAY( video_display ),
UNICAPGTK_CALLBACK_FLAGS_BEFORE,
(unicap_new_frame_callback_t)new_frame_cb,
fps_timer );
//
// Create a window containing the properties for the
// video capture device and a device selection menu
//
widget = unicapgtk_property_dialog_new( );
gtk_widget_show_all( widget );
g_object_set_data( G_OBJECT( video_display ), "property_dialog", widget );
//
// Rescan devices and select first device
//
if( unicapgtk_device_selection_rescan( UNICAPGTK_DEVICE_SELECTION( device_selection ) ) > 0 )
{
gtk_combo_box_set_active (GTK_COMBO_BOX( device_selection ), 0);
}
gdk_threads_enter();
gtk_main ();
gdk_threads_leave();
return 0;
}
int main (int argc, char* argv[])
{
GtkWidget* window;
GtkWidget* ugtk_display;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
ugtk_display = unicapgtk_video_display_new_by_device (NULL);
gtk_container_add (GTK_CONTAINER (window), ugtk_display);
unicapgtk_video_display_start (UNICAPGTK_VIDEO_DISPLAY (ugtk_display));
gtk_widget_show_all (window);
gtk_main();
return 0;
}
static void unicapgtk_video_display_set_property( GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec )
{
UnicapgtkVideoDisplay *ugtk = UNICAPGTK_VIDEO_DISPLAY( object );
switch( property_id )
{
case PROP_SCALE_TO_FIT:
unicapgtk_video_display_set_scale_to_fit( ugtk,
g_value_get_boolean( value ) );
break;
case PROP_BACKEND:
{
const gchar *str = g_value_get_string( value );
backend_type_t t = BACKEND_UNDECIDED;
if( !strcmp( str, "gtk" ) )
{
t = BACKEND_GTK;
}
else if( !strcmp( str, "xv" ) )
{
t = BACKEND_XV;
}
ugtk->requested_backend = t;
set_backend( ugtk );
}
break;
case PROP_FOURCC:
{
ugtk->backend_fourcc = g_value_get_uint( value );
set_backend( ugtk );
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, pspec );
break;
}
}
/*
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 void unicapgtk_video_display_destroy( GtkObject *object )
{
UnicapgtkVideoDisplay *ugtk = UNICAPGTK_VIDEO_DISPLAY( object );
/* g_object_unref( ugtk->gc ); */
if( ugtk->capture_running )
{
unicapgtk_video_display_stop( ugtk );
}
if( ugtk->unicap_handle )
{
unicap_close( ugtk->unicap_handle );
ugtk->unicap_handle = NULL;
}
if( ugtk->backend )
{
ugtk->backend_destroy( ugtk->backend_data );
ugtk->backend = NULL;
}
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *ugtk;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (exit), NULL);
ugtk = unicapgtk_video_display_new_by_device( NULL );
gtk_container_add (GTK_CONTAINER (window), ugtk);
gtk_widget_show_all (window);
// register a callback which is called immediately before an image is displayed
g_signal_connect( G_OBJECT( ugtk ), "unicapgtk_video_display_predisplay",
G_CALLBACK( predisplay_cb ), NULL );
if( unicapgtk_video_display_start( UNICAPGTK_VIDEO_DISPLAY( ugtk ) ) == 0 )
{
GtkWidget *dialog = gtk_message_dialog_new( NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to start live display!\n" \
"No device connected?" );
gtk_dialog_run( GTK_DIALOG( dialog ) );
exit(-1);
}
gtk_main();
return 0;
}
/*
pause_toggle_cb:
Callback called when the user pressed the pause button
*/
static
void pause_toggle_cb( GtkWidget *toggle_button, GtkWidget *ugtk_display )
{
unicapgtk_video_display_set_pause( UNICAPGTK_VIDEO_DISPLAY( ugtk_display ),
gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( toggle_button ) ) );
}
