int32_t vc_gpuserv_init( void )
{
VCHIQ_SERVICE_PARAMS_T vchiq_params;
VCOS_STATUS_T status = VCOS_ENXIO;
VCHIQ_STATUS_T vchiq_status;
vcos_once(&gpuserv_client_once, init_once);
vcos_mutex_lock(&gpuserv_client.lock);
if (gpuserv_client.refcount++ > 0)
{
/* Already initialised so nothing to do */
vcos_mutex_unlock(&gpuserv_client.lock);
return VCOS_SUCCESS;
}
vcos_log_set_level(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE);
vcos_log_register("gpuserv", VCOS_LOG_CATEGORY);
vcos_log_trace("%s: starting initialisation", VCOS_FUNCTION);
/* Initialise a VCHIQ instance */
vchiq_status = vchiq_initialise(&gpuserv_client_vchiq_instance);
if (vchiq_status != VCHIQ_SUCCESS)
{
vcos_log_error("%s: failed to initialise vchiq: %d", VCOS_FUNCTION, vchiq_status);
goto error;
}
vchiq_status = vchiq_connect(gpuserv_client_vchiq_instance);
if (vchiq_status != VCHIQ_SUCCESS)
{
vcos_log_error("%s: failed to connect to vchiq: %d", VCOS_FUNCTION, vchiq_status);
goto error;
}
memset(&vchiq_params, 0, sizeof(vchiq_params));
vchiq_params.fourcc = VCHIQ_MAKE_FOURCC('G','P','U','S');
vchiq_params.callback = gpuserv_callback;
vchiq_params.userdata = NULL;
vchiq_params.version = 1;
vchiq_params.version_min = 1;
vchiq_status = vchiq_open_service(gpuserv_client_vchiq_instance, &vchiq_params, &gpuserv_client.service);
if (vchiq_status != VCHIQ_SUCCESS)
{
vcos_log_error("%s: could not open vchiq service: %d", VCOS_FUNCTION, vchiq_status);
goto error;
}
vcos_mutex_unlock(&gpuserv_client.lock);
return 0;
error:
vcos_mutex_unlock(&gpuserv_client.lock);
return -1;
}
/* Initialises GL preview state and creates the dispmanx native window.
* @param state Pointer to the GL preview state.
* @return Zero if successful.
*/
int raspitex_init(RASPITEX_STATE *state)
{
VCOS_STATUS_T status;
int rc;
vcos_init();
vcos_log_register("RaspiTex", VCOS_LOG_CATEGORY);
vcos_log_set_level(VCOS_LOG_CATEGORY,
state->verbose ? VCOS_LOG_INFO : VCOS_LOG_WARN);
vcos_log_trace("%s", VCOS_FUNCTION);
status = vcos_semaphore_create(&state->capture.start_sem,
"glcap_start_sem", 1);
if (status != VCOS_SUCCESS)
goto error;
status = vcos_semaphore_create(&state->capture.completed_sem,
"glcap_completed_sem", 0);
if (status != VCOS_SUCCESS)
goto error;
switch (state->scene_id)
{
case RASPITEX_SCENE_SQUARE:
rc = square_open(state);
break;
case RASPITEX_SCENE_MIRROR:
rc = mirror_open(state);
break;
case RASPITEX_SCENE_TEAPOT:
rc = teapot_open(state);
break;
case RASPITEX_SCENE_YUV:
rc = yuv_open(state);
break;
case RASPITEX_SCENE_SOBEL:
rc = sobel_open(state);
break;
case RASPITEXT_SCENE_BGS_SIMPLE:
rc = gl_simple_open(state);
break;
default:
rc = -1;
break;
}
if (rc != 0)
goto error;
return 0;
error:
vcos_log_error("%s: failed", VCOS_FUNCTION);
return -1;
}
int main(int argc, char **argv)
{
// Parse command line options/arguments.
VIDTEX_PARAMS_T params = {0};
int rc;
int status = 0;
opterr = 0;
while ((rc = getopt(argc, argv, "d:iuvy")) != -1)
{
switch (rc)
{
case 'd':
params.duration_ms = atoi(optarg);
break;
case 'i':
params.opts |= VIDTEX_OPT_IMG_PER_FRAME;
break;
case 'y':
params.opts |= VIDTEX_OPT_Y_TEXTURE;
break;
case 'u':
params.opts |= VIDTEX_OPT_U_TEXTURE;
break;
case 'v':
params.opts |= VIDTEX_OPT_V_TEXTURE;
break;
default:
usage(argv[0]);
return 2;
}
}
if (optind < argc - 1)
{
usage(argv[0]);
return 2;
}
if (optind < argc)
{
strncpy(params.uri, argv[optind], sizeof(params.uri) - 1);
params.uri[sizeof(params.uri) - 1] = '\0';
}
// Init vcos logging.
vcos_log_set_level(VCOS_LOG_CATEGORY, VCOS_LOG_INFO);
vcos_log_register("vidtex", VCOS_LOG_CATEGORY);
// Run video-on-texture application in a separate thread.
#ifdef __ANDROID__
status = Launcher::runApp("vidtex", launch_vidtex, ¶ms, sizeof(params));
#else
status = runApp("vidtex", launch_vidtex, ¶ms, sizeof(params));
#endif
return (status == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main( int argc, char **argv )
{
int32_t ret;
char optstring[OPTSTRING_LEN];
int opt;
int opt_alloc = 0;
int opt_status = 0;
uint32_t alloc_size = 0;
int opt_pid = -1;
VCSM_STATUS_T status_mode = VCSM_STATUS_NONE;
void *usr_ptr_1;
unsigned int usr_hdl_1;
#if defined(DOUBLE_ALLOC) || defined(RESIZE_ALLOC)
void *usr_ptr_2;
unsigned int usr_hdl_2;
#endif
// Initialize VCOS
vcos_init();
vcos_log_set_level(&smem_log_category, VCOS_LOG_INFO);
smem_log_category.flags.want_prefix = 0;
vcos_log_register( "smem", &smem_log_category );
// Create the option string that we will be using to parse the arguments
create_optstring( optstring );
// Parse the command line arguments
while (( opt = getopt_long_only( argc, argv, optstring, long_opts,
NULL )) != -1 )
{
switch ( opt )
{
case 0:
{
// getopt_long returns 0 for entries where flag is non-NULL
break;
}
case OPT_ALLOC:
{
char *end;
alloc_size = (uint32_t)strtoul( optarg, &end, 10 );
if (end == optarg)
{
vcos_log_info( "Invalid arguments '%s'", optarg );
goto err_out;
}
opt_alloc = 1;
break;
}
case OPT_PID:
{
char *end;
opt_pid = (int)strtol( optarg, &end, 10 );
if (end == optarg)
{
vcos_log_info( "Invalid arguments '%s'", optarg );
goto err_out;
}
break;
}
case OPT_STATUS:
{
char status_str[32];
/* coverity[secure_coding] String length specified, so can't overflow */
if ( sscanf( optarg, "%31s", status_str ) != 1 )
{
vcos_log_info( "Invalid arguments '%s'", optarg );
goto err_out;
}
if ( vcos_strcasecmp( status_str, "all" ) == 0 )
{
status_mode = VCSM_STATUS_VC_MAP_ALL;
}
else if ( vcos_strcasecmp( status_str, "vc" ) == 0 )
{
status_mode = VCSM_STATUS_VC_WALK_ALLOC;
}
else if ( vcos_strcasecmp( status_str, "map" ) == 0 )
{
status_mode = VCSM_STATUS_HOST_WALK_MAP;
}
else if ( vcos_strcasecmp( status_str, "host" ) == 0 )
{
status_mode = VCSM_STATUS_HOST_WALK_PID_ALLOC;
}
else
{
goto err_out;
}
opt_status = 1;
break;
}
default:
{
vcos_log_info( "Unrecognized option '%d'", opt );
goto err_usage;
}
case '?':
case OPT_HELP:
{
goto err_usage;
}
} // end switch
} // end while
argc -= optind;
argv += optind;
if (( optind == 1 ) || ( argc > 0 ))
{
if ( argc > 0 )
{
vcos_log_info( "Unrecognized argument -- '%s'", *argv );
}
goto err_usage;
}
// Start the shared memory support.
if ( vcsm_init() == -1 )
{
vcos_log_info( "Cannot initialize smem device" );
goto err_out;
}
if ( opt_alloc == 1 )
{
vcos_log_info( "Allocating 2 times %u-bytes in shared memory", alloc_size );
usr_hdl_1 = vcsm_malloc( alloc_size,
"smem-test-alloc" );
vcos_log_info( "Allocation 1 result: user %x, vc-hdl %x",
usr_hdl_1, vcsm_vc_hdl_from_hdl( usr_hdl_1 ) );
#if defined(DOUBLE_ALLOC) || defined(RESIZE_ALLOC)
usr_hdl_2 = vcsm_malloc( alloc_size,
NULL );
vcos_log_info( "Allocation 2 result: user %x",
usr_hdl_2 );
usr_ptr_2 = vcsm_lock( usr_hdl_2 );
vcos_log_info( "Allocation 2 : lock %p",
usr_ptr_2 );
vcos_log_info( "Allocation 2 : unlock %d",
vcsm_unlock_hdl( usr_hdl_2 ) );
#endif
// Do a simple write/read test.
if ( usr_hdl_1 != 0 )
{
usr_ptr_1 = vcsm_lock( usr_hdl_1 );
vcos_log_info( "Allocation 1 : lock %p",
usr_ptr_1 );
if ( usr_ptr_1 )
{
memset ( usr_ptr_1,
0,
alloc_size );
memcpy ( usr_ptr_1,
blah_blah,
32 );
vcos_log_info( "Allocation 1 contains: \"%s\"",
(char *)usr_ptr_1 );
vcos_log_info( "Allocation 1: vc-hdl %x",
vcsm_vc_hdl_from_ptr ( usr_ptr_1 ) );
vcos_log_info( "Allocation 1: usr-hdl %x",
vcsm_usr_handle ( usr_ptr_1 ) );
vcos_log_info( "Allocation 1 : unlock %d",
vcsm_unlock_ptr( usr_ptr_1 ) );
}
usr_ptr_1 = vcsm_lock( usr_hdl_1 );
vcos_log_info( "Allocation 1 (relock) : lock %p",
usr_ptr_1 );
if ( usr_ptr_1 )
{
vcos_log_info( "Allocation 1 (relock) : unlock %d",
vcsm_unlock_hdl( usr_hdl_1 ) );
}
}
#if defined(RESIZE_ALLOC)
ret = vcsm_resize( usr_hdl_1, 2 * alloc_size );
vcos_log_info( "Allocation 1 : resize %d", ret );
if ( ret == 0 )
{
usr_ptr_1 = vcsm_lock( usr_hdl_1 );
vcos_log_info( "Allocation 1 (resize) : lock %p",
usr_ptr_1 );
if ( usr_ptr_1 )
{
memset ( usr_ptr_1,
0,
2 * alloc_size );
memcpy ( usr_ptr_1,
blah_blah,
32 );
vcos_log_info( "Allocation 1 (resized) contains: \"%s\"",
(char *)usr_ptr_1 );
vcos_log_info( "Allocation 1 (resized) : unlock %d",
vcsm_unlock_ptr( usr_ptr_1 ) );
}
}
// This checks that the memory can be remapped properly
// because the Block 1 expanded beyond Block 2 boundary.
//
usr_ptr_2 = vcsm_lock( usr_hdl_2 );
vcos_log_info( "Allocation 2 : lock %p",
usr_ptr_2 );
vcos_log_info( "Allocation 2 : unlock %d",
vcsm_unlock_hdl( usr_hdl_2 ) );
// This checks that we can free a memory block even if it
// is locked, which could be the case if the application
// dies.
//
usr_ptr_2 = vcsm_lock( usr_hdl_2 );
vcos_log_info( "Allocation 2 : lock %p",
usr_ptr_2 );
vcsm_free ( usr_hdl_2 );
#endif
#if defined(DOUBLE_ALLOC)
#endif
}
if ( opt_status == 1 )
{
get_status( status_mode, opt_pid );
}
// If we allocated something, wait for the signal to exit to give chance for the
// user to poke around the allocation test.
//
if ( opt_alloc == 1 )
{
start_monitor();
vcos_event_wait( &quit_event );
vcos_event_delete( &quit_event );
}
// Terminate the shared memory support.
vcsm_exit ();
goto err_out;
err_usage:
show_usage();
err_out:
exit( 1 );
}
