static Bool uir_process(GF_TermExt *termext, u32 action, void *param)
{
const char *opt, *uifile;
GF_UIRecord *uir = termext->udta;
switch (action) {
case GF_TERM_EXT_START:
uir->term = (GF_Terminal *) param;
opt = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "Mode");
if (!opt) return 0;
uifile = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "File");
if (!opt) return 0;
if (!strcmp(opt, "Play")) {
uir->uif = gf_f64_open(uifile, "rb");
if (!uir->uif) return 0;
uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_READ);
termext->caps |= GF_TERM_EXTENSION_NOT_THREADED;
uir->evt_filter.on_event = uir_on_event_play;
uir->evt_filter.udta = uir;
gf_term_add_event_filter(uir->term, &uir->evt_filter);
uir_load_event(uir);
} else if (!strcmp(opt, "Record")) {
uir->uif = fopen(uifile, "wb");
if (!uir->uif) return 0;
uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_WRITE);
uir->evt_filter.on_event = uir_on_event_record;
uir->evt_filter.udta = uir;
gf_term_add_event_filter(uir->term, &uir->evt_filter);
} else {
return 0;
}
return 1;
case GF_TERM_EXT_STOP:
if (uir->uif) fclose(uir->uif);
if (uir->bs) gf_bs_del(uir->bs);
gf_term_remove_event_filter(uir->term, &uir->evt_filter);
uir->term = NULL;
/*auto-disable the plugin by default*/
gf_modules_set_option((GF_BaseInterface*)termext, "UIRecord", "Mode", "Disable");
break;
case GF_TERM_EXT_PROCESS:
/*flush all events until current time if reached*/
while (uir->evt_loaded && uir->ck && (uir->next_time <= gf_clock_time(uir->ck) )) {
uir->term->compositor->video_out->on_event(uir->term->compositor->video_out->evt_cbk_hdl, &uir->next_event);
uir_load_event(uir);
}
break;
}
return 0;
}
static Bool osd_process(GF_TermExt *termext, u32 action, void *param)
{
const char *opt;
GF_OSD *osd = termext->udta;
switch (action) {
case GF_TERM_EXT_START:
osd->term = (GF_Terminal *) param;
opt = gf_modules_get_option((GF_BaseInterface*)termext, "OSD", "Enabled");
if (opt && strcmp(opt, "yes")) return 0;
/*load scene*/
if (! osd_load_scene(osd)) return 0;
/*attach scene to compositor*/
gf_sc_register_extra_graph(osd->term->compositor, osd->odm->subscene->graph, 0);
/*we are not threaded*/
termext->caps |= GF_TERM_EXTENSION_NOT_THREADED;
osd->refresh_time_ms = 500;
osd->evt_filter.on_event = osd_on_event_play;
osd->evt_filter.udta = osd;
gf_term_add_event_filter(osd->term, &osd->evt_filter);
return 1;
case GF_TERM_EXT_STOP:
osd->text->string.vals[0] = NULL;
/*remove scene to compositor*/
gf_sc_register_extra_graph(osd->term->compositor, osd->odm->subscene->graph, 1);
gf_odm_disconnect(osd->odm, 1);
osd->odm = NULL;
gf_term_remove_event_filter(osd->term, &osd->evt_filter);
osd->term = NULL;
break;
case GF_TERM_EXT_PROCESS:
/*flush all events until current time if reached*/
if ((osd->visible->whichChoice==0) && gf_sys_get_rti(osd->refresh_time_ms, &osd->rti, 0)) {
sprintf(osd->statBuffer, "CPU %02d - FPS %02.2f - MEM "LLU" KB", osd->rti.process_cpu_usage, gf_sc_get_fps(osd->term->compositor, 0), osd->rti.process_memory/1000);
gf_node_dirty_set((GF_Node *) osd->text, GF_SG_NODE_DIRTY, 1);
}
break;
}
return 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;
}
static Bool avr_process ( GF_TermExt *termext, u32 action, void *param )
{
const char *opt;
GF_AVRedirect *avr = termext->udta;
switch ( action )
{
case GF_TERM_EXT_START:
avr->term = ( GF_Terminal * ) param;
opt = gf_modules_get_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_ENABLED_OPTION );
if ( !opt )
gf_modules_set_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_ENABLED_OPTION, "no" );
if ( !opt || strcmp ( opt, "yes" ) ) return 0;
opt = gf_modules_get_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_VIDEO_CODEC_OPTION );
avr->globalLock = gf_global_resource_lock("AVRedirect:output");
if (!avr->globalLock) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MODULE, ("Failed to lock global resource 'AVRedirect:output', another GPAC instance must be running, disabling AVRedirect\n"));
return 0;
}
/* must be called before using avcodec lib */
avcodec_init();
/* register all the codecs */
avcodec_register_all();
if ( !opt )
gf_modules_set_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_VIDEO_CODEC_OPTION, possibleCodecs );
{
if ( !opt )
{
avr->videoCodec = avcodec_find_encoder ( CODEC_ID_MPEG2VIDEO );
}
else if ( !strcmp ( "MPEG-1", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_MPEG1VIDEO );
}
else if ( !strcmp ( "MPEG-2", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_MPEG2VIDEO );
}
else if ( !strcmp ( "MPEG-4", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_MPEG4 );
}
else if ( !strcmp ( "MSMPEG-4", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_MSMPEG4V3 );
}
else if ( !strcmp ( "H263", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_H263 );
}
else if ( !strcmp ( "RV10", opt ) )
{
avr->videoCodec = avcodec_find_encoder ( CODEC_ID_RV10 );
}
else if ( !strcmp ( "H263P", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_H263P );
}
else if ( !strcmp ( "H263I", opt ) )
{
avr->videoCodec=avcodec_find_encoder ( CODEC_ID_H263I );
}
else if ( !strcmp( "MJPEG", opt))
{
avr->videoCodec=avcodec_find_encoder( CODEC_ID_MJPEG);
}
else
{
GF_LOG ( GF_LOG_ERROR, GF_LOG_MODULE, ( "[AVRedirect] Not a known Video codec : %s, using MPEG-2 video instead, %s\n", opt, possibleCodecs ) );
avr->videoCodec = avcodec_find_encoder ( CODEC_ID_MPEG2VIDEO );
}
}
#if REDIRECT_AV_AUDIO_ENABLED
avr->audioCodec = avcodec_find_encoder(CODEC_ID_MP2);
#endif
/*
opt = gf_modules_get_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_UDP_ADDRESS_OPTION);
if (!opt) {
gf_modules_set_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_UDP_ADDRESS_OPTION, DEFAULT_UDP_OUT_ADDRESS);
avr->udp_address = DEFAULT_UDP_OUT_ADDRESS;
GF_LOG ( GF_LOG_ERROR, GF_LOG_MODULE, ( "[AVRedirect] %s not set, using %s\n", AVR_UDP_ADDRESS_OPTION, DEFAULT_UDP_OUT_ADDRESS ) );
} else
avr->udp_address = opt;
opt = gf_modules_get_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_UDP_PORT_OPTION);
if (opt) {
char *endPtr = NULL;
unsigned int x = strtoul(opt, &endPtr, 10);
if (endPtr == opt || x > 65536) {
printf("Failed to parse : %s\n", opt);
opt = NULL;
} else
avr->udp_port = (u16) x;
}
if (!opt) {
gf_modules_set_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_UDP_PORT_OPTION, DEFAULT_UDP_OUT_PORT_STR);
GF_LOG ( GF_LOG_ERROR, GF_LOG_MODULE, ( "[AVRedirect] %s is not set or valid, using %s\n", AVR_UDP_PORT_OPTION, DEFAULT_UDP_OUT_PORT_STR ) );
avr->udp_port = DEFAULT_UDP_OUT_PORT;
}
*/
opt = gf_modules_get_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_DESTINATION);
if (!opt) {
gf_modules_set_option ( ( GF_BaseInterface* ) termext, moduleName, AVR_DESTINATION, AVR_DEFAULT_DESTINATION);
avr->destination = AVR_DEFAULT_DESTINATION;
GF_LOG ( GF_LOG_ERROR, GF_LOG_MODULE, ( "[AVRedirect] %s not set, using %s\n", AVR_DESTINATION, AVR_DEFAULT_DESTINATION ) );
} else
avr->destination = opt;
avr->audio_listen.udta = avr;
avr->audio_listen.on_audio_frame = avr_on_audio_frame;
avr->audio_listen.on_audio_reconfig = avr_on_audio_reconfig;
avr->video_listen.udta = avr;
avr->video_listen.on_video_frame = avr_on_video_frame;
avr->video_listen.on_video_reconfig = avr_on_video_reconfig;
avr->term_listen.udta = avr;
avr->term_listen.on_event = avr_on_event;
gf_term_add_event_filter ( avr->term, &avr->term_listen );
return 1;
case GF_TERM_EXT_STOP:
gf_term_remove_event_filter ( avr->term, &avr->term_listen );
avr->term = NULL;
break;
/*if not threaded, perform our tasks here*/
case GF_TERM_EXT_PROCESS:
break;
}
return 0;
}
