int UnicapCamera::SetProperty(int propertyNo, int value )
{
unicap_property_t property;
unicap_property_t property_spec;
unicap_void_property( &property_spec );
if (!IsCameraActive())
{
printf("UnicapCamera::SetProperties: Please call open first! \n");
return ERROR_NOT_OPENED;
}
if( !SUCCESS( unicap_enumerate_properties( *m_Handle, &property_spec, &property, propertyNo ) ) )
{
printf( "UnicapCamera::SetProperties: Failed to enumerate property\n" );
return UNSPECIFIED_ERROR;
}
property.value = value;
printf("UnicapCamera::SetProperties: Setting property %d: %s to %f ... \n",propertyNo, property.identifier,property.value);
if( !SUCCESS( unicap_set_property( *m_Handle, &property ) ) )
{
printf( "UnicapCamera::SetProperties: Failed to set property!\n" );
return UNSPECIFIED_ERROR;
}
return OK;
}
int UnicapCamera::PrintCameraInformation()
{
unicap_format_t format;
unicap_property_t property;
int property_count;
int format_count;
if (!IsCameraActive())
{
printf("UnicapCamera::SetProperties: Please call open first! \n");
return ERROR_NOT_OPENED;
}
unicap_reenumerate_properties( *m_Handle, &property_count );
unicap_reenumerate_formats( *m_Handle, &format_count );
printf( "Device: %s\n", m_Device->identifier );
printf( "\tProperties[%d]:\n", property_count );
for(int j = 0; SUCCESS( unicap_enumerate_properties( *m_Handle, NULL, &property, j ) ); j++ )
{
printf( "\t\t%s\n", property.identifier );
}
printf( "\tFormats[%d]:\n", format_count );
for(int j = 0; SUCCESS( unicap_enumerate_formats( *m_Handle, NULL, &format, j ) ); j++ )
{
printf( "\t\t%s\n", format.identifier );
}
return OK;
}
void
getproperty(unicap_handle_t handle, unicap_property_t *prop, char *propid)
{
int i;
for(i = 0; SUCCESS(unicap_enumerate_properties(handle, NULL, prop,i)); i++)
{
unicap_property_t p = *prop;
if(strcmp(propid, p.identifier) == 0)
{
unicap_get_property(handle, prop);
break;
}
}
}
//--------------------------------------------------------------------
void ofUCUtils::queryUC_imageProperties(void) {
unicap_property_t property;
ofLog(OF_NOTICE,"ofUCUtils : Video settings:");
const int PPTY_TYPE_MAPPED_FLOAT=UNICAP_PROPERTY_TYPE_UNKNOWN + 1;
int status = STATUS_SUCCESS;
int ppty_type;
for (int i=0; i<MAX_PROPERTIES; i++) {
status = unicap_enumerate_properties(handle, NULL, &property, i);
if ( !SUCCESS( status ))
return;
status = unicap_get_property(handle, &property );
if ( !SUCCESS( status )) {
ofLog(OF_ERROR,"ofUCUtils : Error getting %s value\n", property.identifier);
return;
}
ppty_type = property.type;
switch (ppty_type) {
case PPTY_TYPE_MAPPED_FLOAT:
case UNICAP_PROPERTY_TYPE_RANGE:
case UNICAP_PROPERTY_TYPE_VALUE_LIST:
if (property.value>0 && property.value<1) {
ofLog(OF_NOTICE,"\t%s: 1/%.0f \n", property.identifier, 1/property.value);
} else {
ofLog(OF_NOTICE,"\t%s: %.2f \n", property.identifier, property.value);
}
break;
case UNICAP_PROPERTY_TYPE_MENU:
printf("\t%s: %s \n", property.identifier, property.menu_item);
break;
default:
break;
}
}
}
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;
}
