//-------------------------------
void CNativeWrapper::Shutdown()
{
debug_log("shutdown");
if (m_term)
gf_term_disconnect(m_term);
if (m_mx)
gf_mx_del(m_mx);
m_mx = NULL;
#ifndef GPAC_GUI_ONLY
if (m_term) {
GF_Terminal *t = m_term;
m_term = NULL;
gf_term_del(t);
}
if (m_user.config) {
gf_cfg_del(m_user.config);
m_user.config = NULL;
}
if (m_user.modules) {
gf_modules_del(m_user.modules);
m_user.modules = NULL;
}
#endif
m_term = NULL;
gf_sys_close();
debug_log("shutdown end");
}
//-----------------------------------------------------
void CNativeWrapper::disconnect() {
if (m_term) {
debug_log("disconnecting");
gf_term_disconnect(m_term);
debug_log("disconnected ...");
}
}
Bool player(char *fn)
{
Bool ret = GF_FALSE;
GF_Err e;
GF_User user;
GF_Terminal *term = NULL;
GF_Config *cfg_file;
memset(&user, 0, sizeof(user));
cfg_file = gf_cfg_init(NULL, NULL);
user.modules = gf_modules_new(NULL, cfg_file);
e = manually_register_opengl_shared_module(user.modules);
if (e != GF_OK) goto exit;
set_cfg_option(cfg_file, "Video:DriverName=" OPENGL_SHARED_MODULE_NAME_STR);
user.config = cfg_file;
user.opaque = &user;
user.EventProc = event_proc;
term = gf_term_new(&user);
if (!term) goto exit;
gf_term_connect(term, fn);
while (!connected) gf_sleep(1);
while ( connected) {
gf_term_process_step(term);
check_keyboard(term);
}
ret = GF_TRUE;
exit:
gf_term_disconnect(term);
gf_term_del(term);
gf_modules_del(user.modules);
gf_cfg_del(cfg_file);
return ret;
}
static Bool player_foreach(int argc, char **argv)
{
int i;
GF_User user;
GF_Terminal *term;
GF_Config *cfg_file;
cfg_file = gf_cfg_init("GPAC.cfg", NULL);
user.modules = gf_modules_new(NULL, cfg_file);
user.config = cfg_file;
user.EventProc = GPAC_EventProc;
term = gf_term_new(&user);
if (!term)
return GF_FALSE;
for (i=0; i<argc; ++i) {
Bool res = play_pause_seek_gettime(term, argv[i]);
if (res == GF_FALSE) {
fprintf(stderr, "Failure with input %d: \"%s\"\n", i, argv[i]);
return GF_FALSE;
}
}
gf_term_disconnect(term);
gf_term_del(term);
gf_modules_del(user.modules);
gf_cfg_del(cfg_file);
return GF_TRUE;
}
void CMainFrame::OnFileStop()
{
COsmo4 *app = GetApp();
if (!app->m_open) return;
if (m_full_screen) OnViewFullscreen();
app->m_stoped = 1;
if (m_view_timing) KillTimer(PROGRESS_TIMER);
gf_term_disconnect(app->m_term);
m_progBar.SetPosition(0);
app->SetBacklightState(0);
SetPauseButton();
}
void CMainFrame::CloseURL()
{
COsmo4 *app = GetApp();
if (!app->m_open) return;
if (m_view_timing) KillTimer(PROGRESS_TIMER);
gf_term_disconnect(app->m_term);
app->m_open = 0;
app->m_can_seek = 0;
app->m_duration = (u32) -1;
m_progBar.m_prev_time = 0;
m_progBar.SetPosition(0);
}
static Bool validator_process(GF_TermExt *termext, u32 action, void *param)
{
const char *opt;
GF_Validator *validator = termext->udta;
switch (action) {
/* Upon starting of the terminal, we parse (possibly an XVL file), an XVS file, and start the first test sequence */
case GF_TERM_EXT_START:
validator->term = (GF_Terminal *) param;
/* if the validator is loaded, we switch off anti-aliasing for image comparison and we put a low framerate,
but we store the previous value to restore it upon termination of the validator */
opt = (char *)gf_modules_get_option((GF_BaseInterface*)termext, "Compositor", "FrameRate");
if (opt) validator->prev_fps = gf_strdup(opt);
opt = (char *)gf_modules_get_option((GF_BaseInterface*)termext, "Compositor", "AntiAlias");
if (opt) validator->prev_alias = gf_strdup(opt);
/* Check if the validator should be loaded and in which mode */
opt = gf_modules_get_option((GF_BaseInterface*)termext, "Validator", "Mode");
if (!opt) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("Validator missing configuration, stopping.\n"));
return 0;
} else if (!strcmp(opt, "Play")) {
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator starting in playback mode.\n"));
validator->is_recording = 0;
} else if (!strcmp(opt, "Record")) {
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator starting in recording mode.\n"));
validator->is_recording = 1;
} else if (!strcmp(opt, "Disable")) {
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator is disabled.\n"));
return 0;
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Validator configuration using wrong mode, stopping.\n"));
return 0;
}
/* initializes the validator and starts */
validator->xvs_filename = NULL;
validator->xvl_filename = (char *)gf_modules_get_option((GF_BaseInterface*)termext, "Validator", "XVL");
if (!validator->xvl_filename) {
validator->xvs_filename = (char *)gf_modules_get_option((GF_BaseInterface*)termext, "Validator", "XVS");
if (!validator->xvs_filename) {
validator->xvs_filename = (char *)gf_modules_get_option((GF_BaseInterface*)termext, "Validator", "Trace");
if (!validator->xvs_filename) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Validator configuration without input, stopping.\n"));
return 0;
}
validator->test_filename = validator->xvs_filename;
validator->trace_mode = 1;
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator using trace file: %s\n", validator->xvs_filename));
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator using scenario file: %s\n", validator->xvs_filename));
}
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Validator using scenario playlist: %s\n", validator->xvl_filename));
}
/* since we changed parameters of the compositor, we need to trigger a reconfiguration */
// gf_modules_set_option((GF_BaseInterface*)termext, "Compositor", "FrameRate", "5.0");
// gf_modules_set_option((GF_BaseInterface*)termext, "Compositor", "AntiAlias", "None");
// gf_term_set_option(validator->term, GF_OPT_RELOAD_CONFIG, 1);
/* TODO: if start returns 0, the module is not loaded, so the above init (filter registration) is not removed,
should probably return 1 all the time, to make sure stop is called */
if (validator->xvl_filename) {
validator_xvl_open(validator);
if (!validator->xvl_node) {
return 0;
}
validator_xvs_next(validator, 0);
if (!validator->xvs_node) {
return 0;
}
} else if (validator->xvs_filename) {
validator_xvs_open(validator);
if (!validator->xvs_node) {
return 0;
}
if (validator->test_filename) {
validator_test_open(validator);
} else {
validator_xvs_close(validator);
return 0;
}
} else {
return 0;
}
validator->evt_filter.udta = validator;
if (!validator->is_recording) {
validator->evt_filter.on_event = validator_on_event_play;
termext->caps |= GF_TERM_EXTENSION_NOT_THREADED;
} else {
validator->evt_filter.on_event = validator_on_event_record;
}
gf_term_add_event_filter(validator->term, &validator->evt_filter);
validator->video_listener.udta = validator;
validator->video_listener.on_video_frame = validator_on_video_frame;
validator->video_listener.on_video_reconfig = validator_on_video_reconfig;
if (!validator->is_recording) {
validator_load_event(validator);
}
return 1;
/* when the terminal stops, we close the XVS parser and XVL parser if any, restore the config,
and free all validator data (the validator will be destroyed when the module is unloaded)
Note: we don't need to disconnect the terminal since it's already stopping */
case GF_TERM_EXT_STOP:
gf_term_remove_event_filter(validator->term, &validator->evt_filter);
validator_xvs_close(validator);
validator_xvl_close(validator);
validator->term = NULL;
if (validator->test_base) {
gf_free(validator->test_base);
validator->test_base = NULL;
}
/*auto-disable the recording by default*/
if (!validator->trace_mode) {
if (validator->is_recording ) {
gf_modules_set_option((GF_BaseInterface*)termext, "Validator", "Mode", "Play");
} else {
gf_modules_set_option((GF_BaseInterface*)termext, "Validator", "Mode", "Disable");
}
}
GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("Stopping validator\n"));
if (validator->prev_fps) {
gf_modules_set_option((GF_BaseInterface*)termext, "Compositor", "FrameRate", validator->prev_fps);
gf_free(validator->prev_fps);
validator->prev_fps = NULL;
}
if (validator->prev_alias) {
gf_modules_set_option((GF_BaseInterface*)termext, "Compositor", "AntiAlias", validator->prev_alias);
gf_free(validator->prev_alias);
validator->prev_alias = NULL;
}
break;
/* When called in the main loop of the terminal, we don't do anything in the recording mode.
In the playing/validating mode, we need to check if an event needs to be dispatched or if snapshots need to be made,
until there is no more event, in which case we trigger either the load of the next XVS or the quit */
case GF_TERM_EXT_PROCESS:
/* if the time is right, dispatch the event and load the next one */
while (!validator->is_recording && validator->evt_loaded && validator->ck && (validator->next_time <= gf_clock_time(validator->ck) )) {
Bool has_more_events;
//u32 diff = gf_clock_time(validator->ck) - validator->next_time;
//GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("[Validator] Time diff: evt_time=%d clock_time = %d, diff=%d\n", validator->next_time, gf_clock_time(validator->ck), diff));
if (validator->next_event_snapshot) {
Bool res;
char *snap_name = validator_create_snapshot(validator);
gf_free(snap_name);
res = validator_compare_snapshots(validator);
validator->xvs_result &= res;
validator->next_event_snapshot = 0;
} else {
validator->term->compositor->video_out->on_event(validator->term->compositor->video_out->evt_cbk_hdl, &validator->next_event);
}
has_more_events = validator_load_event(validator);
if (!has_more_events) {
validator_xvs_close(validator);
if (! validator->trace_mode) {
gf_term_disconnect(validator->term);
gf_sc_remove_video_listener(validator->term->compositor, &validator->video_listener);
validator_xvs_next(validator, 0);
if (!validator->xvs_node) {
GF_Event evt;
memset(&evt, 0, sizeof(GF_Event));
evt.type = GF_EVENT_QUIT;
validator->term->compositor->video_out->on_event(validator->term->compositor->video_out->evt_cbk_hdl, &evt);
} else {
if (!validator->is_recording) {
validator_load_event(validator);
}
}
}
}
}
break;
}
return 0;
}
Bool validator_on_event_record(void *udta, GF_Event *event, Bool consumed_by_compositor)
{
GF_Validator *validator = (GF_Validator *)udta;
Bool rec_event = 1;
switch (event->type) {
case GF_EVENT_CONNECT:
if (event->connect.is_connected) {
if (!validator->trace_mode) {
gf_sc_add_video_listener(validator->term->compositor, &validator->video_listener);
}
validator->ck = validator->term->root_scene->scene_codec ? validator->term->root_scene->scene_codec->ck : validator->term->root_scene->dyn_ck;
}
break;
case GF_EVENT_KEYDOWN:
if (event->key.key_code == GF_KEY_INSERT) {
rec_event = 0;
} else if (event->key.key_code == GF_KEY_PAGEDOWN) {
rec_event = 0;
} else if (event->key.key_code == GF_KEY_PAGEUP) {
rec_event = 0;
} else if (event->key.key_code == GF_KEY_END) {
rec_event = 0;
} else if (event->key.key_code == GF_KEY_CONTROL) {
rec_event = 0;
} else if (event->key.flags & GF_KEY_MOD_CTRL) {
rec_event = 0;
}
break;
case GF_EVENT_KEYUP:
if (event->key.flags & GF_KEY_MOD_CTRL) {
rec_event = 0;
if (event->key.key_code == GF_KEY_INSERT) {
char *snap_name = validator_create_snapshot(validator);
validator_xvs_add_snapshot_node(validator, snap_name, gf_clock_time(validator->ck));
gf_free(snap_name);
} else if (event->key.key_code == GF_KEY_END) {
GF_Event evt;
memset(&evt, 0, sizeof(GF_Event));
evt.type = GF_EVENT_QUIT;
validator->term->compositor->video_out->on_event(validator->term->compositor->video_out->evt_cbk_hdl, &evt);
} else if (event->key.key_code == GF_KEY_F1) {
validator->snapshot_next_frame = 1;
}
} else if (event->key.key_code == GF_KEY_PAGEDOWN) {
rec_event = 0;
validator_xvs_close(validator);
gf_term_disconnect(validator->term);
gf_sc_remove_video_listener(validator->term->compositor, &validator->video_listener);
validator_xvs_next(validator, 0);
} else if (event->key.key_code == GF_KEY_PAGEUP) {
rec_event = 0;
validator_xvs_close(validator);
gf_term_disconnect(validator->term);
gf_sc_remove_video_listener(validator->term->compositor, &validator->video_listener);
validator_xvs_next(validator, 1);
} else if (event->key.key_code == GF_KEY_CONTROL) {
rec_event = 0;
}
break;
}
if (rec_event) {
validator_xvs_add_event_dom(validator, event);
}
return 0;
}
STDMETHODIMP CGPAXPlugin::Stop()
{
if(m_term) gf_term_disconnect(m_term); //set it stop
return S_OK;
}
