static GF_Err HEVC_AttachStream(GF_BaseDecoder *ifcg, GF_ESD *esd)
{
GF_SystemRTInfo rti;
const char *sOpt;
u32 nb_threads = 1;
HEVCDec *ctx = (HEVCDec*) ifcg->privateStack;
if (gf_sys_get_rti(0, &rti, 0) ) {
nb_threads = (rti.nb_cores>1) ? rti.nb_cores-1 : 1;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "NumThreads");
if (!sOpt) {
char szO[100];
sprintf(szO, "%d", nb_threads);
gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "NumThreads", szO);
ctx->nb_threads = nb_threads;
GF_LOG(GF_LOG_INFO, GF_LOG_CODEC, ("[OpenHEVC] Initializing with %d threads\n", ctx->nb_threads));
} else {
ctx->nb_threads = atoi(sOpt);
if (ctx->nb_threads > nb_threads) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[OpenHEVC] Initializing with %d threads but only %d available cores detected on the system\n", ctx->nb_threads, rti.nb_cores));
}
}
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "ThreadingType");
if (sOpt && !strcmp(sOpt, "wpp")) ctx->threading_type = 2;
else if (sOpt && !strcmp(sOpt, "frame+wpp")) ctx->threading_type = 4;
else {
ctx->threading_type = 1;
if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "ThreadingType", "frame");
}
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "Systems", "Output8bit");
if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "Systems", "Output8bit", (ctx->display_bpp>8) ? "no" : "yes");
if (sOpt && !strcmp(sOpt, "yes")) ctx->output_as_8bit = GF_TRUE;
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "CBUnits");
if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "CBUnits", "4");
if (sOpt) ctx->output_cb_size = atoi(sOpt);
if (!ctx->output_cb_size) ctx->output_cb_size = 4;
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "PackHFR");
if (sOpt && !strcmp(sOpt, "yes") ) ctx->pack_mode = GF_TRUE;
else if (!sOpt) gf_modules_set_option((GF_BaseInterface *)ifcg, "OpenHEVC", "PackHFR", "no");
if (!ctx->raw_out) {
sOpt = gf_modules_get_option((GF_BaseInterface *)ifcg, "OpenHEVC", "InputRipFile");
if (sOpt) ctx->raw_out = fopen(sOpt, "wb");
}
/*RTP case: configure enhancement now*/
if (esd->dependsOnESID) {
HEVC_ConfigurationScalableStream(ctx, esd);
return GF_OK;
}
ctx->esd = esd;
return HEVC_ConfigureStream(ctx, esd);
}
static void dd_init_gl_offscreen(GF_VideoOutput *driv)
{
const char *opt;
DDContext *dd = driv->opaque;
opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode");
#ifndef _WIN32_WCE
wglCreatePbufferARB = (CREATEPBUFFERARB) wglGetProcAddress("wglCreatePbufferARB");
if (opt && strcmp(opt, "PBuffer")) wglCreatePbufferARB = NULL;
if (wglCreatePbufferARB) {
wglChoosePixelFormatARB = (CHOOSEPFFORMATARB) wglGetProcAddress("wglChoosePixelFormatARB");
wglDestroyPbufferARB = (DESTROYBUFFERARB) wglGetProcAddress("wglDestroyPbufferARB");
wglGetPbufferDCARB = (GETPBUFFERDCARB ) wglGetProcAddress("wglGetPbufferDCARB");
wglReleasePbufferDCARB = (RELEASEPBUFFERDCARB ) wglGetProcAddress("wglReleasePbufferDCARB");
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX] Using PBuffer for OpenGL Offscreen Rendering\n"));
driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA;
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode", "PBuffer");
} else
#endif
{
u32 gl_type = 1;
HINSTANCE hInst;
#ifndef _WIN32_WCE
hInst = GetModuleHandle("gm_dx_hw.dll");
#else
hInst = GetModuleHandle(_T("gm_dx_hw.dll"));
#endif
opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode");
if (opt) {
if (!strcmp(opt, "Window")) gl_type = 1;
else if (!strcmp(opt, "VisibleWindow")) gl_type = 2;
else gl_type = 0;
} else {
gf_modules_set_option((GF_BaseInterface *)driv, "Video", "GLOffscreenMode", "Window");
}
if (gl_type) {
#ifdef _WIN32_WCE
dd->gl_hwnd = CreateWindow(_T("GPAC DirectDraw Output"), _T("GPAC OpenGL Offscreen"), WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL);
#else
dd->gl_hwnd = CreateWindow("GPAC DirectDraw Output", "GPAC OpenGL Offscreen", WS_POPUP, 0, 0, 120, 100, NULL, NULL, hInst, NULL);
#endif
if (!dd->gl_hwnd)
return;
ShowWindow(dd->gl_hwnd, (gl_type == 2) ? SW_SHOW : SW_HIDE);
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX] Using %s window for OpenGL Offscreen Rendering\n", (gl_type == 2) ? "Visible" : "Hidden"));
driv->hw_caps |= GF_VIDEO_HW_OPENGL_OFFSCREEN | GF_VIDEO_HW_OPENGL_OFFSCREEN_ALPHA;
}
}
}
void VTT_load_script(VTTDec *vttdec, GF_SceneGraph *graph)
{
GF_Node *n, *root;
GF_FieldInfo info;
const char *path;
FILE *jsfile;
if (!graph) return;
gf_sg_add_namespace(graph, "http://www.w3.org/2000/svg", NULL);
gf_sg_add_namespace(graph, "http://www.w3.org/1999/xlink", "xlink");
gf_sg_add_namespace(graph, "http://www.w3.org/2001/xml-events", "ev");
gf_sg_set_scene_size_info(graph, 800, 600, GF_TRUE);
/* modify the scene with an Inline/Animation pointing to the VTT Renderer */
n = root = gf_node_new(graph, TAG_SVG_svg);
gf_node_register(root, NULL);
gf_sg_set_root_node(graph, root);
gf_node_get_attribute_by_name(n, "xmlns", 0, GF_TRUE, GF_FALSE, &info);
gf_svg_parse_attribute(n, &info, "http://www.w3.org/2000/svg", 0);
VTT_UpdateSizeInfo(vttdec);
gf_node_init(n);
n = gf_node_new(graph, TAG_SVG_script);
gf_node_register(n, root);
gf_node_list_add_child(&((GF_ParentNode *)root)->children, n);
path = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript");
if (!path) {
/* try to find the JS renderer in the default GPAC installation folder */
const char *startuppath = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "General", "StartupFile");
path = gf_url_concatenate(startuppath, "webvtt-renderer.js");
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_modules_set_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript", path);
gf_fclose(jsfile);
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot find Rendering Script [WebVTT:RenderingScript] - check config file\n"));
return;
}
}
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_fclose(jsfile);
gf_node_get_attribute_by_tag(n, TAG_XLINK_ATT_href, GF_TRUE, GF_FALSE, &info);
if (strstr(path, ":\\")) {
gf_svg_parse_attribute(n, &info, (char *) path, 0);
} else {
char szPath[GF_MAX_PATH];
strcpy(szPath, "file://");
strcat(szPath, path);
gf_svg_parse_attribute(n, &info, (char *) szPath, 0);
}
vttdec->has_rendering_script = GF_TRUE;
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot open Rendering Script - %s\n", path));
return;
}
gf_node_init(n);
}
static GF_Err ALSA_Setup(GF_AudioOutput*dr, void *os_handle, u32 num_buffers, u32 total_duration)
{
int err;
const char *opt;
ALSAContext *ctx = (ALSAContext*)dr->opaque;
opt = gf_modules_get_option((GF_BaseInterface *)dr, "ALSA", "ForceSampleRate");
if (opt) ctx->force_sr = atoi(opt);
ctx->dev_name = gf_modules_get_option((GF_BaseInterface *)dr, "ALSA", "DeviceName");
if (!ctx->dev_name) {
ctx->dev_name = "hw:0,0";
gf_modules_set_option((GF_BaseInterface *)dr, "ALSA", "DeviceName", ctx->dev_name);
}
/*test device*/
err = snd_pcm_open(&ctx->playback_handle, ctx->dev_name, SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[ALSA] Cannot open audio device %s: %s\n", ctx->dev_name, snd_strerror (err)) );
return GF_IO_ERR;
}
ctx->num_buffers = num_buffers;
ctx->total_duration = total_duration;
return GF_OK;
}
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;
}
void *SDL_NewVideo()
{
SDLVidCtx *ctx;
GF_VideoOutput *driv;
driv = gf_malloc(sizeof(GF_VideoOutput));
memset(driv, 0, sizeof(GF_VideoOutput));
GF_REGISTER_MODULE_INTERFACE(driv, GF_VIDEO_OUTPUT_INTERFACE, "SDL Video Output", "gpac distribution");
ctx = gf_malloc(sizeof(SDLVidCtx));
memset(ctx, 0, sizeof(SDLVidCtx));
#ifdef SDL_WINDOW_THREAD
ctx->sdl_th = gf_th_new("SDLVideo");
#endif
ctx->evt_mx = gf_mx_new("SDLEvents");
driv->opaque = ctx;
driv->Setup = SDLVid_Setup;
driv->Shutdown = SDLVid_Shutdown;
driv->SetFullScreen = SDLVid_SetFullScreen;
driv->Flush = SDLVid_Flush;
driv->ProcessEvent = SDLVid_ProcessEvent;
/*no offscreen opengl with SDL*/
driv->hw_caps |= GF_VIDEO_HW_OPENGL;
/*no YUV hardware blitting in SDL (only overlays)*/
driv->hw_caps |= GF_VIDEO_HW_HAS_YUV_OVERLAY | GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA;
driv->Blit = SDL_Blit;
driv->LockBackBuffer = SDLVid_LockBackBuffer;
driv->LockOSContext = NULL;
/*color keying with overlays are not supported in SDL ...*/
#if 0
/*get YUV overlay key*/
opt = gf_modules_get_option((GF_BaseInterface *)driv, "Video", "OverlayColorKey");
/*no set is the default*/
if (!opt) {
opt = "0101FE";
gf_modules_set_option((GF_BaseInterface *)driv, "Video", "OverlayColorKey", "0101FE");
}
sscanf(opt, "%06x", &driv->overlay_color_key);
if (driv->overlay_color_key) driv->overlay_color_key |= 0xFF000000;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[SDL Out] YUV Overlays enabled - ColorKey enabled: %s (key %x)\n",
driv->overlay_color_key ? "Yes" : "No", driv->overlay_color_key
));
#endif
#ifndef SDL_TEXTINPUTEVENT_TEXT_SIZE
SDL_EnableUNICODE(1);
#else
SDL_StartTextInput();
#endif /* SDL_TEXTINPUTEVENT_TEXT_SIZE */
return driv;
}
static GF_Err SVG_AttachStream(GF_BaseDecoder *plug, GF_ESD *esd)
{
const char *sOpt;
GF_BitStream *bs;
SVGIn *svgin = (SVGIn *)plug->privateStack;
if (esd->decoderConfig->upstream) return GF_NOT_SUPPORTED;
svgin->loader.type = GF_SM_LOAD_SVG;
/* decSpecInfo is not null only when reading from an SVG file (local or distant, cached or not) */
switch (esd->decoderConfig->objectTypeIndication) {
case GPAC_OTI_SCENE_SVG:
case GPAC_OTI_SCENE_SVG_GZ:
svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING;
/*no decSpecInfo defined for streaming svg yet*/
break;
case GPAC_OTI_SCENE_DIMS:
svgin->loader.type = GF_SM_LOAD_DIMS;
svgin->loader.flags |= GF_SM_LOAD_CONTEXT_STREAMING;
/*decSpecInfo not yet supported for DIMS svg - we need properties at the scene level to store the
various indications*/
break;
case GPAC_OTI_PRIVATE_SCENE_SVG:
default:
if (!esd->decoderConfig->decoderSpecificInfo) return GF_NON_COMPLIANT_BITSTREAM;
bs = gf_bs_new(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, GF_BITSTREAM_READ);
svgin->file_size = gf_bs_read_u32(bs);
svgin->file_pos = 0;
gf_bs_del(bs);
svgin->file_name = (char *) gf_malloc(sizeof(char)*(1 + esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32)) );
memcpy(svgin->file_name, esd->decoderConfig->decoderSpecificInfo->data + sizeof(u32), esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) );
svgin->file_name[esd->decoderConfig->decoderSpecificInfo->dataLength - sizeof(u32) ] = 0;
break;
}
svgin->oti = esd->decoderConfig->objectTypeIndication;
if (!esd->dependsOnESID) svgin->base_es_id = esd->ESID;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "Progressive");
if (sOpt && !strcmp(sOpt, "yes")) {
svgin->sax_max_duration = 30;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration");
if (sOpt) {
svgin->sax_max_duration = atoi(sOpt);
} else {
svgin->sax_max_duration = 30;
gf_modules_set_option((GF_BaseInterface *)plug, "SAXLoader", "MaxDuration", "30");
}
} else {
svgin->sax_max_duration = (u32) -1;
}
return GF_OK;
}
GF_EXPORT
void gf_term_register_mime_type(const GF_InputService *ifce, const char *mimeType, const char *extList, const char *description)
{
u32 len;
char *buf;
if (!ifce || !mimeType || !extList || !description) return;
len = (u32) strlen(extList) + 3 + (u32) strlen(description) + 3 + (u32) strlen(ifce->module_name) + 1;
buf = (char*)gf_malloc(sizeof(char)*len);
sprintf(buf, "\"%s\" ", extList);
strlwr(buf);
strcat(buf, "\"");
strcat(buf, description);
strcat(buf, "\" ");
strcat(buf, ifce->module_name);
gf_modules_set_option((GF_BaseInterface *)(GF_BaseInterface *)ifce, "MimeTypes", mimeType, buf);
gf_free(buf);
}
static void SetWindowless(GF_VideoOutput *vout, HWND hWnd)
{
const char *opt;
u32 a, r, g, b;
COLORREF ckey;
typSetLayeredWindowAttributes _SetLayeredWindowAttributes;
HMODULE hUser32;
u32 isWin2K;
OSVERSIONINFO Version = {sizeof(OSVERSIONINFO)};
GetVersionEx(&Version);
isWin2K = (Version.dwPlatformId == VER_PLATFORM_WIN32_NT && Version.dwMajorVersion >= 5);
if (!isWin2K) return;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX Out] Enabling windowless mode\n"));
hUser32 = GetModuleHandle("USER32.DLL");
if (hUser32 == NULL) return;
_SetLayeredWindowAttributes = (typSetLayeredWindowAttributes) GetProcAddress(hUser32,"SetLayeredWindowAttributes");
if (_SetLayeredWindowAttributes == NULL) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MMIO, ("[DX Out] Win32 layered windows not supported\n"));
return;
}
SetWindowLong(hWnd, GWL_EXSTYLE, GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
/*get background ckey*/
opt = gf_modules_get_option((GF_BaseInterface *)vout, "Rendering", "ColorKey");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)vout, "Rendering", "ColorKey", "FFFEFEFE");
opt = "FFFEFEFE";
}
sscanf(opt, "%02X%02X%02X%02X", &a, &r, &g, &b);
ckey = RGB(r, g, b);
if (a<255)
_SetLayeredWindowAttributes(hWnd, ckey, (u8) a, LWA_COLORKEY|LWA_ALPHA);
else
_SetLayeredWindowAttributes(hWnd, ckey, 0, LWA_COLORKEY);
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DX Out] Using color key %s\n", opt));
}
void isor_declare_objects(ISOMReader *read)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
const char *tag;
u32 i, count, ocr_es_id, tlen, base_track, j, track_id;
Bool highest_stream;
char *opt;
Bool add_ps_lower = GF_TRUE;
ocr_es_id = 0;
opt = (char*) gf_modules_get_option((GF_BaseInterface *)read->input, "ISOReader", "DeclareScalableXPS");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)read->input, "ISOReader", "DeclareScalableXPS", "yes");
} else if (!strcmp(opt, "no")) {
add_ps_lower = GF_FALSE;
}
/*TODO check for alternate tracks*/
count = gf_isom_get_track_count(read->mov);
for (i=0; i<count; i++) {
if (!gf_isom_is_track_enabled(read->mov, i+1)) continue;
switch (gf_isom_get_media_type(read->mov, i+1)) {
case GF_ISOM_MEDIA_AUDIO:
case GF_ISOM_MEDIA_VISUAL:
case GF_ISOM_MEDIA_TEXT:
case GF_ISOM_MEDIA_SUBT:
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_SUBPIC:
break;
default:
continue;
}
/*we declare only the highest video track (i.e the track we play)*/
highest_stream = GF_TRUE;
track_id = gf_isom_get_track_id(read->mov, i+1);
for (j = 0; j < count; j++) {
if (gf_isom_has_track_reference(read->mov, j+1, GF_ISOM_REF_SCAL, track_id) > 0) {
highest_stream = GF_FALSE;
break;
}
}
if ((gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_VISUAL) && !highest_stream)
continue;
esd = gf_media_map_esd(read->mov, i+1);
if (esd) {
gf_isom_get_reference(read->mov, i+1, GF_ISOM_REF_BASE, 1, &base_track);
esd->has_ref_base = base_track ? GF_TRUE : GF_FALSE;
/*FIXME: if we declare only SPS/PPS of the highest layer, we have a problem in decoding even though we have all SPS/PPS inband (OpenSVC bug ?)*/
/*so we add by default the SPS/PPS of the lower layers to this esd*/
if (esd->has_ref_base && add_ps_lower) {
u32 count, refIndex, ref_track, num_sps, num_pps, t;
GF_AVCConfig *cfg = gf_odf_avc_cfg_read(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
GF_AVCConfig *avccfg, *svccfg;
count = gf_isom_get_reference_count(read->mov, i+1, GF_ISOM_REF_SCAL);
for (refIndex = count; refIndex != 0; refIndex--) {
gf_isom_get_reference(read->mov, i+1, GF_ISOM_REF_SCAL, refIndex, &ref_track);
avccfg = gf_isom_avc_config_get(read->mov, ref_track, 1);
svccfg = gf_isom_svc_config_get(read->mov, ref_track, 1);
if (avccfg) {
num_sps = gf_list_count(avccfg->sequenceParameterSets);
for (t = 0; t < num_sps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(avccfg->sequenceParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->sequenceParameterSets, sl, 0);
}
num_pps = gf_list_count(avccfg->pictureParameterSets);
for (t = 0; t < num_sps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(avccfg->pictureParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->pictureParameterSets, sl, 0);
}
gf_odf_avc_cfg_del(avccfg);
}
if (svccfg) {
num_sps = gf_list_count(svccfg->sequenceParameterSets);
for (t = 0; t < num_sps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(svccfg->sequenceParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->sequenceParameterSets, sl, 0);
}
num_pps = gf_list_count(svccfg->pictureParameterSets);
for (t = 0; t < num_pps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(svccfg->pictureParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->pictureParameterSets, sl, 0);
}
gf_odf_avc_cfg_del(svccfg);
}
}
if (esd->decoderConfig->decoderSpecificInfo->data) gf_free(esd->decoderConfig->decoderSpecificInfo->data);
gf_odf_avc_cfg_write(cfg, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_odf_avc_cfg_del(cfg);
}
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->service_ifce = read->input;
od->objectDescriptorID = 0;
if (!ocr_es_id) ocr_es_id = esd->ESID;
esd->OCRESID = ocr_es_id;
gf_list_add(od->ESDescriptors, esd);
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, (GF_Descriptor*)od, NULL);
} else {
gf_term_add_media(read->service, (GF_Descriptor*)od, GF_TRUE);
}
}
}
/*if cover art, extract it in cache*/
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COVER_ART, &tag, &tlen)==GF_OK) {
const char *cdir = gf_modules_get_option((GF_BaseInterface *)gf_term_get_service_interface(read->service), "General", "CacheDirectory");
if (cdir) {
char szName[GF_MAX_PATH];
const char *sep;
FILE *t;
sep = strrchr(gf_isom_get_filename(read->mov), '\\');
if (!sep) sep = strrchr(gf_isom_get_filename(read->mov), '/');
if (!sep) sep = gf_isom_get_filename(read->mov);
if ((cdir[strlen(cdir)-1] != '\\') && (cdir[strlen(cdir)-1] != '/')) {
sprintf(szName, "%s/%s_cover.%s", cdir, sep, (tlen & 0x80000000) ? "png" : "jpg");
} else {
sprintf(szName, "%s%s_cover.%s", cdir, sep, (tlen & 0x80000000) ? "png" : "jpg");
}
t = gf_f64_open(szName, "wb");
if (t) {
Bool isom_contains_video = GF_FALSE;
/*write cover data*/
assert(!(tlen & 0x80000000));
gf_fwrite(tag, tlen & 0x7FFFFFFF, 1, t);
fclose(t);
/*don't display cover art when video is present*/
for (i=0; i<gf_isom_get_track_count(read->mov); i++) {
if (!gf_isom_is_track_enabled(read->mov, i+1))
continue;
if (gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_VISUAL) {
isom_contains_video = GF_TRUE;
break;
}
}
if (!isom_contains_video) {
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->service_ifce = read->input;
od->objectDescriptorID = GF_MEDIA_EXTERNAL_ID;
od->URLString = gf_strdup(szName);
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, (GF_Descriptor*)od, NULL);
} else {
gf_term_add_media(read->service, (GF_Descriptor*)od, GF_TRUE);
}
}
}
}
}
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, NULL, NULL);
} else {
gf_term_add_media(read->service, NULL, GF_FALSE);
}
}
/*
* Setup X11 wnd System
*/
void
X11_SetupWindow (GF_VideoOutput * vout)
{
X11VID ();
const char *sOpt;
Bool autorepeat, supported;
xWindow->display = XOpenDisplay (NULL);
xWindow->screennum = DefaultScreen (xWindow->display);
xWindow->screenptr = DefaultScreenOfDisplay (xWindow->display);
xWindow->visual = DefaultVisualOfScreen (xWindow->screenptr);
xWindow->depth = DefaultDepth (xWindow->display, xWindow->screennum);
{
Float screenWidth = (Float)XWidthOfScreen(xWindow->screenptr);
Float screenWidthIn = (Float)XWidthMMOfScreen(xWindow->screenptr) / 25.4f;
Float screenHeight = (Float)XHeightOfScreen(xWindow->screenptr);
Float screenHeightIn = (Float)XHeightMMOfScreen(xWindow->screenptr) / 25.4f;
vout->dpi_x = (u32)(screenWidth / screenWidthIn);
vout->dpi_y = (u32)(screenHeight / screenHeightIn);
}
switch (xWindow->depth) {
case 8:
xWindow->pixel_format = GF_PIXEL_GREYSCALE;
break;
case 16:
xWindow->pixel_format = GF_PIXEL_RGB_565;
break;
case 24:
xWindow->pixel_format = GF_PIXEL_RGB_32;
break;
default:
xWindow->pixel_format = GF_PIXEL_GREYSCALE;
break;
}
xWindow->bpp = xWindow->depth / 8;
xWindow->bpp = xWindow->bpp == 3 ? 4 : xWindow->bpp;
xWindow->screennum=0;
vout->max_screen_width = DisplayWidth(xWindow->display, xWindow->screennum);
vout->max_screen_height = DisplayHeight(xWindow->display, xWindow->screennum);
/*
* Full screen wnd
*/
xWindow->full_wnd = XCreateWindow (xWindow->display,
RootWindowOfScreen (xWindow->screenptr),
0, 0,
vout->max_screen_width,
vout->max_screen_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XSelectInput(xWindow->display, xWindow->full_wnd,
FocusChangeMask | ExposureMask | PointerMotionMask | ButtonReleaseMask | ButtonPressMask | KeyPressMask | KeyReleaseMask);
if (!xWindow->par_wnd) {
xWindow->w_width = 320;
xWindow->w_height = 240;
xWindow->wnd = XCreateWindow (xWindow->display,
RootWindowOfScreen(xWindow->screenptr), 0, 0,
xWindow->w_width, xWindow->w_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
} else {
XWindowAttributes pwa;
XGetWindowAttributes(xWindow->display, xWindow->par_wnd, &pwa);
xWindow->w_width = pwa.width;
xWindow->w_height = pwa.height;
xWindow->wnd = XCreateWindow (xWindow->display, xWindow->par_wnd, pwa.x, pwa.y,
xWindow->w_width, xWindow->w_height, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
}
XSync(xWindow->display, False);
XUnmapWindow (xWindow->display, (Window) xWindow->wnd);
XSync(xWindow->display, False);
old_handler = XSetErrorHandler(X11_BadAccess_ByPass);
selectinput_err = 0;
XSelectInput(xWindow->display, xWindow->wnd,
FocusChangeMask | StructureNotifyMask | PropertyChangeMask | ExposureMask |
PointerMotionMask | ButtonReleaseMask | ButtonPressMask |
KeyPressMask | KeyReleaseMask);
XSync(xWindow->display, False);
XSetErrorHandler(old_handler);
if (selectinput_err) {
XSelectInput(xWindow->display, xWindow->wnd,
StructureNotifyMask | PropertyChangeMask | ExposureMask |
KeyPressMask | KeyReleaseMask);
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Cannot select input focus\n"));
}
XSync(xWindow->display, False);
XMapWindow (xWindow->display, (Window) xWindow->wnd);
XSizeHints *Hints = XAllocSizeHints ();
Hints->flags = PSize | PMinSize;
Hints->min_width = 64;
Hints->min_height = 64;
Hints->max_height = 4096;
Hints->max_width = 4096;
if (!xWindow->par_wnd) {
XSetWMNormalHints (xWindow->display, xWindow->wnd, Hints);
XStoreName (xWindow->display, xWindow->wnd, "GPAC X11 Output");
}
Hints->x = 0;
Hints->y = 0;
Hints->flags |= USPosition;
XSetWMNormalHints (xWindow->display, xWindow->full_wnd, Hints);
autorepeat = 1;
XkbSetDetectableAutoRepeat(xWindow->display, autorepeat, &supported);
if (xWindow->init_flags & GF_TERM_WINDOW_NO_DECORATION) {
#define PROP_MOTIF_WM_HINTS_ELEMENTS 5
#define MWM_HINTS_DECORATIONS (1L << 1)
struct {
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long inputMode;
unsigned long status;
} hints = {2, 0, 0, 0, 0};
hints.flags = MWM_HINTS_DECORATIONS;
hints.decorations = 0;
XChangeProperty(xWindow->display, xWindow->wnd, XInternAtom(xWindow->display,"_MOTIF_WM_HINTS", False), XInternAtom(xWindow->display, "_MOTIF_WM_HINTS", False), 32, PropModeReplace, (unsigned char *)&hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
}
xWindow->the_gc = XCreateGC (xWindow->display, xWindow->wnd, 0, NULL);
xWindow->use_shared_memory = 0;
#ifdef GPAC_HAS_X11_SHM
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "UseHardwareMemory");
if (sOpt && !strcmp(sOpt, "yes")) {
int XShmMajor, XShmMinor;
Bool XShmPixmaps;
if (XShmQueryVersion(xWindow->display, &XShmMajor, &XShmMinor, &XShmPixmaps)) {
xWindow->use_shared_memory = 1;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using X11 Shared Memory\n"));
if ((XShmPixmaps==True) && (XShmPixmapFormat(xWindow->display)==ZPixmap)) {
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] X11 Shared Memory Pixmaps available\n"));
}
}
}
#endif
#ifdef GPAC_HAS_X11_XV
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "DisableColorKeying");
if (sOpt && !strcmp(sOpt, "yes")) {
xWindow->xvport = X11_GetXVideoPort(vout, GF_PIXEL_I420, 0);
} else {
xWindow->xvport = X11_GetXVideoPort(vout, GF_PIXEL_I420, 1);
if (xWindow->xvport<0) {
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Hardware has no color keying\n"));
vout->overlay_color_key = 0;
xWindow->xvport = X11_GetXVideoPort(vout, GF_PIXEL_I420, 0);
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Hardware uses color key %08x\n", vout->overlay_color_key));
}
}
if (xWindow->xvport>=0) {
XvUngrabPort(xWindow->display, xWindow->xvport, CurrentTime );
xWindow->xvport = -1;
vout->yuv_pixel_format = X11_GetPixelFormat(xWindow->xv_pf_format);
vout->Blit = X11_Blit;
vout->hw_caps |= GF_VIDEO_HW_HAS_YUV_OVERLAY;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using XV YUV Overlays\n"));
#ifdef GPAC_HAS_X11_SHM
/*if user asked for YUV->RGB on offscreen, do it (it may crash the system)*/
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "EnableOffscreenYUV");
if (sOpt && !strcmp(sOpt, "yes")) {
vout->hw_caps |= GF_VIDEO_HW_HAS_YUV;
GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[X11] Using XV Offscreen YUV2RGB acceleration\n"));
}
#endif
}
#endif
XSetWindowAttributes xsw;
xsw.border_pixel = WhitePixel (xWindow->display, xWindow->screennum);
xsw.background_pixel = BlackPixel (xWindow->display, xWindow->screennum);
xsw.win_gravity = NorthWestGravity;
XChangeWindowAttributes (xWindow->display, xWindow->wnd, CWBackPixel | CWWinGravity, &xsw);
xsw.override_redirect = True;
XChangeWindowAttributes(xWindow->display, xWindow->full_wnd,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWWinGravity, &xsw);
if (!xWindow->par_wnd) {
xWindow->WM_DELETE_WINDOW = XInternAtom (xWindow->display, "WM_DELETE_WINDOW", False);
XSetWMProtocols(xWindow->display, xWindow->wnd, &xWindow->WM_DELETE_WINDOW, 1);
}
{
XEvent ev;
long mask;
memset (&ev, 0, sizeof (ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = RootWindowOfScreen (xWindow->screenptr);
ev.xclient.message_type = XInternAtom (xWindow->display, "KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = xWindow->full_wnd;
ev.xclient.data.l[1] = CurrentTime;
mask = SubstructureRedirectMask;
XSendEvent (xWindow->display,RootWindowOfScreen (xWindow->screenptr), False,
mask, &ev);
}
/*openGL setup*/
#ifdef GPAC_HAS_OPENGL
{
int attribs[64];
int i, nb_bits;
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "GLNbBitsPerComponent");
/* Most outputs are 24/32 bits these days, use 8 bits per channel instead of 5, works better on MacOS X */
nb_bits = sOpt ? atoi(sOpt) : 8;
if (!sOpt){
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "GLNbBitsPerComponent", "8");
}
i=0;
attribs[i++] = GLX_RGBA;
attribs[i++] = GLX_RED_SIZE;
attribs[i++] = nb_bits;
attribs[i++] = GLX_GREEN_SIZE;
attribs[i++] = nb_bits;
attribs[i++] = GLX_BLUE_SIZE;
attribs[i++] = nb_bits;
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "GLNbBitsDepth");
nb_bits = sOpt ? atoi(sOpt) : 16;
if (!sOpt){
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "GLNbBitsDepth", "16");
}
if (nb_bits) {
attribs[i++] = GLX_DEPTH_SIZE;
attribs[i++] = nb_bits;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "UseGLDoubleBuffering");
if (!sOpt){
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "UseGLDoubleBuffering", "yes");
}
if (!sOpt || !strcmp(sOpt, "yes")) attribs[i++] = GLX_DOUBLEBUFFER;
attribs[i++] = None;
xWindow->glx_visualinfo = glXChooseVisual(xWindow->display, xWindow->screennum, attribs);
if (!xWindow->glx_visualinfo) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("[X11] Error selecting GL display\n"));
}
}
xWindow->gl_wnd = XCreateWindow (xWindow->display, RootWindowOfScreen (xWindow->screenptr),
0,
0,
200,
200, 0,
xWindow->depth, InputOutput,
xWindow->visual, 0, NULL);
XSync(xWindow->display, False);
XUnmapWindow(xWindow->display, (Window) xWindow->gl_wnd);
XSync(xWindow->display, False);
sOpt = gf_modules_get_option((GF_BaseInterface *)vout, "Video", "X113DOffscreenMode");
if (!sOpt)
gf_modules_set_option((GF_BaseInterface *)vout, "Video", "X113DOffscreenMode", "Pixmap");
if (sOpt && !strcmp(sOpt, "Window")) {
xWindow->offscreen_type = 1;
} else if (sOpt && !strcmp(sOpt, "VisibleWindow")) {
xWindow->offscreen_type = 2;
XSetWMNormalHints (xWindow->display, xWindow->gl_wnd, Hints);
} else if (sOpt && !strcmp(sOpt, "Pixmap")) {
xWindow->offscreen_type = 0;
} else {
xWindow->offscreen_type = 0;
}
#endif
/*turn off xscreensaver*/
X11_XScreenSaverState(xWindow, 0);
xWindow->setup_done = 1;
XFree (Hints);
}
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 FFD_CanHandleURL(GF_InputService *plug, const char *url)
{
Bool has_audio, has_video;
s32 i;
AVFormatContext *ctx;
AVOutputFormat *fmt_out;
Bool ret = 0;
char *ext, szName[1000], szExt[20];
const char *szExtList;
if (!plug || !url)
return 0;
/*disable RTP/RTSP from ffmpeg*/
if (!strnicmp(url, "rtsp://", 7)) return 0;
if (!strnicmp(url, "rtspu://", 8)) return 0;
if (!strnicmp(url, "rtp://", 6)) return 0;
if (!strnicmp(url, "plato://", 8)) return 0;
if (!strnicmp(url, "udp://", 6)) return 0;
if (!strnicmp(url, "tcp://", 6)) return 0;
if (!strnicmp(url, "data:", 5)) return 0;
strcpy(szName, url);
ext = strrchr(szName, '#');
if (ext) ext[0] = 0;
ext = strrchr(szName, '?');
if (ext) ext[0] = 0;
ext = strrchr(szName, '.');
if (ext && strlen(ext) > 19) ext = NULL;
if (ext && strlen(ext) > 1) {
strcpy(szExt, &ext[1]);
strlwr(szExt);
#ifndef FFMPEG_DEMUX_ENABLE_MPEG2TS
if (!strcmp(szExt, "ts")) return 0;
#endif
/*note we forbid ffmpeg to handle files we support*/
if (!strcmp(szExt, "mp4") || !strcmp(szExt, "mpg4") || !strcmp(szExt, "m4a") || !strcmp(szExt, "m21")
|| !strcmp(szExt, "m4v") || !strcmp(szExt, "m4a")
|| !strcmp(szExt, "m4s") || !strcmp(szExt, "3gs")
|| !strcmp(szExt, "3gp") || !strcmp(szExt, "3gpp") || !strcmp(szExt, "3gp2") || !strcmp(szExt, "3g2")
|| !strcmp(szExt, "mp3")
|| !strcmp(szExt, "ac3")
|| !strcmp(szExt, "amr")
|| !strcmp(szExt, "bt") || !strcmp(szExt, "wrl") || !strcmp(szExt, "x3dv")
|| !strcmp(szExt, "xmt") || !strcmp(szExt, "xmta") || !strcmp(szExt, "x3d")
|| !strcmp(szExt, "jpg") || !strcmp(szExt, "jpeg") || !strcmp(szExt, "png")
) return 0;
/*check any default stuff that should work with ffmpeg*/
{
u32 i;
for (i = 0 ; FFD_MIME_TYPES[i]; i+=3) {
if (gf_service_check_mime_register(plug, FFD_MIME_TYPES[i], FFD_MIME_TYPES[i+1], FFD_MIME_TYPES[i+2], ext))
return 1;
}
}
}
ctx = NULL;
if (open_file(&ctx, szName, NULL)<0) {
AVInputFormat *av_in = NULL;;
/*some extensions not supported by ffmpeg*/
if (ext && !strcmp(szExt, "cmp")) av_in = av_find_input_format("m4v");
if (open_file(&ctx, szName, av_in)<0) {
return 0;
}
}
if (!ctx || av_find_stream_info(ctx) <0) goto exit;
/*figure out if we can use codecs or not*/
has_video = has_audio = 0;
for(i = 0; i < (s32)ctx->nb_streams; i++) {
AVCodecContext *enc = ctx->streams[i]->codec;
switch(enc->codec_type) {
case AVMEDIA_TYPE_AUDIO:
if (!has_audio) has_audio = 1;
break;
case AVMEDIA_TYPE_VIDEO:
if (!has_video) has_video= 1;
break;
default:
break;
}
}
if (!has_audio && !has_video) goto exit;
ret = 1;
#if ((LIBAVFORMAT_VERSION_MAJOR == 52) && (LIBAVFORMAT_VERSION_MINOR <= 47)) || (LIBAVFORMAT_VERSION_MAJOR < 52)
fmt_out = guess_stream_format(NULL, url, NULL);
#else
fmt_out = av_guess_format(NULL, url, NULL);
#endif
if (fmt_out) gf_service_register_mime(plug, fmt_out->mime_type, fmt_out->extensions, fmt_out->name);
else {
ext = strrchr(szName, '.');
if (ext) {
strcpy(szExt, &ext[1]);
strlwr(szExt);
szExtList = gf_modules_get_option((GF_BaseInterface *)plug, "MimeTypes", "application/x-ffmpeg");
if (!szExtList) {
gf_service_register_mime(plug, "application/x-ffmpeg", szExt, "Other Movies (FFMPEG)");
} else if (!strstr(szExtList, szExt)) {
u32 len;
char *buf;
len = (u32) (strlen(szExtList) + strlen(szExt) + 10);
buf = gf_malloc(sizeof(char)*len);
sprintf(buf, "\"%s ", szExt);
strcat(buf, &szExtList[1]);
gf_modules_set_option((GF_BaseInterface *)plug, "MimeTypes", "application/x-ffmpeg", buf);
gf_free(buf);
}
}
}
exit:
#ifndef FF_API_CLOSE_INPUT_FILE
if (ctx) av_close_input_file(ctx);
#else
if (ctx) avformat_close_input(&ctx);
#endif
return ret;
}
static Bool ft_enum_fonts(void *cbck, char *file_name, char *file_path)
{
char *szfont;
FT_Face face;
u32 num_faces, i;
GF_FontReader *dr = cbck;
FTBuilder *ftpriv = dr->udta;
GF_LOG(GF_LOG_DEBUG, GF_LOG_PARSER, ("[FreeType] Enumerating font %s (%s)\n", file_name, file_path));
if (FT_New_Face(ftpriv->library, file_path, 0, & face )) return 0;
if (!face || !face->family_name) return 0;
num_faces = face->num_faces;
/*locate right font in collection if several*/
for (i=0; i<num_faces; i++) {
/*only scan scalable fonts*/
if (face->face_flags & FT_FACE_FLAG_SCALABLE) {
Bool bold, italic;
szfont = gf_malloc(sizeof(char)* (strlen(face->family_name)+100));
if (!szfont) continue;
strcpy(szfont, face->family_name);
/*remember first font found which looks like a alphabetical one*/
if (!ftpriv->font_dir) {
u32 gidx;
FT_Select_Charmap(face, FT_ENCODING_UNICODE);
gidx = FT_Get_Char_Index(face, (u32) 'a');
if (gidx) gidx = FT_Get_Char_Index(face, (u32) 'z');
if (gidx) gidx = FT_Get_Char_Index(face, (u32) '1');
if (gidx) gidx = FT_Get_Char_Index(face, (u32) '@');
if (gidx) ftpriv->font_dir = gf_strdup(szfont);
}
bold = italic = 0;
if (face->style_name) {
char *name = gf_strdup(face->style_name);
strupr(name);
if (strstr(name, "BOLD")) bold = 1;
if (strstr(name, "ITALIC")) italic = 1;
/*if font is not regular style, append all styles blindly*/
if (!strstr(name, "REGULAR")) {
strcat(szfont, " ");
strcat(szfont, face->style_name);
}
gf_free(name);
} else {
if (face->style_flags & FT_STYLE_FLAG_BOLD) bold = 1;
if (face->style_flags & FT_STYLE_FLAG_ITALIC) italic = 1;
if (bold) strcat(szfont, " Bold");
if (italic) strcat(szfont, " Italic");
}
gf_modules_set_option((GF_BaseInterface *)dr, "FontEngine", szfont, file_path);
/*try to assign default fixed fonts*/
if (!bold && !italic) {
strcpy(szfont, face->family_name);
strlwr(szfont);
if (face->face_flags & FT_FACE_FLAG_FIXED_WIDTH){
setBestFont(BEST_FIXED_FONTS, &(ftpriv->font_fixed), face->family_name);
}
setBestFont(BEST_SERIF_FONTS, &(ftpriv->font_serif), face->family_name);
setBestFont(BEST_SANS_FONTS, &(ftpriv->font_sans), face->family_name);
}
gf_free(szfont);
}
FT_Done_Face(face);
if (i+1==num_faces) return 0;
/*load next font in collection*/
if (FT_New_Face(ftpriv->library, file_path, i+1, & face )) return 0;
if (!face) return 0;
}
return 0;
}
GF_Err MPD_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
GF_MPD_In *mpdin = (GF_MPD_In*) plug->priv;
const char *opt;
GF_Err e;
u32 max_cache_duration, auto_switch_count;
GF_DASHInitialSelectionMode first_select_mode;
Bool keep_files, disable_switching;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Service Connection request (%p) from terminal for %s\n", serv, url));
if (!mpdin|| !serv || !url) return GF_BAD_PARAM;
mpdin->service = serv;
mpdin->dash_io.udta = mpdin;
mpdin->dash_io.delete_cache_file = mpdin_dash_io_delete_cache_file;
mpdin->dash_io.create = mpdin_dash_io_create;
mpdin->dash_io.del = mpdin_dash_io_del;
mpdin->dash_io.abort = mpdin_dash_io_abort;
mpdin->dash_io.setup_from_url = mpdin_dash_io_setup_from_url;
mpdin->dash_io.set_range = mpdin_dash_io_set_range;
mpdin->dash_io.init = mpdin_dash_io_init;
mpdin->dash_io.run = mpdin_dash_io_run;
mpdin->dash_io.get_url = mpdin_dash_io_get_url;
mpdin->dash_io.get_cache_name = mpdin_dash_io_get_cache_name;
mpdin->dash_io.get_mime = mpdin_dash_io_get_mime;
mpdin->dash_io.get_bytes_per_sec = mpdin_dash_io_get_bytes_per_sec;
mpdin->dash_io.get_total_size = mpdin_dash_io_get_total_size;
mpdin->dash_io.on_dash_event = mpdin_dash_io_on_dash_event;
max_cache_duration = 30;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "MaxCacheDuration");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "MaxCacheDuration", "30");
if (opt) max_cache_duration = atoi(opt);
auto_switch_count = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "AutoSwitchCount");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "AutoSwitchCount", "0");
if (opt) auto_switch_count = atoi(opt);
keep_files = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "KeepFiles");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "KeepFiles", "no");
if (opt && !strcmp(opt, "yes")) keep_files = 1;
disable_switching = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "DisableSwitching");
if (opt && !strcmp(opt, "yes")) disable_switching = 1;
first_select_mode = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "StartRepresentation");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "StartRepresentation", "minBandwidth");
opt = "minBandwidth";
}
if (opt && !strcmp(opt, "maxBandwidth")) first_select_mode = GF_DASH_SELECT_BANDWIDTH_HIGHEST;
else if (opt && !strcmp(opt, "minQuality")) first_select_mode = GF_DASH_SELECT_QUALITY_LOWEST;
else if (opt && !strcmp(opt, "maxQuality")) first_select_mode = GF_DASH_SELECT_QUALITY_HIGHEST;
else first_select_mode = GF_DASH_SELECT_BANDWIDTH_LOWEST;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "MemoryStorage");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "MemoryStorage", "no");
mpdin->memory_storage = (opt && !strcmp(opt, "yes")) ? 1 : 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "UseMaxResolution");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "UseMaxResolution", "yes");
mpdin->use_max_res = (!opt || !strcmp(opt, "yes")) ? 1 : 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "ImmediateSwitching");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "ImmediateSwitching", "no");
mpdin->immediate_switch = (opt && !strcmp(opt, "yes")) ? 1 : 0;
mpdin->in_seek = 0;
mpdin->previous_start_range = -1;
mpdin->dash = gf_dash_new(&mpdin->dash_io, max_cache_duration, auto_switch_count, keep_files, disable_switching, first_select_mode);
if (!mpdin->dash) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[MPD_IN] Error - cannot create DASH Client for %s\n", url));
gf_term_on_connect(mpdin->service, NULL, GF_IO_ERR);
return GF_OK;
}
/*dash thread starts at the end of gf_dash_open */
e = gf_dash_open(mpdin->dash, url);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[MPD_IN] Error - cannot initialize DASH Client for %s: %s\n", url, gf_error_to_string(e) ));
gf_term_on_connect(mpdin->service, NULL, e);
return GF_OK;
}
return GF_OK;
}
/**
* function DirectFBVid_Setup
* - DirectFB setup
**/
GF_Err DirectFBVid_Setup(GF_VideoOutput *driv, void *os_handle, void *os_display, u32 init_flags)
{
const char* opt;
DirectFBVID();
DirectFBVid_CtxSetIsInit(ctx, 0);
// initialisation and surface creation
GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("[DirectFB] Initialization\n"));
// check window mode used - SDL or X11
{
WINDOW_MODE window_mode = 0;
opt = gf_modules_get_option((GF_BaseInterface *)driv, "DirectFB", "WindowMode");
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "DirectFB", "WindowMode", "X11");
if (!opt || !strcmp(opt, "X11")) window_mode = WINDOW_X11;
else if (opt && !strcmp(opt, "SDL")) window_mode = WINDOW_SDL;
DirectFBVid_InitAndCreateSurface(ctx, window_mode);
}
// check hardware accelerator configuration
DirectFBVid_CtxSetDisableAcceleration(ctx, 0);
opt = gf_modules_get_option((GF_BaseInterface *)driv, "DirectFB", "DisableAcceleration");
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "DirectFB", "DisableAcceleration", "no");
if (opt && !strcmp(opt, "yes")) DirectFBVid_CtxSetDisableAcceleration(ctx, 1);
// check for display configuration
DirectFBVid_CtxSetDisableDisplay(ctx, 0);
opt = gf_modules_get_option((GF_BaseInterface *)driv, "DirectFB", "DisableDisplay");
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "DirectFB", "DisableDisplay", "no");
if (opt && !strcmp(opt, "yes")) DirectFBVid_CtxSetDisableDisplay(ctx, 1);
// set flip mode
{
FLIP_MODE flip_mode = 0;
opt = gf_modules_get_option((GF_BaseInterface *)driv, "DirectFB", "FlipSyncMode");
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "DirectFB", "FlipSyncMode", "waitsync");
if (!opt || !strcmp(opt, "waitsync")) flip_mode |= FLIP_WAITFORSYNC;
else if (opt && !strcmp(opt, "wait")) flip_mode |= FLIP_WAIT;
else if (opt && !strcmp(opt, "sync")) flip_mode |= FLIP_ONSYNC;
else if (opt && !strcmp(opt, "swap")) flip_mode |= FLIP_SWAP;
DirectFBVid_CtxSetFlipMode(ctx, flip_mode);
}
// enable/disable blit
opt = gf_modules_get_option((GF_BaseInterface *)driv, "DirectFB", "DisableBlit");
if (!opt) gf_modules_set_option((GF_BaseInterface *)driv, "DirectFB", "DisableBlit", "no");
if (opt && !strcmp(opt, "all")) {
driv->hw_caps &= ~(GF_VIDEO_HW_HAS_RGB | GF_VIDEO_HW_HAS_RGBA | GF_VIDEO_HW_HAS_YUV);
}
else if (opt && !strcmp(opt, "yuv")) driv->hw_caps &= ~GF_VIDEO_HW_HAS_YUV;
else if (opt && !strcmp(opt, "rgb")) driv->hw_caps &= ~GF_VIDEO_HW_HAS_RGB;
else if (opt && !strcmp(opt, "rgba")) driv->hw_caps &= ~GF_VIDEO_HW_HAS_RGBA;
if (!DirectFBVid_CtxGetDisableAcceleration(ctx)) {
// check for functions that are hardware accelerated
DirectFBVid_CtxPrimaryProcessGetAccelerationMask(ctx);
driv->hw_caps |= GF_VIDEO_HW_HAS_LINE_BLIT;
driv->DrawHLine = DirectFBVid_DrawHLine;
driv->DrawHLineAlpha = DirectFBVid_DrawHLineAlpha;
driv->DrawRectangle = DirectFBVid_DrawRectangle;
//GF_LOG(GF_LOG_INFO, GF_LOG_MMIO, ("[DirectFB] hardware acceleration mask %08x - Line: %d Rectangle: %d\n", mask, ctx->accel_drawline, ctx->accel_fillrect));
}
// end of initialization
DirectFBVid_CtxSetIsInit(ctx, 1);
GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("[DirectFB] Initialization success - HW caps %08x\n", driv->hw_caps));
// GF_LOG(GF_LOG_DEBUG, GF_LOG_MMIO, ("[DirectFB] Pixel format %s\n", gf_4cc_to_str(ctx->pixel_format)));
return GF_OK;
}
static Bool check_mpeg4_systems(GF_InputService *plug, GF_ISOFile *mov)
{
char *opt, *bname, *br, *next;
u32 i, count, brand, has_mpeg4;
GF_Err e;
e = gf_isom_get_brand_info(mov, &brand, &i, &count);
/*no brand == MP4 v1*/
if (e || !brand) return 1;
has_mpeg4 = 0;
if ((brand==GF_ISOM_BRAND_MP41) || (brand==GF_ISOM_BRAND_MP42)) has_mpeg4 = 1;
opt = (char*) gf_modules_get_option((GF_BaseInterface *)plug, "ISOReader", "IgnoreMPEG-4ForBrands");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)plug, "ISOReader", "IgnoreMPEG-4ForBrands", "nd*");
opt = (char*) gf_modules_get_option((GF_BaseInterface *)plug, "ISOReader", "IgnoreMPEG-4ForBrands");
}
for (i=0; i<count; i++) {
e = gf_isom_get_alternate_brand(mov, i+1, &brand);
if (e) return 0;
if ((brand==GF_ISOM_BRAND_MP41) || (brand==GF_ISOM_BRAND_MP42)) {
has_mpeg4 = 1;
continue;
}
bname = (char*)gf_4cc_to_str(brand);
br = opt;
while (br) {
Bool ignore = 0;
u32 orig_len, len;
next = strchr(br, ' ');
if (next) next[0] = 0;
len = orig_len = strlen(br);
while (len) {
if (br[len-1]=='*') {
br[len-1]=0;
len--;
} else {
break;
}
}
/*ignor all brands*/
if (!len) ignore = 1;
else if (!strncmp(bname, br, len)) ignore = 1;
while (len<orig_len) {
br[len] = '*';
len++;
}
if (next) {
next[0] = ' ';
br = next + 1;
} else {
br = NULL;
}
if (ignore) return 0;
}
}
return has_mpeg4;
}
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;
}
/*we assume what was asked is what we got*/
static GF_Err DS_ConfigureOutput(GF_AudioOutput *dr, u32 *SampleRate, u32 *NbChannels, u32 *nbBitsPerSample, u32 channel_cfg)
{
u32 i;
HRESULT hr;
const char *sOpt;
DSBUFFERDESC dsbBufferDesc;
IDirectSoundNotify *pNotify;
#ifdef USE_WAVE_EX
WAVEFORMATEXTENSIBLE format_ex;
#endif
DSCONTEXT();
DS_ReleaseBuffer(dr);
ctx->format.nChannels = *NbChannels;
ctx->format.wBitsPerSample = *nbBitsPerSample;
ctx->format.nSamplesPerSec = *SampleRate;
ctx->format.cbSize = sizeof (WAVEFORMATEX);
ctx->format.wFormatTag = WAVE_FORMAT_PCM;
ctx->format.nBlockAlign = ctx->format.nChannels * ctx->format.wBitsPerSample / 8;
ctx->format.nAvgBytesPerSec = ctx->format.nSamplesPerSec * ctx->format.nBlockAlign;
if (!ctx->force_config) {
ctx->buffer_size = ctx->format.nBlockAlign * 1024;
ctx->num_audio_buffer = 2;
} else {
ctx->num_audio_buffer = ctx->cfg_num_buffers;
ctx->buffer_size = (ctx->format.nAvgBytesPerSec * ctx->cfg_duration) / (1000 * ctx->cfg_num_buffers);
}
/*make sure we're aligned*/
while (ctx->buffer_size % ctx->format.nBlockAlign) ctx->buffer_size++;
ctx->use_notif = 1;
sOpt = gf_modules_get_option((GF_BaseInterface *)dr, "Audio", "DisableNotification");
if (sOpt && !stricmp(sOpt, "yes")) ctx->use_notif = 0;
memset(&dsbBufferDesc, 0, sizeof(DSBUFFERDESC));
dsbBufferDesc.dwSize = sizeof (DSBUFFERDESC);
dsbBufferDesc.dwBufferBytes = ctx->buffer_size * ctx->num_audio_buffer;
dsbBufferDesc.lpwfxFormat = &ctx->format;
dsbBufferDesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS | DSBCAPS_CTRLVOLUME;
if (ctx->use_notif) dsbBufferDesc.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
#ifdef USE_WAVE_EX
if (channel_cfg && ctx->format.nChannels>2) {
memset(&format_ex, 0, sizeof(WAVEFORMATEXTENSIBLE));
format_ex.Format = ctx->format;
format_ex.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE);
format_ex.SubFormat = GPAC_KSDATAFORMAT_SUBTYPE_PCM;
format_ex.Samples.wValidBitsPerSample = *nbBitsPerSample;
format_ex.dwChannelMask = 0;
if (channel_cfg & GF_AUDIO_CH_FRONT_LEFT) format_ex.dwChannelMask |= SPEAKER_FRONT_LEFT;
if (channel_cfg & GF_AUDIO_CH_FRONT_RIGHT) format_ex.dwChannelMask |= SPEAKER_FRONT_RIGHT;
if (channel_cfg & GF_AUDIO_CH_FRONT_CENTER) format_ex.dwChannelMask |= SPEAKER_FRONT_CENTER;
if (channel_cfg & GF_AUDIO_CH_LFE) format_ex.dwChannelMask |= SPEAKER_LOW_FREQUENCY;
if (channel_cfg & GF_AUDIO_CH_BACK_LEFT) format_ex.dwChannelMask |= SPEAKER_BACK_LEFT;
if (channel_cfg & GF_AUDIO_CH_BACK_RIGHT) format_ex.dwChannelMask |= SPEAKER_BACK_RIGHT;
if (channel_cfg & GF_AUDIO_CH_BACK_CENTER) format_ex.dwChannelMask |= SPEAKER_BACK_CENTER;
if (channel_cfg & GF_AUDIO_CH_SIDE_LEFT) format_ex.dwChannelMask |= SPEAKER_SIDE_LEFT;
if (channel_cfg & GF_AUDIO_CH_SIDE_RIGHT) format_ex.dwChannelMask |= SPEAKER_SIDE_RIGHT;
dsbBufferDesc.lpwfxFormat = (WAVEFORMATEX *) &format_ex;
}
#endif
hr = ctx->pDS->lpVtbl->CreateSoundBuffer(ctx->pDS, &dsbBufferDesc, &ctx->pOutput, NULL );
if (FAILED(hr)) {
retry:
if (ctx->use_notif) gf_modules_set_option((GF_BaseInterface *)dr, "Audio", "DisableNotification", "yes");
ctx->use_notif = 0;
dsbBufferDesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS;
hr = ctx->pDS->lpVtbl->CreateSoundBuffer(ctx->pDS, &dsbBufferDesc, &ctx->pOutput, NULL );
if (FAILED(hr)) return GF_IO_ERR;
}
for (i=0; i<ctx->num_audio_buffer; i++) ctx->frame_state[i] = 0;
if (ctx->use_notif) {
hr = ctx->pOutput->lpVtbl->QueryInterface(ctx->pOutput, &IID_IDirectSoundNotify , (void **)&pNotify);
if (hr == S_OK) {
/*setup the notification positions*/
for (i=0; i<ctx->num_audio_buffer; i++) {
ctx->events[i] = CreateEvent( NULL, FALSE, FALSE, NULL );
ctx->notif_events[i].hEventNotify = ctx->events[i];
ctx->notif_events[i].dwOffset = ctx->buffer_size * i;
}
/*Tell DirectSound when to notify us*/
hr = pNotify->lpVtbl->SetNotificationPositions(pNotify, ctx->num_audio_buffer, ctx->notif_events);
if (hr != S_OK) {
pNotify->lpVtbl->Release(pNotify);
for (i=0; i<ctx->num_audio_buffer; i++) CloseHandle(ctx->events[i]);
SAFE_DS_RELEASE(ctx->pOutput);
goto retry;
}
pNotify->lpVtbl->Release(pNotify);
} else {
ctx->use_notif = 0;
}
}
if (ctx->use_notif) {
dr->WriteAudio = DS_WriteAudio_Notifs;
} else {
dr->WriteAudio = DS_WriteAudio;
}
ctx->total_audio_buffer_ms = 1000 * ctx->buffer_size * ctx->num_audio_buffer / ctx->format.nAvgBytesPerSec;
/*reset*/
DS_ResetBuffer(ctx);
/*play*/
ctx->pOutput->lpVtbl->Play(ctx->pOutput, 0, 0, DSBPLAY_LOOPING);
return GF_OK;
}
GF_Err MPD_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
GF_MPD_In *mpdin = (GF_MPD_In*) plug->priv;
const char *opt;
GF_Err e;
s32 shift_utc_ms, debug_adaptation_set;
u32 max_cache_duration, auto_switch_count, init_timeshift;
Bool use_server_utc;
GF_DASHInitialSelectionMode first_select_mode;
Bool keep_files, disable_switching;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] Received Service Connection request (%p) from terminal for %s\n", serv, url));
if (!mpdin || !serv || !url)
return GF_BAD_PARAM;
mpdin->service = serv;
mpdin->seek_request = -1;
mpdin->dash_io.udta = mpdin;
mpdin->dash_io.delete_cache_file = mpdin_dash_io_delete_cache_file;
mpdin->dash_io.create = mpdin_dash_io_create;
mpdin->dash_io.del = mpdin_dash_io_del;
mpdin->dash_io.abort = mpdin_dash_io_abort;
mpdin->dash_io.setup_from_url = mpdin_dash_io_setup_from_url;
mpdin->dash_io.set_range = mpdin_dash_io_set_range;
mpdin->dash_io.init = mpdin_dash_io_init;
mpdin->dash_io.run = mpdin_dash_io_run;
mpdin->dash_io.get_url = mpdin_dash_io_get_url;
mpdin->dash_io.get_cache_name = mpdin_dash_io_get_cache_name;
mpdin->dash_io.get_mime = mpdin_dash_io_get_mime;
mpdin->dash_io.get_header_value = mpdin_dash_io_get_header_value;
mpdin->dash_io.get_utc_start_time = mpdin_dash_io_get_utc_start_time;
mpdin->dash_io.get_bytes_per_sec = mpdin_dash_io_get_bytes_per_sec;
mpdin->dash_io.get_total_size = mpdin_dash_io_get_total_size;
mpdin->dash_io.get_bytes_done = mpdin_dash_io_get_bytes_done;
mpdin->dash_io.on_dash_event = mpdin_dash_io_on_dash_event;
max_cache_duration = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "Network", "BufferLength");
if (opt) max_cache_duration = atoi(opt);
auto_switch_count = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "AutoSwitchCount");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "AutoSwitchCount", "0");
if (opt) auto_switch_count = atoi(opt);
keep_files = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "KeepFiles");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "KeepFiles", "no");
if (opt && !strcmp(opt, "yes")) keep_files = 1;
disable_switching = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "DisableSwitching");
if (opt && !strcmp(opt, "yes")) disable_switching = 1;
first_select_mode = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "StartRepresentation");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "StartRepresentation", "minBandwidth");
opt = "minBandwidth";
}
if (opt && !strcmp(opt, "maxBandwidth")) first_select_mode = GF_DASH_SELECT_BANDWIDTH_HIGHEST;
else if (opt && !strcmp(opt, "minQuality")) first_select_mode = GF_DASH_SELECT_QUALITY_LOWEST;
else if (opt && !strcmp(opt, "maxQuality")) first_select_mode = GF_DASH_SELECT_QUALITY_HIGHEST;
else first_select_mode = GF_DASH_SELECT_BANDWIDTH_LOWEST;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "MemoryStorage");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "MemoryStorage", "yes");
mpdin->memory_storage = (opt && !strcmp(opt, "yes")) ? 1 : 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "UseMaxResolution");
if (!opt) {
#if defined(_WIN32_WCE) || defined(GPAC_ANDROID) || defined(GPAC_IPHONE)
opt = "yes";
#else
opt = "no";
#endif
gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "UseMaxResolution", opt);
}
mpdin->use_max_res = !strcmp(opt, "yes") ? 1 : 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "ImmediateSwitching");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "ImmediateSwitching", "no");
mpdin->immediate_switch = (opt && !strcmp(opt, "yes")) ? 1 : 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "BufferingMode");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "BufferingMode", "minBuffer");
if (opt && !strcmp(opt, "segments")) mpdin->buffer_mode = MPDIN_BUFFER_SEGMENTS;
else if (opt && !strcmp(opt, "none")) mpdin->buffer_mode = MPDIN_BUFFER_NONE;
else mpdin->buffer_mode = MPDIN_BUFFER_MIN;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "LowLatency");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "LowLatency", "no");
if (opt && !strcmp(opt, "chunk") ) mpdin->use_low_latency = 1;
else if (opt && !strcmp(opt, "always") ) mpdin->use_low_latency = 2;
else mpdin->use_low_latency = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "AllowAbort");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "AllowAbort", "no");
mpdin->allow_http_abort = (opt && !strcmp(opt, "yes")) ? GF_TRUE : GF_FALSE;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "ShiftClock");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "ShiftClock", "0");
shift_utc_ms = opt ? atoi(opt) : 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "UseServerUTC");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "UseServerUTC", "yes");
use_server_utc = (opt && !strcmp(opt, "yes")) ? 1 : 0;
mpdin->in_seek = 0;
mpdin->previous_start_range = 0;
init_timeshift = 0;
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "InitialTimeshift");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "InitialTimeshift", "0");
if (opt) init_timeshift = atoi(opt);
//override all service callbacks
mpdin->fn_connect_ack = serv->fn_connect_ack;
serv->fn_connect_ack = mpdin_connect_ack;
mpdin->fn_data_packet = serv->fn_data_packet;
serv->fn_data_packet = mpdin_data_packet;
mpdin->dash = gf_dash_new(&mpdin->dash_io, max_cache_duration, auto_switch_count, keep_files, disable_switching, first_select_mode, (mpdin->buffer_mode == MPDIN_BUFFER_SEGMENTS) ? 1 : 0, init_timeshift);
if (!mpdin->dash) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[MPD_IN] Error - cannot create DASH Client for %s\n", url));
mpdin->fn_connect_ack(mpdin->service, NULL, GF_IO_ERR);
return GF_OK;
}
gf_dash_set_utc_shift(mpdin->dash, shift_utc_ms);
gf_dash_enable_utc_drift_compensation(mpdin->dash, use_server_utc);
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "UseScreenResolution");
//default mode is no for the time being
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "UseScreenResolution", "no");
if (!opt || !strcmp(opt, "yes")) {
GF_NetworkCommand com;
memset(&com, 0, sizeof(GF_NetworkCommand));
com.base.command_type = GF_NET_SERVICE_MEDIA_CAP_QUERY;
gf_service_command(serv, &com, GF_OK);
if (com.mcaps.width && com.mcaps.height) {
gf_dash_set_max_resolution(mpdin->dash, com.mcaps.width, com.mcaps.height, com.mcaps.display_bit_depth);
}
}
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "TimeBetween404");
if (opt) {
gf_dash_set_min_timeout_between_404(mpdin->dash, atoi(opt));
}
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "SegmentExpirationThreshold");
if (opt) {
gf_dash_set_segment_expiration_threshold(mpdin->dash, atoi(opt));
}
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "SwitchProbeCount");
if (opt) {
gf_dash_set_switching_probe_count(mpdin->dash, atoi(opt));
} else {
gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "SwitchProbeCount", "1");
}
opt = gf_modules_get_option((GF_BaseInterface *)plug, "DASH", "DebugAdaptationSet");
if (!opt) gf_modules_set_option((GF_BaseInterface *)plug, "DASH", "DebugAdaptationSet", "-1");
debug_adaptation_set = opt ? atoi(opt) : -1;
gf_dash_debug_group(mpdin->dash, debug_adaptation_set);
/*dash thread starts at the end of gf_dash_open */
e = gf_dash_open(mpdin->dash, url);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[MPD_IN] Error - cannot initialize DASH Client for %s: %s\n", url, gf_error_to_string(e) ));
mpdin->fn_connect_ack(mpdin->service, NULL, e);
return GF_OK;
}
return GF_OK;
}
static void ft_rescan_fonts(GF_FontReader *dr)
{
char *font_dir, *font_default;
u32 i, count;
GF_Config *cfg = gf_modules_get_config((GF_BaseInterface *)dr);
FTBuilder *ftpriv = (FTBuilder *)dr->udta;
GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("[FreeType] Rescaning font directory %s\n", ftpriv->font_dir));
count = gf_cfg_get_key_count(cfg, "FontEngine");
for (i=0; i<count; i++) {
const char *key = gf_cfg_get_key_name(cfg, "FontEngine", i);
if (!strcmp(key, "FontReader")) continue;
if (!strcmp(key, "FontDirectory")) continue;
if (!strcmp(key, "RescanFonts")) continue;
/*any other persistent options should go here*/
gf_cfg_set_key(cfg, "FontEngine", key, NULL);
count--;
i--;
}
gf_modules_set_option((GF_BaseInterface *)dr, "FontEngine", "RescanFonts", "no");
ftpriv->font_serif = NULL;
ftpriv->font_sans = NULL;
ftpriv->font_fixed = NULL;
font_dir = ftpriv->font_dir;
ftpriv->font_dir = NULL;
gf_enum_directory(font_dir, 0, ft_enum_fonts, dr, "ttf;ttc");
gf_enum_directory(font_dir, 1, ft_enum_fonts_dir, dr, NULL);
font_default = ftpriv->font_dir;
ftpriv->font_dir = font_dir;
if (ftpriv->font_fixed) gf_free(ftpriv->font_fixed);
ftpriv->font_fixed = NULL;
if (ftpriv->font_sans) gf_free(ftpriv->font_sans);
ftpriv->font_sans = NULL;
if (ftpriv->font_serif) gf_free(ftpriv->font_serif);
ftpriv->font_serif = NULL;
/* let's check we have fonts that match our default Bol/Italic/BoldItalic conventions*/
count = gf_cfg_get_key_count(cfg, "FontEngine");
for (i=0; i<count; i++) {
const char *opt;
char fkey[GF_MAX_PATH];
const char *key = gf_cfg_get_key_name(cfg, "FontEngine", i);
opt = gf_cfg_get_key(cfg, "FontEngine", key);
if (!strchr(opt, '/') && !strchr(opt, '\\')) continue;
if (!strcmp(key, "FontDirectory")) continue;
if (strstr(key, "Bold")) continue;
if (strstr(key, "Italic")) continue;
strcpy(fkey, key);
strcat(fkey, " Italic");
opt = gf_cfg_get_key(cfg, "FontEngine", fkey);
if (!opt) continue;
strcpy(fkey, key);
strcat(fkey, " Bold");
opt = gf_cfg_get_key(cfg, "FontEngine", fkey);
if (!opt) continue;
strcpy(fkey, key);
strcat(fkey, " Bold Italic");
opt = gf_cfg_get_key(cfg, "FontEngine", fkey);
if (!opt) continue;
strcpy(fkey, key);
strlwr(fkey);
/*this font is suited for our case*/
if (isBestFontFor(BEST_FIXED_FONTS, ftpriv->font_fixed, key) || (!ftpriv->font_fixed && (strstr(fkey, "fixed") || strstr(fkey, "mono")) ) ) {
if (ftpriv->font_fixed) gf_free(ftpriv->font_fixed);
ftpriv->font_fixed = gf_strdup(key);
}
if (isBestFontFor(BEST_SANS_FONTS, ftpriv->font_sans, key) || (!ftpriv->font_sans && strstr(fkey, "sans")) ) {
if (ftpriv->font_sans) gf_free(ftpriv->font_sans);
ftpriv->font_sans = gf_strdup(key);
}
if (isBestFontFor(BEST_SERIF_FONTS, ftpriv->font_serif, key) || (!ftpriv->font_serif && strstr(fkey, "serif")) ) {
if (ftpriv->font_serif) gf_free(ftpriv->font_serif);
ftpriv->font_serif = gf_strdup(key);
}
}
if (!ftpriv->font_serif) ftpriv->font_serif = gf_strdup(font_default ? font_default : "");
if (!ftpriv->font_sans) ftpriv->font_sans = gf_strdup(font_default ? font_default : "");
if (!ftpriv->font_fixed) ftpriv->font_fixed = gf_strdup(font_default ? font_default : "");
if (font_default) gf_free(font_default);
gf_modules_set_option((GF_BaseInterface *)dr, "FontEngine", "FontFixed", ftpriv->font_fixed);
gf_modules_set_option((GF_BaseInterface *)dr, "FontEngine", "FontSerif", ftpriv->font_serif);
gf_modules_set_option((GF_BaseInterface *)dr, "FontEngine", "FontSans", ftpriv->font_sans);
GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("[FreeType] Font directory scanned\n", ftpriv->font_dir));
}
static void RT_LoadPrefs(GF_InputService *plug, RTPClient *rtp)
{
const char *sOpt;
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Streaming", "DefaultPort");
if (sOpt) {
rtp->default_port = atoi(sOpt);
} else {
rtp->default_port = 554;
}
if ((rtp->default_port == 80) || (rtp->default_port == 8080))
gf_modules_set_option((GF_BaseInterface *)plug, "Streaming", "RTPoverRTSP", "yes");
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Streaming", "RTPoverRTSP");
if (sOpt && !stricmp(sOpt, "yes")) {
rtp->transport_mode = 1;
} else if (sOpt && !stricmp(sOpt, "OnlyCritical")) {
rtp->transport_mode = 2;
} else {
rtp->transport_mode = 0;
}
/*
get heneral network config for UDP
*/
/*if UDP not available don't try it*/
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Network", "UDPNotAvailable");
if (sOpt && !stricmp(sOpt, "yes")) {
if (!rtp->transport_mode) rtp->transport_mode = 1;
/*turn it off*/
gf_modules_set_option((GF_BaseInterface *)plug, "Network", "UDPNotAvailable", "no");
}
if (!rtp->transport_mode) {
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Network", "UDPTimeout");
if (sOpt ) {
rtp->udp_time_out = atoi(sOpt);
} else {
rtp->udp_time_out = 10000;
}
}
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Streaming", "RTSPTimeout");
if (sOpt ) {
rtp->time_out = atoi(sOpt);
} else {
rtp->time_out = 30000;
}
/*packet drop emulation*/
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Streaming", "FirstPacketDrop");
if (sOpt) {
rtp->first_packet_drop = atoi(sOpt);
} else {
rtp->first_packet_drop = 0;
}
sOpt = gf_modules_get_option((GF_BaseInterface *)plug, "Streaming", "PacketDropFrequency");
if (sOpt) {
rtp->frequency_drop = atoi(sOpt);
} else {
rtp->frequency_drop = 0;
}
// rtp->handle_announce = 0;
}