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