int main (int argc, const char **argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
int success = -1;
char response[ 128 ];
if (!is_filed_running())
{
printf("vcfiled not running\n");
exit(-1);
}
vcos_init();
vcos_set_args(argc, argv);
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
return -1;
}
// initialise the OS abstraction layer
os_init();
vcos_log("vchi_initialise");
success = vchi_initialise( &global_initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vcos_log("vchi_connect");
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_gencmd_init (global_initialise_instance, &global_connection, 1);
vc_vchi_dispmanx_init (global_initialise_instance, &global_connection, 1);
vc_vchi_tv_init (global_initialise_instance, &global_connection, 1);
vc_vchi_cec_init (global_initialise_instance, &global_connection, 1);
vc_vchi_bufman_init (global_initialise_instance, &global_connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
vcos_log("VMCS services initialized.");
message_queue_init ();
host_app_message_handler (PLATFORM_MSG_INIT, 0, 0);
dispatch_messages ();
vcos_deinit ();
return 0;
}
/* 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;
}
/***********************************************************
* Name: os_init
*
* Arguments: void
*
* Description: Routine to init the local OS stack - called from vchi_init
*
* Returns: int32_t - success == 0
*
***********************************************************/
int32_t os_init( void )
{
int success;
vcos_init();
os_cond_init();
os_assert(!vcos_os_inited++); /* should only be called once now */
success = os_semaphore_create(&os_mutex_global, OS_SEMAPHORE_TYPE_SUSPEND);
os_assert(success == 0);
return success;
}
int main(int argc, char *const *argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
int success;
progname = argv[0];
const char *sep = strrchr(progname, '/');
if (sep)
progname = sep+1;
parse_args(argc, argv);
if (!foreground)
{
log_stderr = 0; // must log to syslog if we're a daemon
daemonize();
}
vcfile_lock();
vcos_init();
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
logmsg(LOG_ERR, "%s: failed to open vchiq instance\n", argv[0]);
return -1;
}
// initialise the OS abstraction layer
os_init();
success = vchi_initialise( &global_initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_filesys_init (global_initialise_instance, &global_connection, 1);
for (;;)
{
sleep(INT_MAX);
}
vcos_deinit ();
return 0;
}
void bcm_host_init(void)
{
VCHIQ_INSTANCE_T vchiq_instance;
static int initted;
int success = -1;
char response[ 128 ];
if (initted)
return;
initted = 1;
vcos_init();
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
exit(-1);
}
vcos_log("vchi_initialise");
success = vchi_initialise( &global_initialise_instance);
vcos_assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vcos_log("vchi_connect");
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_gencmd_init (global_initialise_instance, &global_connection, 1);
vc_vchi_dispmanx_init (global_initialise_instance, &global_connection, 1);
vc_vchi_tv_init (global_initialise_instance, &global_connection, 1);
vc_vchi_cec_init (global_initialise_instance, &global_connection, 1);
//vc_vchi_bufman_init (global_initialise_instance, &global_connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
}
int main( int argc, char **argv )
{
int32_t ret;
char optstring[OPTSTRING_LEN];
int opt;
int opt_preferred = 0;
int opt_explicit = 0;
int opt_sdtvon = 0;
int opt_off = 0;
int opt_modes = 0;
int opt_monitor = 0;
int opt_status = 0;
int opt_audiosup = 0;
int opt_dumpedid = 0;
int opt_showinfo = 0;
int opt_3d = 0;
int opt_json = 0;
int opt_name = 0;
char *dumpedid_filename = NULL;
VCHI_INSTANCE_T vchi_instance;
VCHI_CONNECTION_T *vchi_connection;
HDMI_RES_GROUP_T power_on_explicit_group = HDMI_RES_GROUP_INVALID;
uint32_t power_on_explicit_mode;
uint32_t power_on_explicit_drive = HDMI_MODE_HDMI;
HDMI_RES_GROUP_T get_modes_group = HDMI_RES_GROUP_INVALID;
SDTV_MODE_T sdtvon_mode;
SDTV_ASPECT_T sdtvon_aspect;
// Initialize VCOS
vcos_init();
// 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_PREFERRED:
{
opt_preferred = 1;
break;
}
case OPT_EXPLICIT:
{
char group_str[32], drive_str[32];
/* coverity[secure_coding] String length specified, so can't overflow */
int s = sscanf( optarg, "%31s %u %31s", group_str, &power_on_explicit_mode, drive_str );
if ( s != 2 && s != 3 )
{
LOG_ERR( "Invalid arguments '%s'", optarg );
goto err_out;
}
// Check the group first
if ( vcos_strcasecmp( "CEA", group_str ) == 0 )
{
power_on_explicit_group = HDMI_RES_GROUP_CEA;
}
else if ( vcos_strcasecmp( "DMT", group_str ) == 0 )
{
power_on_explicit_group = HDMI_RES_GROUP_DMT;
}
else if ( vcos_strcasecmp( "CEA_3D", group_str ) == 0 ||
vcos_strcasecmp( "CEA_3D_SBS", group_str ) == 0)
{
power_on_explicit_group = HDMI_RES_GROUP_CEA;
opt_3d = 1;
}
else if ( vcos_strcasecmp( "CEA_3D_TB", group_str ) == 0 )
{
power_on_explicit_group = HDMI_RES_GROUP_CEA;
opt_3d = 2;
}
else
{
LOG_ERR( "Invalid group '%s'", group_str );
goto err_out;
}
if (s==3)
{
if (vcos_strcasecmp( "HDMI", drive_str ) == 0 )
{
power_on_explicit_drive = HDMI_MODE_HDMI;
}
else if (vcos_strcasecmp( "DVI", drive_str ) == 0 )
{
power_on_explicit_drive = HDMI_MODE_DVI;
}
else
{
LOG_ERR( "Invalid drive '%s'", drive_str );
goto err_out;
}
}
// Then check if mode is a sane number
if ( power_on_explicit_mode > MAX_MODE_ID )
{
LOG_ERR( "Invalid mode '%u'", power_on_explicit_mode );
goto err_out;
}
opt_explicit = 1;
break;
}
case OPT_SDTVON:
{
char mode_str[32], aspect_str[32];
if ( sscanf( optarg, "%s %s", mode_str,
aspect_str ) != 2 )
{
LOG_ERR( "Invalid arguments '%s'", optarg );
goto err_out;
}
// Check the group first
if ( vcos_strcasecmp( "NTSC", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_NTSC;
}
else if ( vcos_strcasecmp( "NTSC_J", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_NTSC_J;
}
else if ( vcos_strcasecmp( "PAL", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_PAL;
}
else if ( vcos_strcasecmp( "PAL_M", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_PAL_M;
}
else
{
LOG_ERR( "Invalid mode '%s'", mode_str );
goto err_out;
}
if ( vcos_strcasecmp( "4:3", aspect_str ) == 0 )
{
sdtvon_aspect = SDTV_ASPECT_4_3;
}
else if ( vcos_strcasecmp( "14:9", aspect_str ) == 0 )
{
sdtvon_aspect = SDTV_ASPECT_14_9;
}
else if ( vcos_strcasecmp( "16:9", aspect_str ) == 0 )
{
sdtvon_aspect = SDTV_ASPECT_16_9;
}
opt_sdtvon = 1;
break;
}
case OPT_OFF:
{
opt_off = 1;
break;
}
case OPT_MODES:
{
if ( vcos_strcasecmp( "CEA", optarg ) == 0 )
{
get_modes_group = HDMI_RES_GROUP_CEA;
}
else if ( vcos_strcasecmp( "DMT", optarg ) == 0 )
{
get_modes_group = HDMI_RES_GROUP_DMT;
}
else
{
LOG_ERR( "Invalid group '%s'", optarg );
goto err_out;
}
opt_modes = 1;
break;
}
case OPT_MONITOR:
{
opt_monitor = 1;
break;
}
case OPT_STATUS:
{
opt_status = 1;
break;
}
case OPT_AUDIOSUP:
{
opt_audiosup = 1;
break;
}
case OPT_DUMPEDID:
{
opt_dumpedid = 1;
dumpedid_filename = optarg;
break;
}
case OPT_SHOWINFO:
{
opt_showinfo = atoi(optarg)+1;
break;
}
case OPT_JSON:
{
opt_json = 1;
break;
}
case OPT_NAME:
{
opt_name = 1;
break;
}
default:
{
LOG_ERR( "Unrecognized option '%d'\n", 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 )
{
LOG_ERR( "Unrecognized argument -- '%s'", *argv );
}
goto err_usage;
}
if (( opt_preferred + opt_explicit + opt_sdtvon > 1 ))
{
LOG_ERR( "Conflicting power on options" );
goto err_usage;
}
if ((( opt_preferred == 1 ) || ( opt_explicit == 1 ) || ( opt_sdtvon == 1)) && ( opt_off == 1 ))
{
LOG_ERR( "Cannot power on and power off simultaneously" );
goto err_out;
}
// Initialize the VCHI connection
ret = vchi_initialise( &vchi_instance );
if ( ret != 0 )
{
LOG_ERR( "Failed to initialize VCHI (ret=%d)", ret );
goto err_out;
}
ret = vchi_connect( NULL, 0, vchi_instance );
if ( ret != 0)
{
LOG_ERR( "Failed to create VCHI connection (ret=%d)", ret );
goto err_out;
}
// LOG_INFO( "Starting tvservice" );
// Initialize the tvservice
vc_vchi_tv_init( vchi_instance, &vchi_connection, 1 );
if ( opt_monitor == 1 )
{
LOG_STD( "Starting to monitor for HDMI events" );
if ( start_monitor() != 0 )
{
goto err_stop_service;
}
}
if ( opt_modes == 1 )
{
if ( get_modes( get_modes_group, opt_json ) != 0 )
{
goto err_stop_service;
}
}
if ( opt_preferred == 1 )
{
if ( power_on_preferred() != 0 )
{
goto err_stop_service;
}
}
else if ( opt_explicit == 1 )
{
//Distinguish between turning on 3D side by side and 3D top/bottom
if(opt_3d == 1 && set_property( HDMI_PROPERTY_3D_STRUCTURE, HDMI_3D_FORMAT_SBS_HALF, 0) != 0)
{
goto err_stop_service;
}
else if(opt_3d == 2 && set_property( HDMI_PROPERTY_3D_STRUCTURE, HDMI_3D_FORMAT_TB_HALF, 0) != 0)
{
goto err_stop_service;
}
if ( power_on_explicit( power_on_explicit_group,
power_on_explicit_mode, power_on_explicit_drive ) != 0 )
{
goto err_stop_service;
}
}
else if ( opt_sdtvon == 1 )
{
if ( power_on_sdtv( sdtvon_mode,
sdtvon_aspect ) != 0 )
{
goto err_stop_service;
}
}
else if (opt_off == 1 )
{
if ( power_off() != 0 )
{
goto err_stop_service;
}
}
if ( opt_status == 1 )
{
if ( get_status() != 0 )
{
goto err_stop_service;
}
}
if ( opt_audiosup == 1 )
{
if ( get_audiosup() != 0 )
{
goto err_stop_service;
}
}
if ( opt_dumpedid == 1 )
{
if ( dump_edid(dumpedid_filename) != 0 )
{
goto err_stop_service;
}
}
if ( opt_showinfo )
{
if ( show_info(opt_showinfo-1) != 0 )
{
goto err_stop_service;
}
}
if ( opt_name == 1 )
{
TV_DEVICE_ID_T id;
memset(&id, 0, sizeof(id));
if(vc_tv_get_device_id(&id) == 0) {
if(id.vendor[0] == '\0' || id.monitor_name[0] == '\0') {
LOG_ERR( "No device present" );
} else {
LOG_STD( "device_name=%s-%s", id.vendor, id.monitor_name);
}
} else {
LOG_ERR( "Failed to obtain device name" );
}
}
if ( opt_monitor == 1 )
{
// Wait until we get the signal to exit
vcos_event_wait( &quit_event );
vcos_event_delete( &quit_event );
}
err_stop_service:
// LOG_INFO( "Stopping tvservice" );
// Stop the tvservice
vc_vchi_tv_stop();
// Disconnect the VCHI connection
vchi_disconnect( vchi_instance );
exit( 0 );
err_usage:
show_usage();
err_out:
exit( 1 );
}
int main(int argc, char **argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
VCHI_INSTANCE_T initialise_instance;
VCHI_CONNECTION_T *connection;
int success = -1;
ILCS_CONFIG_T config;
char response[ 128 ];
printf("vcos_init\n");
vcos_init();
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
return -1;
}
// initialise the OS abstraction layer
os_init();
// initialise the mphi driver
// mphi_get_func_table()->init();
// initialise the vchi layer
printf("vchi_initialise\n");
success = vchi_initialise( &initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)initialise_instance;
connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
printf("vchi_connect\n");
vchi_connect(&connection, 1, initialise_instance);
vc_vchi_gencmd_init(initialise_instance, &connection, 1);
vc_vchi_filesys_init(initialise_instance, &connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
printf("vcilcs_config\n");
vcilcs_config(&config);
printf("ilcs_init\n");
il_service_global = ilcs_init(vchiq_instance, &config, 0, host_OMX_SetILCSState);
printf("do_stripes\n");
do_stripes_default();
printf("do_blocks_test\n");
do_blocks_test();
printf("do_playback_api_test\n");
do_playback_api_test();
return 0;
}
void vcos_ctor(void)
{
vcos_init();
}
static void crt_rpi_switch(int width, int height, float hz)
{
char buffer[1024];
VCHI_INSTANCE_T vchi_instance;
VCHI_CONNECTION_T *vchi_connection = NULL;
static char output[250] = {0};
static char output1[250] = {0};
static char output2[250] = {0};
static char set_hdmi[250] = {0};
static char set_hdmi_timing[250] = {0};
int i = 0;
int hfp = 0;
int hsp = 0;
int hbp = 0;
int vfp = 0;
int vsp = 0;
int vbp = 0;
int hmax = 0;
int vmax = 0;
int pdefault = 8;
int pwidth = 0;
float roundw = 0.0f;
float roundh = 0.0f;
float pixel_clock = 0;
int ip_flag = 0;
/* set core refresh from hz */
video_monitor_set_refresh_rate(hz);
/* following code is the mode line generator */
pwidth = width;
if (height < 400 && width > 400)
pwidth = width / 2;
roundw = roundf((float)pwidth / (float)height * 100) / 100;
if (height > width)
roundw = roundf((float)height / (float)width * 100) / 100;
if (roundw > 1.35)
roundw = 1.25;
if (roundw < 1.20)
roundw = 1.34;
hfp = width * 0.065;
hsp = width * 0.1433-hfp+(crt_center_adjust*4);
hbp = width * 0.3-hsp-hfp;
if (height < 241)
vmax = 261;
if (height < 241 && hz > 56 && hz < 58)
vmax = 280;
if (height < 241 && hz < 55)
vmax = 313;
if (height > 250 && height < 260 && hz > 54)
vmax = 296;
if (height > 250 && height < 260 && hz > 52 && hz < 54)
vmax = 285;
if (height > 250 && height < 260 && hz < 52)
vmax = 313;
if (height > 260 && height < 300)
vmax = 318;
if (height > 400 && hz > 56)
vmax = 533;
if (height > 520 && hz < 57)
vmax = 580;
if (height > 300 && hz < 56)
vmax = 615;
if (height > 500 && hz < 56)
vmax = 624;
if (height > 300)
pdefault = pdefault * 2;
vfp = (height + ((vmax - height) / 2) - pdefault) - height;
if (height < 300)
vsp = vfp + 3; /* needs to be 3 for progressive */
if (height > 300)
vsp = vfp + 6; /* needs to be 6 for interlaced */
vsp = 3;
vbp = (vmax-height)-vsp-vfp;
hmax = width+hfp+hsp+hbp;
if (height < 300)
{
pixel_clock = (hmax * vmax * hz) ;
ip_flag = 0;
}
if (height > 300)
{
pixel_clock = (hmax * vmax * (hz/2)) /2 ;
ip_flag = 1;
}
/* above code is the modeline generator */
snprintf(set_hdmi_timing, sizeof(set_hdmi_timing),
"hdmi_timings %d 1 %d %d %d %d 1 %d %d %d 0 0 0 %f %d %f 1 ",
width, hfp, hsp, hbp, height, vfp,vsp, vbp,
hz, ip_flag, pixel_clock);
vcos_init();
vchi_initialise(&vchi_instance);
vchi_connect(NULL, 0, vchi_instance);
vc_vchi_gencmd_init(vchi_instance, &vchi_connection, 1);
vc_gencmd(buffer, sizeof(buffer), set_hdmi_timing);
vc_gencmd_stop();
vchi_disconnect(vchi_instance);
snprintf(output1, sizeof(output1),
"tvservice -e \"DMT 87\" > /dev/null");
system(output1);
snprintf(output2, sizeof(output1),
"fbset -g %d %d %d %d 24 > /dev/null",
width, height, width, height);
system(output2);
}
int main( int argc, char **argv )
{
int instNum = 0;
VCHI_INSTANCE_T vchi_instance;
VCHI_CONNECTION_T *vchi_connection = NULL;
if ( argc > 1 )
{
if (( strcmp( argv[1], "0" ) == 0 ) || ( strcmp( argv[1], "1" ) == 0 ))
{
instNum = atoi( argv[1] );
argv++;
argc--;
}
}
vcos_init();
if ( vchi_initialise( &vchi_instance ) != 0)
{
printf( "VCHI initialization failed\n" );
return -1;
}
//create a vchi connection
if ( vchi_connect( NULL, 0, vchi_instance ) != 0)
{
printf( "VCHI connection failed\n" );
return -1;
}
vc_vchi_gencmd_init(vchi_instance, &vchi_connection, 1 );
if (argc > 1)
{
int i = 1;
char buffer[ 1024 ];
size_t buffer_offset = 0;
clock_t before=0, after=0;
double time_diff;
uint32_t show_time = 0;
int ret;
//reset the string
buffer[0] = '\0';
//first, strip out a potential leading -t
if( strcmp( argv[1], "-t" ) == 0 )
{
show_time = 1;
i++;
}
for (; i <= argc-1; i++)
{
buffer_offset = vcos_safe_strcpy( buffer, argv[i], sizeof(buffer), buffer_offset );
buffer_offset = vcos_safe_strcpy( buffer, " ", sizeof(buffer), buffer_offset );
}
if( show_time )
before = clock();
//send the gencmd for the argument
if (( ret = vc_gencmd_send( "%s", buffer )) != 0 )
{
printf( "vc_gencmd_send returned %d\n", ret );
}
//get + print out the response!
if (( ret = vc_gencmd_read_response( buffer, sizeof( buffer ) )) != 0 )
{
printf( "vc_gencmd_read_response returned %d\n", ret );
}
if( show_time )
after = clock();
if( show_time )
{
time_diff = ((double) (after - before)) / CLOCKS_PER_SEC;
printf( "Time took %f seconds (%f msecs) (%f usecs)\n", time_diff, time_diff * 1000, time_diff * 1000000 );
}
if ( buffer[0] != '\0' )
{
if ( buffer[ strlen( buffer) - 1] == '\n' )
{
fputs( buffer, stdout );
}
else
{
printf("%s\n", buffer );
}
}
}
vc_gencmd_stop();
//close the vchi connection
if ( vchi_disconnect( vchi_instance ) != 0)
{
printf( "VCHI disconnect failed\n" );
return -1;
}
return 0;
}
int main(int argc, const char **argv)
{
VCOS_THREAD_ATTR_T attrs;
int i;
vcos_init();
signal(SIGINT, test_signal_handler);
/* coverity[tainted_data] Ignore unnecessary warning about an attacker
* being able to pass an arbitrarily long "-vvvvv..." argument */
if (test_parse_cmdline(argc, argv))
return -1;
if (verbosity--)
{
static char value[512];
const char *levels[] = {"warn", "info", "trace"};
char *env = getenv("VC_LOGLEVEL");
if (verbosity >= MMAL_COUNTOF(levels)) verbosity = MMAL_COUNTOF(levels) - 1;
snprintf(value, sizeof(value)-1, "mmalplay:%s,mmal:%s,%s",
levels[verbosity], levels[verbosity], env ? env : "");
#ifdef WIN32
_putenv("VC_LOGLEVEL", value, 1);
#else
setenv("VC_LOGLEVEL", value, 1);
#endif
}
vcos_log_register("mmalplay", VCOS_LOG_CATEGORY);
LOG_INFO("MMAL Video Playback Test App");
vcos_thread_attr_init(&attrs);
for (i = 0; i < play_info_count; i++)
{
const char *uri = play_info[i].uri;
memcpy(play_info[i].name, THREAD_PREFIX, sizeof(THREAD_PREFIX));
if (strlen(uri) >= URI_FOR_THREAD_NAME_MAX)
uri += strlen(uri) - URI_FOR_THREAD_NAME_MAX;
strncat(play_info[i].name, uri, URI_FOR_THREAD_NAME_MAX);
vcos_mutex_create(&play_info[i].lock, "mmalplay");
play_info[i].options.render_layer = i;
if (vcos_thread_create(&play_info[i].thread, play_info[i].name, &attrs, mmal_playback, &play_info[i]) != VCOS_SUCCESS)
{
LOG_ERROR("Thread creation failure for URI %s", play_info[i].uri);
return -2;
}
}
if (sleepy_time != 0)
{
#ifdef WIN32
Sleep(sleepy_time);
#else
sleep(sleepy_time);
#endif
for (i = 0; i < play_info_count; i++)
{
vcos_mutex_lock(&play_info[i].lock);
if (play_info[i].ctx)
mmalplay_stop(play_info[i].ctx);
vcos_mutex_unlock(&play_info[i].lock);
}
}
LOG_TRACE("Waiting for threads to terminate");
for (i = 0; i < play_info_count; i++)
{
vcos_thread_join(&play_info[i].thread, NULL);
LOG_TRACE("Joined thread %d (%i)", i, play_info[i].status);
}
LOG_TRACE("Completed");
/* Check for errors */
for (i = 0; i < play_info_count; i++)
{
if (!play_info[i].status)
continue;
LOG_ERROR("Playback of %s failed (%i, %s)", play_info[i].uri,
play_info[i].status,
mmal_status_to_string(play_info[i].status));
fprintf(stderr, "playback of %s failed (%i, %s)\n", play_info[i].uri,
play_info[i].status,
mmal_status_to_string(play_info[i].status));
return play_info[i].status;
}
return 0;
}
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 );
}
int
vchiq_platform_vcos_init(void)
{
return (vcos_init() == VCOS_SUCCESS) ? 0 : EINVAL;
}
