static GF_Err Codec_LoadModule(GF_Codec *codec, GF_ESD *esd, u32 PL)
{
char szPrefDec[500];
const char *sOpt;
GF_BaseDecoder *ifce, *dec_ifce;
u32 i, plugCount;
u32 ifce_type;
char *cfg;
u32 cfg_size, dec_confidence;
GF_Terminal *term = codec->odm->term;
if (esd->decoderConfig->decoderSpecificInfo) {
cfg = esd->decoderConfig->decoderSpecificInfo->data;
cfg_size = esd->decoderConfig->decoderSpecificInfo->dataLength;
} else {
cfg = NULL;
cfg_size = 0;
}
switch (esd->decoderConfig->streamType) {
case GF_STREAM_AUDIO:
case GF_STREAM_VISUAL:
case GF_STREAM_ND_SUBPIC:
ifce_type = GF_MEDIA_DECODER_INTERFACE;
codec->process = MediaCodec_Process;
break;
case GF_STREAM_PRIVATE_MEDIA:
ifce_type = GF_PRIVATE_MEDIA_DECODER_INTERFACE;
codec->process = gf_codec_process_private_media;
break;
case GF_STREAM_PRIVATE_SCENE:
ifce_type = GF_SCENE_DECODER_INTERFACE;
codec->process = PrivateScene_Process;
break;
default:
ifce_type = GF_SCENE_DECODER_INTERFACE;
codec->process = SystemCodec_Process;
if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_SCENE_AFX) {
ifce_type = GF_NODE_DECODER_INTERFACE;
}
break;
}
/*a bit dirty, if FFMPEG is used for demuxer load it for decoder too*/
if (0 && !stricmp(codec->odm->net_service->ifce->module_name, "FFMPEG demuxer")) {
sOpt = "FFMPEG decoder";
} else {
/*use user-defined module if any*/
sOpt = NULL;
switch (esd->decoderConfig->streamType) {
case GF_STREAM_VISUAL:
if ((esd->decoderConfig->objectTypeIndication==GPAC_OTI_IMAGE_JPEG) || (esd->decoderConfig->objectTypeIndication==GPAC_OTI_IMAGE_PNG))
sOpt = gf_cfg_get_key(term->user->config, "Systems", "DefImageDec");
else
sOpt = gf_cfg_get_key(term->user->config, "Systems", "DefVideoDec");
break;
case GF_STREAM_AUDIO:
sOpt = gf_cfg_get_key(term->user->config, "Systems", "DefAudioDec");
break;
default:
break;
}
}
dec_confidence = 0;
ifce = NULL;
if (sOpt) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface_by_name(term->user->modules, sOpt, ifce_type);
if (ifce) {
if (ifce->CanHandleStream) {
dec_confidence = ifce->CanHandleStream(ifce, esd->decoderConfig->streamType, esd, PL);
if (dec_confidence==GF_CODEC_SUPPORTED) {
codec->decio = ifce;
return GF_OK;
}
if (dec_confidence==GF_CODEC_NOT_SUPPORTED) {
gf_modules_close_interface((GF_BaseInterface *) ifce);
ifce = NULL;
}
} else {
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
}
}
dec_ifce = ifce;
/*prefered codec module per streamType/objectType from config*/
sprintf(szPrefDec, "codec_%02X_%02X", esd->decoderConfig->streamType, esd->decoderConfig->objectTypeIndication);
sOpt = gf_cfg_get_key(term->user->config, "Systems", szPrefDec);
if (sOpt) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface_by_name(term->user->modules, sOpt, ifce_type);
if (ifce) {
if (ifce->CanHandleStream) {
u32 conf = ifce->CanHandleStream(ifce, esd->decoderConfig->streamType, esd, PL);
if ((conf!=GF_CODEC_NOT_SUPPORTED) && (conf>=dec_confidence)) {
/*switch*/
if (dec_ifce) gf_modules_close_interface((GF_BaseInterface *) dec_ifce);
dec_confidence = conf;
dec_ifce = ifce;
ifce = NULL;
if (dec_confidence==GF_CODEC_SUPPORTED) {
codec->decio = dec_ifce;
return GF_OK;
}
}
}
if (ifce)
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
}
/*not found, check all modules*/
plugCount = gf_modules_get_count(term->user->modules);
for (i = 0; i < plugCount ; i++) {
ifce = (GF_BaseDecoder *) gf_modules_load_interface(term->user->modules, i, ifce_type);
if (!ifce) continue;
if (ifce->CanHandleStream) {
u32 conf = ifce->CanHandleStream(ifce, esd->decoderConfig->streamType, esd, PL);
if ((conf!=GF_CODEC_NOT_SUPPORTED) && (conf>=dec_confidence)) {
/*switch*/
if (dec_ifce) gf_modules_close_interface((GF_BaseInterface *) dec_ifce);
dec_confidence = conf;
dec_ifce = ifce;
ifce = NULL;
}
}
if (ifce)
gf_modules_close_interface((GF_BaseInterface *) ifce);
}
if (dec_ifce) {
codec->decio = dec_ifce;
sprintf(szPrefDec, "codec_%02X_%02X", esd->decoderConfig->streamType, esd->decoderConfig->objectTypeIndication);
gf_cfg_set_key(term->user->config, "Systems", szPrefDec, dec_ifce->module_name);
return GF_OK;
}
return GF_CODEC_NOT_FOUND;
}
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));
}
void COptStream::SaveOptions()
{
COsmo4 *gpac = GetApp();
Bool force_rtsp = 0;
s32 sel = m_Port.GetCurSel();
switch (sel) {
case 3:
gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "8080");
force_rtsp = 1;
break;
case 2:
gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "80");
force_rtsp = 1;
break;
case 1:
gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "7070");
break;
default:
gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "554");
break;
}
if (force_rtsp) {
gf_cfg_set_key(gpac->m_user.config, "Streaming", "RTPoverRTSP", "yes");
} else {
gf_cfg_set_key(gpac->m_user.config, "Streaming", "RTPoverRTSP", m_UseRTSP.GetCheck() ? "yes" : "no");
if (!m_UseRTSP.GetCheck()) gf_cfg_set_key(gpac->m_user.config, "Streaming", "ReorderSize", m_Reorder.GetCheck() ? "30" : "0");
}
TCHAR wstr[50];
char str[50];
m_Timeout.GetWindowText(wstr, 50);
CE_WideToChar((u16 *)wstr, str);
gf_cfg_set_key(gpac->m_user.config, "Streaming", "RTSPTimeout", str);
m_Buffer.GetWindowText(wstr, 50);
CE_WideToChar((u16 *)wstr, str);
gf_cfg_set_key(gpac->m_user.config, "Network", "BufferLength", str);
if (m_Rebuffer.GetCheck()) {
m_RebufferLen.GetWindowText(wstr, 50);
CE_WideToChar((u16 *)wstr, str);
gf_cfg_set_key(gpac->m_user.config, "Network", "RebufferLength", str);
} else {
gf_cfg_set_key(gpac->m_user.config, "Network", "RebufferLength", "0");
}
}
static void imagetexture_update(GF_TextureHandler *txh)
{
if (gf_node_get_tag(txh->owner)!=TAG_MPEG4_CacheTexture) {
MFURL url = ((M_ImageTexture *) txh->owner)->url;
/*setup texture if needed*/
if (!txh->is_open && url.count) {
gf_sc_texture_play(txh, &url);
}
gf_sc_texture_update_frame(txh, 0);
if (
/*URL is present but not opened - redraw till fetch*/
/* (txh->stream && !txh->tx_io) && */
/*image has been updated*/
txh->needs_refresh) {
/*mark all subtrees using this image as dirty*/
gf_node_dirty_parents(txh->owner);
gf_sc_invalidate(txh->compositor, NULL);
}
return;
}
/*cache texture case*/
else {
M_CacheTexture *ct = (M_CacheTexture *) txh->owner;
/*decode cacheTexture data */
if ((ct->data || ct->image.buffer) && !txh->data) {
#ifndef GPAC_DISABLE_AV_PARSERS
u32 out_size;
GF_Err e;
/*BT/XMT playback*/
if (ct->image.buffer) {
e = gf_img_file_dec(ct->image.buffer, (u32 *) &ct->objectTypeIndication, &txh->width, &txh->height, &txh->pixelformat, &txh->data, &out_size);
if (e==GF_OK) {
txh->needs_refresh = 1;
txh->stride = out_size / txh->height;
}
}
/*BIFS decoded playback*/
else {
switch (ct->objectTypeIndication) {
case GPAC_OTI_IMAGE_JPEG:
out_size = 0;
e = gf_img_jpeg_dec((char *) ct->data, ct->data_len, &txh->width, &txh->height, &txh->pixelformat, NULL, &out_size, 3);
if (e==GF_BUFFER_TOO_SMALL) {
u32 BPP;
txh->data = gf_malloc(sizeof(char) * out_size);
if (txh->pixelformat==GF_PIXEL_GREYSCALE) BPP = 1;
else BPP = 3;
e = gf_img_jpeg_dec((char *) ct->data, ct->data_len, &txh->width, &txh->height, &txh->pixelformat, txh->data, &out_size, BPP);
if (e==GF_OK) {
txh->needs_refresh = 1;
txh->stride = out_size / txh->height;
}
}
break;
case GPAC_OTI_IMAGE_PNG:
out_size = 0;
e = gf_img_png_dec((char *) ct->data, ct->data_len, &txh->width, &txh->height, &txh->pixelformat, NULL, &out_size);
if (e==GF_BUFFER_TOO_SMALL) {
txh->data = gf_malloc(sizeof(char) * out_size);
e = gf_img_png_dec((char *) ct->data, ct->data_len, &txh->width, &txh->height, &txh->pixelformat, txh->data, &out_size);
if (e==GF_OK) {
txh->needs_refresh = 1;
txh->stride = out_size / txh->height;
}
}
break;
}
}
#endif // GPAC_DISABLE_AV_PARSERS
/*cacheURL is specified, store the image*/
if (ct->cacheURL.buffer) {
u32 i;
u8 hash[20];
FILE *cached_texture;
char szExtractName[GF_MAX_PATH], section[16], *opt, *src_url;
opt = (char *) gf_cfg_get_key(txh->compositor->user->config, "General", "CacheDirectory");
if (opt) {
strcpy(szExtractName, opt);
} else {
opt = gf_get_default_cache_directory();
strcpy(szExtractName, opt);
gf_free(opt);
}
strcat(szExtractName, "/");
src_url = (char *) gf_scene_get_service_url( gf_node_get_graph(txh->owner ) );
gf_sha1_csum((u8 *)src_url, (u32) strlen(src_url), hash);
for (i=0; i<20; i++) {
char t[3];
t[2] = 0;
sprintf(t, "%02X", hash[i]);
strcat(szExtractName, t);
}
strcat(szExtractName, "_");
strcat(szExtractName, ct->cacheURL.buffer);
cached_texture = gf_f64_open(szExtractName, "wb");
if (cached_texture) {
gf_fwrite(ct->data, 1, ct->data_len, cached_texture);
fclose(cached_texture);
}
/*and write cache info*/
if (ct->expirationDate!=0) {
sprintf(section, "@cache=%08X", (u32) (PTR_TO_U_CAST ct));
gf_cfg_set_key(txh->compositor->user->config, section, "serviceURL", src_url);
gf_cfg_set_key(txh->compositor->user->config, section, "cacheFile", szExtractName);
gf_cfg_set_key(txh->compositor->user->config, section, "cacheName", ct->cacheURL.buffer);
if (ct->expirationDate>0) {
char exp[50];
u32 sec, frac;
gf_net_get_ntp(&sec, &frac);
sec += ct->expirationDate;
sprintf(exp, "%u", sec);
gf_cfg_set_key(txh->compositor->user->config, section, "expireAfterNTP", exp);
} else {
gf_cfg_set_key(txh->compositor->user->config, section, "expireAfterNTP", "0");
}
}
}
/*done with image, destroy buffer*/
if (ct->data) gf_free(ct->data);
ct->data = NULL;
ct->data_len = 0;
}
}
}
GF_EXPORT
GF_BaseInterface *gf_modules_load_interface(GF_ModuleManager *pm, u32 whichplug, u32 InterfaceFamily)
{
const char *opt;
char szKey[32];
ModuleInstance *inst;
GF_BaseInterface *ifce;
if (!pm) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] gf_modules_load_interface() : No Module Manager set\n"));
return NULL;
}
gf_mx_p(pm->mutex);
inst = (ModuleInstance *) gf_list_get(pm->plug_list, whichplug);
if (!inst) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] gf_modules_load_interface() : no module %d exist.\n", whichplug));
gf_mx_v(pm->mutex);
return NULL;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface...%s\n", inst->name));
/*look in cache*/
if (!pm->cfg) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] No pm->cfg has been set !!!\n"));
gf_mx_v(pm->mutex);
return NULL;
}
opt = gf_cfg_get_key(pm->cfg, "PluginsCache", inst->name);
if (opt) {
const char * ifce_str = gf_4cc_to_str(InterfaceFamily);
snprintf(szKey, 32, "%s:yes", ifce_str ? ifce_str : "(null)");
if (!strstr(opt, szKey)) {
gf_mx_v(pm->mutex);
return NULL;
}
}
if (!gf_modules_load_library(inst)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] Cannot load library %s\n", inst->name));
gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, "Invalid Plugin");
gf_mx_v(pm->mutex);
return NULL;
}
if (!inst->query_func) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] Library %s missing GPAC export symbols\n", inst->name));
gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, "Invalid Plugin");
goto err_exit;
}
/*build cache*/
if (!opt) {
u32 i;
Bool found = GF_FALSE;
char *key;
const u32 *si = inst->query_func();
if (!si) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CORE, ("[Core] GPAC module %s has no supported interfaces - disabling\n", inst->name));
gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, "Invalid Plugin");
goto err_exit;
}
i=0;
while (si[i]) i++;
key = (char*)gf_malloc(sizeof(char) * 10 * i);
key[0] = 0;
i=0;
while (si[i]) {
snprintf(szKey, 32, "%s:yes ", gf_4cc_to_str(si[i]));
strcat(key, szKey);
if (InterfaceFamily==si[i]) found = GF_TRUE;
i++;
}
gf_cfg_set_key(pm->cfg, "PluginsCache", inst->name, key);
gf_free(key);
if (!found) goto err_exit;
}
if (!inst->query_func || !inst->query_func(InterfaceFamily) ) goto err_exit;
ifce = (GF_BaseInterface *) inst->load_func(InterfaceFamily);
/*sanity check*/
if (!ifce) goto err_exit;
if (!ifce->module_name || (ifce->InterfaceType != InterfaceFamily)) {
inst->destroy_func(ifce);
goto err_exit;
}
gf_list_add(inst->interfaces, ifce);
/*keep track of parent*/
ifce->HPLUG = inst;
GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface %s DONE.\n", inst->name));
gf_mx_v(pm->mutex);
return ifce;
err_exit:
GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface %s exit label, freing library...\n", inst->name));
gf_modules_unload_library(inst);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Load interface %s EXIT.\n", inst->name));
gf_mx_v(pm->mutex);
return NULL;
}
GF_EXPORT
Bool gf_mo_get_visual_info(GF_MediaObject *mo, u32 *width, u32 *height, u32 *stride, u32 *pixel_ar, u32 *pixelFormat)
{
GF_CodecCapability cap;
if ((mo->type != GF_MEDIA_OBJECT_VIDEO) && (mo->type!=GF_MEDIA_OBJECT_TEXT)) return 0;
if (width) {
cap.CapCode = GF_CODEC_WIDTH;
gf_codec_get_capability(mo->odm->codec, &cap);
*width = cap.cap.valueInt;
}
if (height) {
cap.CapCode = GF_CODEC_HEIGHT;
gf_codec_get_capability(mo->odm->codec, &cap);
*height = cap.cap.valueInt;
}
if (mo->type==GF_MEDIA_OBJECT_TEXT) return 1;
if (stride) {
cap.CapCode = GF_CODEC_STRIDE;
gf_codec_get_capability(mo->odm->codec, &cap);
*stride = cap.cap.valueInt;
}
if (pixelFormat) {
cap.CapCode = GF_CODEC_PIXEL_FORMAT;
gf_codec_get_capability(mo->odm->codec, &cap);
*pixelFormat = cap.cap.valueInt;
if (mo->odm && mo->odm->parentscene->is_dynamic_scene) {
const char *name = gf_node_get_name(gf_list_get(mo->nodes, 0));
if (name && !strcmp(name, "DYN_VIDEO")) {
const char *opt;
u32 r, g, b, a;
M_Background2D *back = (M_Background2D *) gf_sg_find_node_by_name(mo->odm->parentscene->graph, "DYN_BACK");
if (back) {
switch (cap.cap.valueInt) {
case GF_PIXEL_ARGB:
case GF_PIXEL_RGBA:
case GF_PIXEL_YUVA:
opt = gf_cfg_get_key(mo->odm->term->user->config, "Compositor", "BackColor");
if (!opt) {
gf_cfg_set_key(mo->odm->term->user->config, "Compositor", "BackColor", "FF999999");
opt = "FF999999";
}
sscanf(opt, "%02X%02X%02X%02X", &a, &r, &g, &b);
back->backColor.red = INT2FIX(r)/255;
back->backColor.green = INT2FIX(g)/255;
back->backColor.blue = INT2FIX(b)/255;
break;
default:
back->backColor.red = back->backColor.green = back->backColor.blue = FIX_ONE;
break;
}
gf_node_dirty_set((GF_Node *)back, 0, 1);
}
}
}
}
/*get PAR settings*/
if (pixel_ar) {
cap.CapCode = GF_CODEC_PAR;
gf_codec_get_capability(mo->odm->codec, &cap);
*pixel_ar = cap.cap.valueInt;
if (! (*pixel_ar & 0x0000FFFF)) *pixel_ar = 0;
if (! (*pixel_ar & 0xFFFF0000)) *pixel_ar = 0;
/**/
if (! *pixel_ar) {
GF_Channel *ch;
GF_NetworkCommand com;
com.base.command_type = GF_NET_CHAN_GET_PIXEL_AR;
ch = gf_list_get(mo->odm->channels, 0);
if (!ch) return 0;
com.base.on_channel = ch;
com.par.hSpacing = com.par.vSpacing = 0;
if (gf_term_service_command(ch->service, &com) == GF_OK) {
if ((com.par.hSpacing>65535) || (com.par.vSpacing>65535)) {
com.par.hSpacing>>=16;
com.par.vSpacing>>=16;
}
if (com.par.hSpacing|| com.par.vSpacing)
*pixel_ar = (com.par.hSpacing<<16) | com.par.vSpacing;
}
}
static GF_Config *create_default_config(char *file_path)
{
FILE *f;
GF_Config *cfg;
char *cache_dir;
char szPath[GF_MAX_PATH];
char gui_path[GF_MAX_PATH];
if (! get_default_install_path(file_path, GF_PATH_CFG)) {
gf_delete_file(szPath);
return NULL;
}
/*Create the config file*/
sprintf(szPath, "%s%c%s", file_path, GF_PATH_SEPARATOR, CFG_FILE_NAME);
fprintf(stderr, "Trying to create config file: %s", szPath);
f = gf_f64_open(szPath, "wt");
if (!f) return NULL;
fclose(f);
if (! get_default_install_path(szPath, GF_PATH_MODULES)) {
gf_delete_file(szPath);
GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] default modules not found\n"));
return NULL;
}
cfg = gf_cfg_new(file_path, CFG_FILE_NAME);
if (!cfg) return NULL;
gf_cfg_set_key(cfg, "General", "ModulesDirectory", szPath);
/*get default temporary directoy */
cache_dir = gf_get_default_cache_directory();
if (cache_dir) {
gf_cfg_set_key(cfg, "General", "CacheDirectory", cache_dir);
gf_free(cache_dir);
}
gf_cfg_set_key(cfg, "Compositor", "Raster2D", "GPAC 2D Raster");
gf_cfg_set_key(cfg, "Audio", "ForceConfig", "yes");
gf_cfg_set_key(cfg, "Audio", "NumBuffers", "2");
gf_cfg_set_key(cfg, "Audio", "TotalDuration", "120");
gf_cfg_set_key(cfg, "Audio", "DisableNotification", "no");
/*Setup font engine to FreeType by default, and locate TrueType font directory on the system*/
gf_cfg_set_key(cfg, "FontEngine", "FontReader", "FreeType Font Reader");
gf_cfg_set_key(cfg, "FontEngine", "RescanFonts", "yes");
#if defined(_WIN32_WCE)
/*FIXME - is this true on all WinCE systems??*/
strcpy(szPath, "\\Windows");
#elif defined(WIN32)
GetWindowsDirectory((char*)szPath, MAX_PATH);
if (szPath[strlen((char*)szPath)-1] != '\\') strcat((char*)szPath, "\\");
strcat((char *)szPath, "Fonts");
#elif defined(__APPLE__)
#ifdef GPAC_IPHONE
strcpy(szPath, "/System/Library/Fonts/Cache");
#else
strcpy(szPath, "/Library/Fonts");
#endif
#else
strcpy(szPath, "/usr/share/fonts/truetype/");
#endif
gf_cfg_set_key(cfg, "FontEngine", "FontDirectory", szPath);
gf_cfg_set_key(cfg, "Downloader", "CleanCache", "yes");
gf_cfg_set_key(cfg, "Compositor", "AntiAlias", "All");
gf_cfg_set_key(cfg, "Compositor", "FrameRate", "30.0");
/*use power-of-2 emulation in OpenGL if no rectangular texture extension*/
gf_cfg_set_key(cfg, "Compositor", "EmulatePOW2", "yes");
gf_cfg_set_key(cfg, "Compositor", "ScalableZoom", "yes");
#if defined(_WIN32_WCE)
gf_cfg_set_key(cfg, "Video", "DriverName", "GAPI Video Output");
#elif defined(WIN32)
gf_cfg_set_key(cfg, "Video", "DriverName", "DirectX Video Output");
#elif defined(__DARWIN__) || defined(__APPLE__)
gf_cfg_set_key(cfg, "Video", "DriverName", "SDL Video Output");
#else
gf_cfg_set_key(cfg, "Video", "DriverName", "X11 Video Output");
gf_cfg_set_key(cfg, "Audio", "DriverName", "SDL Audio Output");
#endif
#ifdef GPAC_IPHONE
gf_cfg_set_key(cfg, "Compositor", "DisableGLUScale", "yes");
#endif
gf_cfg_set_key(cfg, "Video", "SwitchResolution", "no");
gf_cfg_set_key(cfg, "Video", "HardwareMemory", "Auto");
gf_cfg_set_key(cfg, "Network", "AutoReconfigUDP", "yes");
gf_cfg_set_key(cfg, "Network", "UDPTimeout", "10000");
gf_cfg_set_key(cfg, "Network", "BufferLength", "3000");
/*locate GUI*/
if ( get_default_install_path(szPath, GF_PATH_GUI) ) {
sprintf(gui_path, "%s%cgui.bt", szPath, GF_PATH_SEPARATOR);
f = fopen(gui_path, "rt");
if (f) {
fclose(f);
gf_cfg_set_key(cfg, "General", "StartupFile", gui_path);
}
}
/*store and reload*/
gf_cfg_del(cfg);
return gf_cfg_new(file_path, CFG_FILE_NAME);
}
static void dc_create_configuration(CmdData *cmd_data)
{
u32 i;
GF_Config *conf = cmd_data->conf;
u32 sec_count = gf_cfg_get_section_count(conf);
if (!sec_count) {
gf_cfg_set_key(conf, "v1", "type", "video");
gf_cfg_set_key(conf, "a1", "type", "audio");
sec_count = gf_cfg_get_section_count(conf);
}
for (i=0; i<sec_count; i++) {
char value[GF_MAX_PATH];
const char *section_name = gf_cfg_get_section_name(conf, i);
const char *section_type = gf_cfg_get_key(conf, section_name, "type");
if (strcmp(section_type, "video") == 0) {
if (!gf_cfg_get_key(conf, section_name, "bitrate")) {
if (cmd_data->video_data_conf.bitrate == -1)
cmd_data->video_data_conf.bitrate = DEFAULT_VIDEO_BITRATE;
snprintf(value, sizeof(value), "%d", cmd_data->video_data_conf.bitrate);
gf_cfg_set_key(conf, section_name, "bitrate", value);
}
if (!gf_cfg_get_key(conf, section_name, "framerate")) {
if (cmd_data->video_data_conf.framerate == -1)
cmd_data->video_data_conf.framerate = DEFAULT_VIDEO_FRAMERATE;
snprintf(value, sizeof(value), "%d", cmd_data->video_data_conf.framerate);
gf_cfg_set_key(conf, section_name, "framerate", value);
}
if (!gf_cfg_get_key(conf, section_name, "width")) {
if (cmd_data->video_data_conf.width == -1)
cmd_data->video_data_conf.width = DEFAULT_VIDEO_WIDTH;
snprintf(value, sizeof(value), "%d", cmd_data->video_data_conf.width);
gf_cfg_set_key(conf, section_name, "width", value);
}
if (!gf_cfg_get_key(conf, section_name, "height")) {
if (cmd_data->video_data_conf.height == -1)
cmd_data->video_data_conf.height = DEFAULT_VIDEO_HEIGHT;
snprintf(value, sizeof(value), "%d", cmd_data->video_data_conf.height);
gf_cfg_set_key(conf, section_name, "height", value);
}
if (!gf_cfg_get_key(conf, section_name, "crop_x")) {
if (cmd_data->video_data_conf.crop_x == -1)
cmd_data->video_data_conf.crop_x = 0;
snprintf(value, sizeof(value), "%d", cmd_data->video_data_conf.crop_x);
gf_cfg_set_key(conf, section_name, "crop_x", value);
}
if (!gf_cfg_get_key(conf, section_name, "crop_y")) {
if (cmd_data->video_data_conf.crop_y == -1)
cmd_data->video_data_conf.crop_y = 0;
snprintf(value, sizeof(value), "%d", cmd_data->video_data_conf.crop_y);
gf_cfg_set_key(conf, section_name, "crop_y", value);
}
if (!gf_cfg_get_key(conf, section_name, "codec"))
gf_cfg_set_key(conf, section_name, "codec", DEFAULT_VIDEO_CODEC);
}
if (strcmp(section_type, "audio") == 0) {
if (!gf_cfg_get_key(conf, section_name, "bitrate")) {
if (cmd_data->audio_data_conf.bitrate == -1)
cmd_data->audio_data_conf.bitrate = DEFAULT_AUDIO_BITRATE;
snprintf(value, sizeof(value), "%d", cmd_data->audio_data_conf.bitrate);
gf_cfg_set_key(conf, section_name, "bitrate", value);
}
if (!gf_cfg_get_key(conf, section_name, "samplerate")) {
if (cmd_data->audio_data_conf.samplerate == -1)
cmd_data->audio_data_conf.samplerate = DEFAULT_AUDIO_SAMPLERATE;
snprintf(value, sizeof(value), "%d", cmd_data->audio_data_conf.samplerate);
gf_cfg_set_key(conf, section_name, "samplerate", value);
}
if (!gf_cfg_get_key(conf, section_name, "channels")) {
if (cmd_data->audio_data_conf.channels == -1)
cmd_data->audio_data_conf.channels = DEFAULT_AUDIO_CHANNELS;
snprintf(value, sizeof(value), "%d", cmd_data->audio_data_conf.channels);
gf_cfg_set_key(conf, section_name, "channels", value);
}
if (!gf_cfg_get_key(conf, section_name, "codec"))
gf_cfg_set_key(conf, section_name, "codec", DEFAULT_AUDIO_CODEC);
}
}
}
BOOL Osmo4::InitInstance()
{
CCommandLineInfo cmdInfo;
m_logs = NULL;
m_term = NULL;
memset(&m_user, 0, sizeof(GF_User));
/*get Osmo4.exe path*/
strcpy((char *) szApplicationPath, AfxGetApp()->m_pszHelpFilePath);
while (szApplicationPath[strlen((char *) szApplicationPath)-1] != '\\') szApplicationPath[strlen((char *) szApplicationPath)-1] = 0;
if (szApplicationPath[strlen((char *) szApplicationPath)-1] != '\\') strcat(szApplicationPath, "\\");
gf_sys_init(0);
/*setup user*/
memset(&m_user, 0, sizeof(GF_User));
Bool first_launch = 0;
/*init config and modules*/
m_user.config = gf_cfg_init(NULL, &first_launch);
if (!m_user.config) {
MessageBox(NULL, "GPAC Configuration file not found", "Fatal Error", MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
}
char *name = gf_cfg_get_filename(m_user.config);
char *sep = strrchr(name, '\\');
if (sep) sep[0] = 0;
strcpy(szUserPath, name);
if (sep) sep[0] = '\\';
gf_free(name);
const char *opt = gf_cfg_get_key(m_user.config, "General", "SingleInstance");
m_SingleInstance = (opt && !stricmp(opt, "yes")) ? 1 : 0;
m_hMutex = NULL;
if (m_SingleInstance) {
m_hMutex = CreateMutex(NULL, FALSE, "Osmo4_GPAC_INSTANCE");
if ( GetLastError() == ERROR_ALREADY_EXISTS ) {
char szDIR[1024];
if (m_hMutex) CloseHandle(m_hMutex);
m_hMutex = NULL;
if (!static_gpac_hwnd || !IsWindow(static_gpac_hwnd) ) {
::MessageBox(NULL, "Osmo4 ghost process detected", "Error at last shutdown" , MB_OK);
} else {
::SetForegroundWindow(static_gpac_hwnd);
if (m_lpCmdLine && strlen(m_lpCmdLine)) {
DWORD res;
u32 len;
char *the_url, *cmd;
GetCurrentDirectory(1024, szDIR);
if (szDIR[strlen(szDIR)-1] != '\\') strcat(szDIR, "\\");
cmd = (char *)(const char *) m_lpCmdLine;
strcpy(static_szCmdLine, "");
if (cmd[0]=='"') cmd+=1;
if (!strnicmp(cmd, "-queue ", 7)) {
strcat(static_szCmdLine, "-queue ");
cmd += 7;
}
the_url = gf_url_concatenate(szDIR, cmd);
if (!the_url) {
strcat(static_szCmdLine, cmd);
} else {
strcat(static_szCmdLine, the_url);
gf_free(the_url);
}
while ( (len = strlen(static_szCmdLine)) ) {
char s = static_szCmdLine[len-1];
if ((s==' ') || (s=='"')) static_szCmdLine[len-1]=0;
else break;
}
::SendMessageTimeout(static_gpac_hwnd, WM_NEWINSTANCE, 0, 0, 0, 1000, &res);
}
}
return FALSE;
}
}
#if 0
// Standard initialization
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
#endif
SetRegistryKey(_T("GPAC"));
CMainFrame* pFrame = new CMainFrame;
m_pMainWnd = pFrame;
pFrame->LoadFrame(IDR_MAINFRAME, WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL, NULL);
m_pMainWnd->DragAcceptFiles();
if (m_SingleInstance) static_gpac_hwnd = m_pMainWnd->m_hWnd;
const char *str = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
m_user.modules = gf_modules_new(str, m_user.config);
if (!m_user.modules || ! gf_modules_get_count(m_user.modules) ) {
MessageBox(NULL, "No modules available - system cannot work", "Fatal Error", MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
}
else if (first_launch) {
/*first launch, register all files ext*/
u32 i;
for (i=0; i<gf_modules_get_count(m_user.modules); i++) {
GF_InputService *ifce = (GF_InputService *) gf_modules_load_interface(m_user.modules, i, GF_NET_CLIENT_INTERFACE);
if (!ifce) continue;
if (ifce) {
ifce->CanHandleURL(ifce, "test.test");
gf_modules_close_interface((GF_BaseInterface *)ifce);
}
}
/*set some shortcuts*/
gf_cfg_set_key(m_user.config, "Shortcuts", "VolumeUp", "ctrl+Up");
gf_cfg_set_key(m_user.config, "Shortcuts", "VolumeDown", "ctrl+Down");
gf_cfg_set_key(m_user.config, "Shortcuts", "FastRewind", "ctrl+Left");
gf_cfg_set_key(m_user.config, "Shortcuts", "FastForward", "ctrl+Right");
gf_cfg_set_key(m_user.config, "Shortcuts", "Play", "ctrl+ ");
}
/*check log file*/
str = gf_cfg_get_key(m_user.config, "General", "LogFile");
if (str) {
m_logs = gf_f64_open(str, "wt");
gf_log_set_callback(m_logs, osmo4_do_log);
}
else m_logs = NULL;
/*set log level*/
if (gf_log_set_tools_levels(gf_cfg_get_key(m_user.config, "General", "Logs")) != GF_OK)
fprintf(stdout, "osmo4: invalid log level specified\n");
m_user.opaque = this;
m_user.os_window_handler = pFrame->m_pWndView->m_hWnd;
m_user.EventProc = Osmo4_EventProc;
m_reset = 0;
orig_width = 320;
orig_height = 240;
gf_set_progress_callback(this, Osmo4_progress_cbk);
m_term = gf_term_new(&m_user);
if (! m_term) {
MessageBox(NULL, "Cannot load GPAC Terminal", "Fatal Error", MB_OK);
m_pMainWnd->PostMessage(WM_CLOSE);
return TRUE;
}
SetOptions();
UpdateRenderSwitch();
pFrame->SendMessage(WM_SETSIZE, orig_width, orig_height);
pFrame->m_Address.ReloadURLs();
pFrame->m_Sliders.SetVolume();
m_reconnect_time = 0;
ParseCommandLine(cmdInfo);
start_mode = 0;
if (! cmdInfo.m_strFileName.IsEmpty()) {
pFrame->m_pPlayList->QueueURL(cmdInfo.m_strFileName);
pFrame->m_pPlayList->RefreshList();
pFrame->m_pPlayList->PlayNext();
} else {
char sPL[MAX_PATH];
strcpy((char *) sPL, szUserPath);
strcat(sPL, "gpac_pl.m3u");
pFrame->m_pPlayList->OpenPlayList(sPL);
const char *sOpt = gf_cfg_get_key(GetApp()->m_user.config, "General", "PLEntry");
if (sOpt) {
s32 count = (s32)gf_list_count(pFrame->m_pPlayList->m_entries);
pFrame->m_pPlayList->m_cur_entry = atoi(sOpt);
if (pFrame->m_pPlayList->m_cur_entry>=count)
pFrame->m_pPlayList->m_cur_entry = count-1;
} else {
pFrame->m_pPlayList->m_cur_entry = -1;
}
#if 0
if (pFrame->m_pPlayList->m_cur_entry>=0) {
start_mode = 1;
pFrame->m_pPlayList->Play();
}
#endif
sOpt = gf_cfg_get_key(GetApp()->m_user.config, "General", "StartupFile");
if (sOpt) gf_term_connect(m_term, sOpt);
}
pFrame->SetFocus();
pFrame->SetForegroundWindow();
return TRUE;
}
GF_AudioRenderer *gf_sc_ar_load(GF_User *user)
{
const char *sOpt;
u32 i, count;
u32 num_buffers, total_duration;
GF_Err e;
GF_AudioRenderer *ar;
ar = (GF_AudioRenderer *) gf_malloc(sizeof(GF_AudioRenderer));
memset(ar, 0, sizeof(GF_AudioRenderer));
num_buffers = total_duration = 0;
sOpt = gf_cfg_get_key(user->config, "Audio", "ForceConfig");
if (sOpt && !stricmp(sOpt, "yes")) {
sOpt = gf_cfg_get_key(user->config, "Audio", "NumBuffers");
num_buffers = sOpt ? atoi(sOpt) : 6;
sOpt = gf_cfg_get_key(user->config, "Audio", "TotalDuration");
total_duration = sOpt ? atoi(sOpt) : 400;
}
sOpt = gf_cfg_get_key(user->config, "Audio", "NoResync");
ar->disable_resync = (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0;
sOpt = gf_cfg_get_key(user->config, "Audio", "DisableMultiChannel");
ar->disable_multichannel = (sOpt && !stricmp(sOpt, "yes")) ? 1 : 0;
ar->mixer = gf_mixer_new(ar);
ar->user = user;
sOpt = gf_cfg_get_key(user->config, "Audio", "Volume");
ar->volume = sOpt ? atoi(sOpt) : 75;
sOpt = gf_cfg_get_key(user->config, "Audio", "Pan");
ar->pan = sOpt ? atoi(sOpt) : 50;
if (! (user->init_flags & GF_TERM_NO_AUDIO) ) {
/*get a prefered compositor*/
sOpt = gf_cfg_get_key(user->config, "Audio", "DriverName");
if (sOpt) {
ar->audio_out = (GF_AudioOutput *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_AUDIO_OUTPUT_INTERFACE);
if (!ar->audio_out) {
ar->audio_out = NULL;
sOpt = NULL;
}
}
if (!ar->audio_out) {
GF_AudioOutput *raw_out = NULL;
count = gf_modules_get_count(ar->user->modules);
for (i=0; i<count; i++) {
ar->audio_out = (GF_AudioOutput *) gf_modules_load_interface(ar->user->modules, i, GF_AUDIO_OUTPUT_INTERFACE);
if (!ar->audio_out) continue;
//in enum mode, only use raw out if everything else failed ...
if (!stricmp(ar->audio_out->module_name, "Raw Audio Output")) {
raw_out = ar->audio_out;
ar->audio_out = NULL;
continue;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] Audio output module %s loaded\n", ar->audio_out->module_name));
/*check that's a valid audio compositor*/
if ((ar->audio_out->SelfThreaded && ar->audio_out->SetPriority) || ar->audio_out->WriteAudio) {
/*remember the module we use*/
gf_cfg_set_key(user->config, "Audio", "DriverName", ar->audio_out->module_name);
break;
}
gf_modules_close_interface((GF_BaseInterface *)ar->audio_out);
ar->audio_out = NULL;
}
if (raw_out) {
if (ar->audio_out) gf_modules_close_interface((GF_BaseInterface *)raw_out);
else ar->audio_out = raw_out;
}
}
/*if not init we run with a NULL audio compositor*/
if (ar->audio_out) {
ar->audio_out->FillBuffer = gf_ar_fill_output;
ar->audio_out->audio_renderer = ar;
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] Setting up audio module %s\n", ar->audio_out->module_name));
e = ar->audio_out->Setup(ar->audio_out, ar->user->os_window_handler, num_buffers, total_duration);
/*load main audio filter*/
gf_afc_load(&ar->filter_chain, user, (char*)gf_cfg_get_key(user->config, "Audio", "Filter"));
if (e != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MMIO, ("Could not setup audio out %s\n", ar->audio_out->module_name));
gf_modules_close_interface((GF_BaseInterface *)ar->audio_out);
ar->audio_out = NULL;
} else {
if (!ar->audio_out->SelfThreaded) {
ar->th = gf_th_new("AudioRenderer");
gf_th_run(ar->th, gf_ar_proc, ar);
} else {
gf_ar_setup_output_format(ar);
if (ar->audio_out->SetPriority) ar->audio_out->SetPriority(ar->audio_out, GF_THREAD_PRIORITY_REALTIME);
}
}
}
if (!ar->audio_out) gf_cfg_set_key(user->config, "Audio", "DriverName", "No Audio Output Available");
}
/*init compositor timer*/
ar->startTime = gf_sys_clock();
return ar;
}
int dc_read_configuration(CmdData * p_cmdd) {
int i;
GF_Config * p_conf = p_cmdd->p_conf;
int i_sec_count = gf_cfg_get_section_count(p_conf);
if (i_sec_count == 0) {
gf_cfg_set_key(p_conf, "v1.mp4", "type", "video");
gf_cfg_set_key(p_conf, "v1.mp4", "bitrate", "400000");
// gf_cfg_set_key(p_conf, "v1.mp4", "framerate", "25");
gf_cfg_set_key(p_conf, "v1.mp4", "width", "640");
gf_cfg_set_key(p_conf, "v1.mp4", "height", "480");
// gf_cfg_set_key(p_conf, "v1.mp4", "codec", "libx264");
gf_cfg_set_key(p_conf, "a1.mp4", "type", "audio");
gf_cfg_set_key(p_conf, "a1.mp4", "bitrate", "200000");
// gf_cfg_set_key(p_conf, "a1.mp4", "samplerate", "48000");
// gf_cfg_set_key(p_conf, "a1.mp4", "channels", "2");
// gf_cfg_set_key(p_conf, "a1.mp4", "codec", "aac");
i_sec_count = 2;
}
for (i = 0; i < i_sec_count; i++) {
const char * psz_sec_name = gf_cfg_get_section_name(p_conf, i);
const char * psz_type = gf_cfg_get_key(p_conf, psz_sec_name, "type");
if (strcmp(psz_type, "video") == 0) {
VideoData * p_vconf = malloc(sizeof(VideoData));
strcpy(p_vconf->psz_name, psz_sec_name);
// strcpy(p_vconf->psz_codec,
// gf_cfg_get_key(p_conf, psz_sec_name, "codec"));
p_vconf->i_bitrate = atoi(
gf_cfg_get_key(p_conf, psz_sec_name, "bitrate"));
// p_vconf->i_framerate = atoi(
// gf_cfg_get_key(p_conf, psz_sec_name, "framerate"));
p_vconf->i_height = atoi(
gf_cfg_get_key(p_conf, psz_sec_name, "height"));
p_vconf->i_width = atoi(
gf_cfg_get_key(p_conf, psz_sec_name, "width"));
gf_list_add(p_cmdd->p_video_lst, (void *) p_vconf);
} else if (strcmp(psz_type, "audio") == 0) {
AudioData * p_aconf = malloc(sizeof(AudioData));
strcpy(p_aconf->psz_name, psz_sec_name);
// strcpy(p_aconf->psz_codec,
// gf_cfg_get_key(p_conf, psz_sec_name, "codec"));
p_aconf->i_bitrate = atoi(
gf_cfg_get_key(p_conf, psz_sec_name, "bitrate"));
// p_aconf->i_samplerate = atoi(
// gf_cfg_get_key(p_conf, psz_sec_name, "samplerate"));
// p_aconf->i_channels = atoi(
// gf_cfg_get_key(p_conf, psz_sec_name, "channels"));
gf_list_add(p_cmdd->p_audio_lst, (void *) p_aconf);
} else {
printf("Configuration file: type %s is not supported.\n", psz_type);
}
}
printf("\33[34m\33[1m");
printf("Configurations:\n");
for (i = 0; i < gf_list_count(p_cmdd->p_video_lst); i++) {
VideoData * p_vconf = gf_list_get(p_cmdd->p_video_lst, i);
printf(" id:%s\tres:%dx%d\tvbr:%d\n",
p_vconf->psz_name, p_vconf->i_width, p_vconf->i_height,
p_vconf->i_bitrate/*, p_vconf->i_framerate, p_vconf->psz_codec*/);
}
for (i = 0; i < gf_list_count(p_cmdd->p_audio_lst); i++) {
AudioData * p_aconf = gf_list_get(p_cmdd->p_audio_lst, i);
printf(" id:%s\tabr:%d\n", p_aconf->psz_name,
p_aconf->i_bitrate/*, p_aconf->i_samplerate,
p_aconf->i_channels,p_aconf->psz_codec*/);
}
printf("\33[0m");
fflush(stdout);
return 0;
}
void SR_ReloadConfig(GF_Renderer *sr)
{
const char *sOpt, *dr_name;
/*changing drivers needs exclusive access*/
gf_sr_lock(sr, 1);
sOpt = gf_cfg_get_key(sr->user->config, "Rendering", "ForceSceneSize");
if (sOpt && ! stricmp(sOpt, "yes")) {
sr->override_size_flags = 1;
} else {
sr->override_size_flags = 0;
}
sOpt = gf_cfg_get_key(sr->user->config, "Rendering", "AntiAlias");
if (sOpt) {
if (! stricmp(sOpt, "None")) gf_sr_set_option(sr, GF_OPT_ANTIALIAS, GF_ANTIALIAS_NONE);
else if (! stricmp(sOpt, "Text")) gf_sr_set_option(sr, GF_OPT_ANTIALIAS, GF_ANTIALIAS_TEXT);
else gf_sr_set_option(sr, GF_OPT_ANTIALIAS, GF_ANTIALIAS_FULL);
} else {
gf_cfg_set_key(sr->user->config, "Rendering", "AntiAlias", "All");
gf_sr_set_option(sr, GF_OPT_ANTIALIAS, GF_ANTIALIAS_FULL);
}
sOpt = gf_cfg_get_key(sr->user->config, "Rendering", "StressMode");
gf_sr_set_option(sr, GF_OPT_STRESS_MODE, (sOpt && !stricmp(sOpt, "yes") ) ? 1 : 0);
sOpt = gf_cfg_get_key(sr->user->config, "Rendering", "FastRender");
gf_sr_set_option(sr, GF_OPT_HIGHSPEED, (sOpt && !stricmp(sOpt, "yes") ) ? 1 : 0);
sOpt = gf_cfg_get_key(sr->user->config, "Rendering", "BoundingVolume");
if (sOpt) {
if (! stricmp(sOpt, "Box")) gf_sr_set_option(sr, GF_OPT_DRAW_BOUNDS, GF_BOUNDS_BOX);
else if (! stricmp(sOpt, "AABB")) gf_sr_set_option(sr, GF_OPT_DRAW_BOUNDS, GF_BOUNDS_AABB);
else gf_sr_set_option(sr, GF_OPT_DRAW_BOUNDS, GF_BOUNDS_NONE);
} else {
gf_cfg_set_key(sr->user->config, "Rendering", "BoundingVolume", "None");
gf_sr_set_option(sr, GF_OPT_DRAW_BOUNDS, GF_BOUNDS_NONE);
}
sOpt = gf_cfg_get_key(sr->user->config, "FontEngine", "DriverName");
if (sOpt && sr->font_engine) {
dr_name = sr->font_engine->module_name;
if (stricmp(dr_name, sOpt)) SR_SetFontEngine(sr);
}
sOpt = gf_cfg_get_key(sr->user->config, "FontEngine", "TextureTextMode");
if (sOpt && !stricmp(sOpt, "Always")) sr->texture_text_mode = GF_TEXTURE_TEXT_ALWAYS;
else if (sOpt && !stricmp(sOpt, "3D")) sr->texture_text_mode = GF_TEXTURE_TEXT_3D;
else sr->texture_text_mode = GF_TEXTURE_TEXT_NONE;
if (sr->audio_renderer) {
sOpt = gf_cfg_get_key(sr->user->config, "Audio", "NoResync");
if (sOpt && !stricmp(sOpt, "yes")) sr->audio_renderer->flags |= GF_SR_AUDIO_NO_RESYNC;
else sr->audio_renderer->flags &= ~GF_SR_AUDIO_NO_RESYNC;
sOpt = gf_cfg_get_key(sr->user->config, "Audio", "DisableMultiChannel");
if (sOpt && !stricmp(sOpt, "yes")) sr->audio_renderer->flags |= GF_SR_AUDIO_NO_MULTI_CH;
else sr->audio_renderer->flags &= ~GF_SR_AUDIO_NO_MULTI_CH;
}
sr->draw_next_frame = 1;
gf_sr_lock(sr, 0);
}
static GF_Renderer *SR_New(GF_User *user)
{
const char *sOpt;
GF_VisualRenderer *vrend;
GF_GLConfig cfg, *gl_cfg;
Bool forced = 1;
GF_Renderer *tmp;
GF_SAFEALLOC(tmp, GF_Renderer);
if (!tmp) return NULL;
tmp->user = user;
/*load renderer to check for GL flag*/
if (! (user->init_flags & (GF_TERM_FORCE_2D | GF_TERM_FORCE_3D)) ) {
sOpt = gf_cfg_get_key(user->config, "Rendering", "RendererName");
if (sOpt) {
tmp->visual_renderer = (GF_VisualRenderer *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_RENDERER_INTERFACE);
if (!tmp->visual_renderer) sOpt = NULL;
}
forced = 0;
}
if (!tmp->visual_renderer) {
u32 i, count;
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
tmp->visual_renderer = (GF_VisualRenderer *) gf_modules_load_interface(user->modules, i, GF_RENDERER_INTERFACE);
if (tmp->visual_renderer) {
if ((tmp->visual_renderer->bNeedsGL && (user->init_flags & GF_TERM_FORCE_2D))
|| (!tmp->visual_renderer->bNeedsGL && (user->init_flags & GF_TERM_FORCE_3D)) ) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Renderer] Renderer %s loaded but not matching init flags %08x\n", tmp->visual_renderer->module_name, user->init_flags));
gf_modules_close_interface((GF_BaseInterface *)tmp->visual_renderer);
tmp->visual_renderer = NULL;
continue;
}
break;
}
}
if (!forced && tmp->visual_renderer) gf_cfg_set_key(user->config, "Rendering", "RendererName", tmp->visual_renderer->module_name);
}
if (!tmp->visual_renderer) {
GF_LOG(GF_LOG_ERROR, GF_LOG_RENDER, ("[Renderer] Cannot load any visual renderer - aborting\n"));
free(tmp);
return NULL;
}
memset(&cfg, 0, sizeof(cfg));
cfg.double_buffered = 1;
gl_cfg = tmp->visual_renderer->bNeedsGL ? &cfg : NULL;
vrend = tmp->visual_renderer;
tmp->visual_renderer = NULL;
/*load video out*/
sOpt = gf_cfg_get_key(user->config, "Video", "DriverName");
if (sOpt) {
tmp->video_out = (GF_VideoOutput *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_VIDEO_OUTPUT_INTERFACE);
if (tmp->video_out) {
tmp->video_out->evt_cbk_hdl = tmp;
tmp->video_out->on_event = gf_sr_on_event;
/*init hw*/
if (tmp->video_out->Setup(tmp->video_out, user->os_window_handler, user->os_display, user->init_flags, gl_cfg) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)tmp->video_out);
tmp->video_out = NULL;
}
} else {
sOpt = NULL;
}
}
if (!tmp->video_out) {
u32 i, count;
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
tmp->video_out = (GF_VideoOutput *) gf_modules_load_interface(user->modules, i, GF_VIDEO_OUTPUT_INTERFACE);
if (!tmp->video_out) continue;
tmp->video_out->evt_cbk_hdl = tmp;
tmp->video_out->on_event = gf_sr_on_event;
/*init hw*/
if (tmp->video_out->Setup(tmp->video_out, user->os_window_handler, user->os_display, user->init_flags, gl_cfg)==GF_OK) {
gf_cfg_set_key(user->config, "Video", "DriverName", tmp->video_out->module_name);
break;
}
gf_modules_close_interface((GF_BaseInterface *)tmp->video_out);
tmp->video_out = NULL;
}
}
tmp->visual_renderer = vrend;
if (!tmp->video_out ) {
gf_modules_close_interface((GF_BaseInterface *)tmp->visual_renderer);
free(tmp);
return NULL;
}
/*try to load a raster driver*/
sOpt = gf_cfg_get_key(user->config, "Rendering", "Raster2D");
if (sOpt) {
tmp->r2d = (GF_Raster2D *) gf_modules_load_interface_by_name(user->modules, sOpt, GF_RASTER_2D_INTERFACE);
if (!tmp->r2d) {
sOpt = NULL;
} else if (!check_graphics2D_driver(tmp->r2d)) {
gf_modules_close_interface((GF_BaseInterface *)tmp->r2d);
tmp->r2d = NULL;
sOpt = NULL;
}
}
if (!tmp->r2d) {
u32 i, count;
count = gf_modules_get_count(user->modules);
for (i=0; i<count; i++) {
tmp->r2d = (GF_Raster2D *) gf_modules_load_interface(user->modules, i, GF_RASTER_2D_INTERFACE);
if (!tmp->r2d) continue;
if (check_graphics2D_driver(tmp->r2d)) break;
gf_modules_close_interface((GF_BaseInterface *)tmp->r2d);
tmp->r2d = NULL;
}
if (tmp->r2d) gf_cfg_set_key(user->config, "Rendering", "Raster2D", tmp->r2d->module_name);
}
/*and init*/
if (tmp->visual_renderer->LoadRenderer(tmp->visual_renderer, tmp) != GF_OK) {
gf_modules_close_interface((GF_BaseInterface *)tmp->visual_renderer);
tmp->video_out->Shutdown(tmp->video_out);
gf_modules_close_interface((GF_BaseInterface *)tmp->video_out);
free(tmp);
return NULL;
}
tmp->mx = gf_mx_new();
tmp->textures = gf_list_new();
tmp->frame_rate = 30.0;
tmp->frame_duration = 33;
tmp->time_nodes = gf_list_new();
#ifdef GF_SR_EVENT_QUEUE
tmp->events = gf_list_new();
tmp->ev_mx = gf_mx_new();
#endif
SR_ResetFrameRate(tmp);
/*set font engine if any*/
SR_SetFontEngine(tmp);
tmp->extra_scenes = gf_list_new();
tmp->interaction_level = GF_INTERACT_NORMAL | GF_INTERACT_INPUT_SENSOR | GF_INTERACT_NAVIGATION;
return tmp;
}
/*generates an intertwined bmp from a scene file with 5 different viewpoints*/
void bifs3d_viewpoints_merger(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time)
{
GF_User user;
char out_path[GF_MAX_PATH];
char old_driv[1024];
BIFSVID b2v;
Bool needs_raw;
GF_Err e;
GF_VideoSurface fb;
unsigned char **rendered_frames;
u32 nb_viewpoints = 5;
u32 viewpoint_index;
/* Configuration of the Rendering Capabilities */
{
const char *test;
char config_path[GF_MAX_PATH];
memset(&user, 0, sizeof(GF_User));
user.config = gf_cfg_init(szConfigFile, NULL);
if (!user.config) {
fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path);
return;
}
test = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
user.modules = gf_modules_new((const unsigned char *) test, user.config);
strcpy(old_driv, "raw_out");
if (!gf_modules_get_count(user.modules)) {
printf("Error: no modules found\n");
goto err_exit;
}
/*switch driver to raw_driver*/
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (test) strcpy(old_driv, test);
needs_raw = 0;
test = gf_cfg_get_key(user.config, "Compositor", "RendererName");
/*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/
if (test && strstr(test, "2D")) {
gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output");
needs_raw = 1;
}
if (needs_raw) {
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) {
printf("couldn't load raw output driver (%s used)\n", test);
goto err_exit;
}
}
}
memset(&b2v, 0, sizeof(BIFSVID));
user.init_flags = GF_TERM_NO_AUDIO;
/* Initialization of the compositor */
b2v.sr = gf_sc_new(&user, 0, NULL);
gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0);
/* Initialization of the scene graph */
b2v.sg = gf_sg_new();
gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v);
gf_sg_set_init_callback(b2v.sg, node_init, &b2v);
gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v);
/*load config*/
gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1);
{
u32 di;
u32 track_number;
GF_ESD *esd;
u16 es_id;
b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0);
for (track_number=0; track_number<gf_isom_get_track_count(file); track_number++) {
esd = gf_isom_get_esd(file, track_number+1, 1);
if (!esd) continue;
if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break;
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
if (!esd) {
printf("no bifs track found\n");
goto err_exit;
}
es_id = (u16) gf_isom_get_track_id(file, track_number+1);
e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
if (e) {
printf("BIFS init error %s\n", gf_error_to_string(e));
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
goto err_exit;
}
{
GF_ISOSample *samp = gf_isom_get_sample(file, track_number+1, 1, &di);
b2v.cts = samp->DTS + samp->CTS_Offset;
/*apply command*/
gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0);
gf_isom_sample_del(&samp);
}
b2v.duration = gf_isom_get_media_duration(file, track_number+1);
gf_odf_desc_del((GF_Descriptor *) esd);
}
gf_sc_set_scene(b2v.sr, b2v.sg);
if (!width || !height) {
gf_sg_get_scene_size_info(b2v.sg, &width, &height);
}
/*we work in RGB24, and we must make sure the pitch is %4*/
if ((width*3)%4) {
printf("Adjusting width (%d) to have a stride multiple of 4\n", width);
while ((width*3)%4) width--;
}
gf_sc_set_size(b2v.sr, width, height);
gf_sc_get_screen_buffer(b2v.sr, &fb);
width = fb.width;
height = fb.height;
gf_sc_release_screen_buffer(b2v.sr, &fb);
GF_SAFEALLOC(rendered_frames, nb_viewpoints*sizeof(char *));
for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) {
GF_SAFEALLOC(rendered_frames[viewpoint_index-1], fb.width*fb.height*3);
gf_sc_set_viewpoint(b2v.sr, viewpoint_index, NULL);
gf_sc_draw_frame(b2v.sr, 0, NULL);
/*needed for background2D !!*/
gf_sc_draw_frame(b2v.sr, 0, NULL);
strcpy(out_path, "");
if (out_dir) {
strcat(out_path, out_dir);
if (out_path[strlen(out_path)-1] != '\\') strcat(out_path, "\\");
}
strcat(out_path, rad_name);
strcat(out_path, "_view");
gf_sc_get_screen_buffer(b2v.sr, &fb);
write_bmp(&fb, out_path, viewpoint_index);
memcpy(rendered_frames[viewpoint_index-1], fb.video_buffer, fb.width*fb.height*3);
gf_sc_release_screen_buffer(b2v.sr, &fb);
}
if (width != 800 || height != 480) {
printf("Wrong scene dimension, cannot produce output\n");
goto err_exit;
} else {
u32 x, y;
GF_VideoSurface out_fb;
u32 bpp = 3;
out_fb.width = 800;
out_fb.height = 480;
out_fb.pitch = 800*bpp;
out_fb.pixel_format = GF_PIXEL_RGB_24;
out_fb.is_hardware_memory = 0;
GF_SAFEALLOC(out_fb.video_buffer, out_fb.pitch*out_fb.height)
#if 1
for (y=0; y<out_fb.height; y++) {
/*starting red pixel is R1, R5, R4, R3, R2, R1, R5, ... when increasing line num*/
u32 line_shift = (5-y) % 5;
for (x=0; x<out_fb.width; x++) {
u32 view_shift = (line_shift+bpp*x)%5;
u32 offset = out_fb.pitch*y + x*bpp;
/* red */
out_fb.video_buffer[offset] = rendered_frames[view_shift][offset];
/* green */
out_fb.video_buffer[offset+1] = rendered_frames[(view_shift+1)%5][offset+1];
/* blue */
out_fb.video_buffer[offset+2] = rendered_frames[(view_shift+2)%5][offset+2];
}
}
#else
/*calibration*/
for (y=0; y<out_fb.height; y++) {
u32 line_shift = (5- y%5) % 5;
for (x=0; x<out_fb.width; x++) {
u32 view_shift = (line_shift+bpp*x)%5;
u32 offset = out_fb.pitch*y + x*bpp;
out_fb.video_buffer[offset] = ((view_shift)%5 == 2) ? 0xFF : 0;
out_fb.video_buffer[offset+1] = ((view_shift+1)%5 == 2) ? 0xFF : 0;
out_fb.video_buffer[offset+2] = ((view_shift+2)%5 == 2) ? 0xFF : 0;
}
}
#endif
write_bmp(&out_fb, "output", 0);
}
/*destroy everything*/
gf_bifs_decoder_del(b2v.bifs);
gf_sg_del(b2v.sg);
gf_sc_set_scene(b2v.sr, NULL);
gf_sc_del(b2v.sr);
err_exit:
/* if (rendered_frames) {
for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) {
if (rendered_frames[viewpoint_index-1]) gf_free(rendered_frames[viewpoint_index-1]);
}
gf_free(rendered_frames);
}
if (output_merged_frame) gf_free(output_merged_frame);
*/
if (user.modules) gf_modules_del(user.modules);
if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv);
gf_cfg_del(user.config);
}
//-------------------------------
// dir should end with /
int CNativeWrapper::init(JNIEnv * env, void * bitmap, jobject * callback, int width, int height, const char * cfg_dir, const char * modules_dir, const char * cache_dir, const char * font_dir, const char * gui_dir, const char * urlToLoad) {
LOGI("Initializing GPAC with URL=%s...", urlToLoad);
strcpy(m_modules_dir, modules_dir);
strcpy(m_cache_dir, cache_dir);
strcpy(m_font_dir, font_dir);
if (cfg_dir)
strcpy(m_cfg_dir, cfg_dir);
char m_cfg_filename[GF_MAX_PATH];
if (m_cfg_dir) {
LOGI("GPAC.cfg found in %s, force using it.\n", m_cfg_dir);
strcpy(m_cfg_filename, m_cfg_dir);
strcat(m_cfg_filename, "GPAC.cfg");
}
int m_Width = width;
int m_Height = height;
int first_launch = 0;
const char *opt;
m_window = env;
m_session = bitmap;
if (!mainJavaEnv)
mainJavaEnv = (JavaEnvTh *) gf_malloc(sizeof(JavaEnvTh));
memset(mainJavaEnv, 0, sizeof(JavaEnvTh));
setJavaEnv(mainJavaEnv, env, env->NewGlobalRef(*callback));
if (pthread_setspecific( jni_thread_env_key, mainJavaEnv)) {
LOGE("Failed to set specific thread data to jni_thread_env_key=%d for main thread !", jni_thread_env_key);
}
m_mx = gf_mx_new("Osmo4");
//load config file
LOGI("Loading User Config %s...", "GPAC.cfg");
m_user.config = gf_cfg_init(m_cfg_dir ? m_cfg_filename : NULL, NULL);
gf_set_progress_callback(this, Osmo4_progress_cbk);
char path[512];
strcpy(path, gui_dir);
char vertex_path[512], fragment_path[512];
strcpy(vertex_path, path);
strcpy(fragment_path, path);
strcat(vertex_path, "/../shaders/vertex.glsl");
strcat(fragment_path, "/../shaders/fragment.glsl");
gf_cfg_set_key(m_user.config, "Compositor", "VertexShader", vertex_path);
gf_cfg_set_key(m_user.config, "Compositor", "FragmentShader", fragment_path);
gf_cfg_set_key(m_user.config, "Compositor", "OpenGLMode", "hybrid");
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
LOGI("loading modules in directory %s...", opt);
m_user.modules = gf_modules_new(opt, m_user.config);
if (!m_user.modules || !gf_modules_get_count(m_user.modules)) {
LOGE("No modules found in directory %s !", opt);
if (m_user.modules)
gf_modules_del(m_user.modules);
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
/*we don't thread the visual compositor to be able to minimize the app and still have audio running*/
m_user.init_flags = GF_TERM_NO_COMPOSITOR_THREAD;
m_user.opaque = this;
m_user.os_window_handler = m_window;
m_user.os_display = m_session;
m_user.EventProc = GPAC_EventProc;
if (!javaVM) {
LOGE("NO JAVA VM FOUND, m_user=%p !!!!\n", &m_user);
return Quit(KErrGeneral);
}
LOGD("Loading GPAC terminal, m_user=%p...", &m_user);
gf_sys_init(GF_MemTrackerNone);
gf_fm_request_set_callback(this, on_fm_request);
SetupLogs();
m_term = gf_term_new(&m_user);
if (!m_term) {
LOGE("Cannot load GPAC Terminal with m_user=%p", &m_user);
MessageBox("Cannot load GPAC terminal", "Fatal Error", GF_SERVICE_ERROR);
gf_modules_del(m_user.modules);
m_user.modules = NULL;
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
/*force fullscreen*/
gf_term_set_option(m_term, GF_OPT_FULLSCREEN, 1);
//setAudioEnvironment(javaVM);
LOGD("Setting term size m_user=%p...", &m_user);
gf_term_set_size(m_term, m_Width, m_Height);
opt = gf_cfg_get_key(m_user.config, "General", "StartupFile");
LOGD("File loaded at startup=%s.", opt);
if (!urlToLoad)
urlToLoad = opt;
if (urlToLoad) {
LOGI("Connecting to %s...", urlToLoad);
gf_term_connect(m_term, urlToLoad);
}
debug_log("init end");
LOGD("Saving config file...\n");
gf_cfg_save(m_user.config);
LOGI("Initialization complete, config file saved.\n");
return 0;
}
void bifs_to_vid(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time)
{
GF_User user;
BIFSVID b2v;
u16 es_id;
Bool first_dump, needs_raw;
u32 i, j, di, count, timescale, frameNum;
u32 duration, cur_time;
GF_VideoSurface fb;
GF_Err e;
char old_driv[1024];
const char *test;
char config_path[GF_MAX_PATH];
avi_t *avi_out;
Bool reset_fps;
GF_ESD *esd;
char comp[5];
char *conv_buf;
memset(&user, 0, sizeof(GF_User));
if (szConfigFile && strlen(szConfigFile)) {
user.config = gf_cfg_init(config_path, NULL);
} else {
user.config = gf_cfg_init(NULL, NULL);
}
if (!user.config) {
fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path);
return;
}
avi_out = NULL;
conv_buf = NULL;
esd = NULL;
needs_raw = 0;
test = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
user.modules = gf_modules_new((const unsigned char *) test, user.config);
strcpy(old_driv, "raw_out");
if (!gf_modules_get_count(user.modules)) {
printf("Error: no modules found\n");
goto err_exit;
}
/*switch driver to raw_driver*/
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (test) strcpy(old_driv, test);
test = gf_cfg_get_key(user.config, "Compositor", "RendererName");
/*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/
if (test && strstr(test, "2D")) {
gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output");
needs_raw = 1;
}
needs_raw = 0;
user.init_flags = GF_TERM_NO_AUDIO | GF_TERM_FORCE_3D;
b2v.sr = gf_sc_new(&user, 0, NULL);
gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0);
b2v.sg = gf_sg_new();
gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v);
gf_sg_set_init_callback(b2v.sg, node_init, &b2v);
gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v);
/*load config*/
gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1);
b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0);
if (needs_raw) {
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) {
printf("couldn't load raw output driver (%s used)\n", test);
goto err_exit;
}
}
strcpy(config_path, "");
if (out_dir) {
strcat(config_path, out_dir);
if (config_path[strlen(config_path)-1] != '\\') strcat(config_path, "\\");
}
strcat(config_path, rad_name);
strcat(config_path, "_bifs");
if (!dump_type) {
strcat(config_path, ".avi");
avi_out = AVI_open_output_file(config_path);
comp[0] = comp[1] = comp[2] = comp[3] = comp[4] = 0;
if (!avi_out) goto err_exit;
}
for (i=0; i<gf_isom_get_track_count(file); i++) {
esd = gf_isom_get_esd(file, i+1, 1);
if (!esd) continue;
if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break;
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
if (!esd) {
printf("no bifs track found\n");
goto err_exit;
}
b2v.duration = gf_isom_get_media_duration(file, i+1);
timescale = gf_isom_get_media_timescale(file, i+1);
es_id = (u16) gf_isom_get_track_id(file, i+1);
e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
if (e) {
printf("BIFS init error %s\n", gf_error_to_string(e));
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
goto err_exit;
}
if (dump_time>=0) dump_time = dump_time *1000 / timescale;
gf_sc_set_scene(b2v.sr, b2v.sg);
count = gf_isom_get_sample_count(file, i+1);
reset_fps = 0;
if (!fps) {
fps = (Float) (count * timescale);
fps /= (Double) (s64) b2v.duration;
printf("Estimated BIFS FrameRate %g\n", fps);
reset_fps = 1;
}
if (!width || !height) {
gf_sg_get_scene_size_info(b2v.sg, &width, &height);
}
/*we work in RGB24, and we must make sure the pitch is %4*/
if ((width*3)%4) {
printf("Adjusting width (%d) to have a stride multiple of 4\n", width);
while ((width*3)%4) width--;
}
gf_sc_set_size(b2v.sr, width, height);
gf_sc_draw_frame(b2v.sr, 0, NULL);
gf_sc_get_screen_buffer(b2v.sr, &fb);
width = fb.width;
height = fb.height;
if (avi_out) {
AVI_set_video(avi_out, width, height, fps, comp);
conv_buf = gf_malloc(sizeof(char) * width * height * 3);
}
printf("Dumping at BIFS resolution %d x %d\n\n", width, height);
gf_sc_release_screen_buffer(b2v.sr, &fb);
cur_time = 0;
duration = (u32)(timescale / fps);
if (reset_fps) fps = 0;
frameNum = 1;
first_dump = 1;
for (j=0; j<count; j++) {
GF_ISOSample *samp = gf_isom_get_sample(file, i+1, j+1, &di);
b2v.cts = samp->DTS + samp->CTS_Offset;
/*apply command*/
gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0);
gf_isom_sample_del(&samp);
if ((frameID>=0) && (j<(u32)frameID)) continue;
if ((dump_time>=0) && ((u32) dump_time>b2v.cts)) continue;
/*render frame*/
gf_sc_draw_frame(b2v.sr, 0, NULL);
/*needed for background2D !!*/
if (first_dump) {
gf_sc_draw_frame(b2v.sr, 0, NULL);
first_dump = 0;
}
if (fps) {
if (cur_time > b2v.cts) continue;
while (1) {
printf("dumped frame time %f (frame %d - sample %d)\r", ((Float)cur_time)/timescale, frameNum, j+1);
dump_frame(b2v, conv_buf, config_path, dump_type, avi_out, frameNum);
frameNum++;
cur_time += duration;
if (cur_time > b2v.cts) break;
}
} else {
dump_frame(b2v, conv_buf, config_path, dump_type, avi_out, (frameID>=0) ? frameID : frameNum);
if (frameID>=0 || dump_time>=0) break;
frameNum++;
printf("dumped frame %d / %d\r", j+1, count);
}
}
gf_odf_desc_del((GF_Descriptor *) esd);
/*destroy everything*/
gf_bifs_decoder_del(b2v.bifs);
gf_sg_del(b2v.sg);
gf_sc_set_scene(b2v.sr, NULL);
gf_sc_del(b2v.sr);
err_exit:
if (avi_out) AVI_close(avi_out);
if (conv_buf) gf_free(conv_buf);
if (user.modules) gf_modules_del(user.modules);
if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv);
gf_cfg_del(user.config);
}
//-------------------------------
// dir should end with /
int CNativeWrapper::init(JNIEnv * env, void * bitmap, jobject * callback, int width, int height, const char * cfg_dir, const char * modules_dir, const char * cache_dir, const char * font_dir, const char * urlToLoad){
LOGI("Initializing GPAC with URL=%s...", urlToLoad);
strcpy(m_cfg_dir, cfg_dir);
strcpy(m_modules_dir, modules_dir);
strcpy(m_cache_dir, cache_dir);
strcpy(m_font_dir, font_dir);
char m_cfg_filename[GF_MAX_PATH];
strcpy(m_cfg_filename, m_cfg_dir);
strcat(m_cfg_filename, "GPAC.cfg");
int m_Width = width;
int m_Height = height;
int first_launch = 0;
const char *opt;
m_window = env;
m_session = bitmap;
if (!mainJavaEnv)
mainJavaEnv = (JavaEnvTh *) gf_malloc(sizeof(JavaEnvTh));
memset(mainJavaEnv, 0, sizeof(JavaEnvTh));
setJavaEnv(mainJavaEnv, env, env->NewGlobalRef(*callback));
if (pthread_setspecific( jni_thread_env_key, mainJavaEnv)){
LOGE("Failed to set specific thread data to jni_thread_env_key=%p for main thread !", jni_thread_env_key);
}
m_mx = gf_mx_new("Osmo4");
//load config file
LOGI("Loading User Config %s...", "GPAC.cfg");
m_user.config = gf_cfg_force_new(cfg_dir, "GPAC.cfg");
gf_set_progress_callback(this, Osmo4_progress_cbk);
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
if (!opt) {
FILE * fstart;
char msg[256];
LOGI("First launch, initializing new Config %s...", "GPAC.cfg");
/*hardcode module directory*/
gf_cfg_set_key(m_user.config, "Downloader", "CleanCache", "yes");
/*startup file*/
snprintf(msg, 256, "%sgui/gui.bt", cfg_dir);
fstart = fopen(msg, "r");
if (fstart){
fclose(fstart);
gf_cfg_set_key(m_user.config, "General", "StartupFile", msg);
} else {
gf_cfg_set_key(m_user.config, "General", "#StartupFile", msg);
}
gf_cfg_set_key(m_user.config, "GUI", "UnhideControlPlayer", "1");
/*setup UDP traffic autodetect*/
gf_cfg_set_key(m_user.config, "Network", "AutoReconfigUDP", "yes");
gf_cfg_set_key(m_user.config, "Network", "UDPTimeout", "10000");
gf_cfg_set_key(m_user.config, "Network", "BufferLength", "3000");
gf_cfg_set_key(m_user.config, "Compositor", "TextureTextMode", "Default");
//gf_cfg_set_key(m_user.config, "Compositor", "FrameRate", "30");
gf_cfg_set_key(m_user.config, "Audio", "ForceConfig", "no");
gf_cfg_set_key(m_user.config, "Audio", "NumBuffers", "1");
gf_cfg_set_key(m_user.config, "FontEngine", "FontReader", "ft_font");
}
/* All of this has to be done for every instance */
gf_cfg_set_key(m_user.config, "General", "ModulesDirectory", modules_dir ? modules_dir : GPAC_MODULES_DIR);
gf_cfg_set_key(m_user.config, "General", "CacheDirectory", cache_dir ? cache_dir : GPAC_CACHE_DIR);
gf_cfg_set_key(m_user.config, "General", "LastWorkingDir", cfg_dir);
gf_cfg_set_key(m_user.config, "FontEngine", "FontDirectory", GPAC_FONT_DIR);
gf_cfg_set_key(m_user.config, "Video", "DriverName", "Android Video Output");
gf_cfg_set_key(m_user.config, "Audio", "DriverName", "Android Audio Output");
opt = gf_cfg_get_key(m_user.config, "General", "ModulesDirectory");
LOGI("loading modules in directory %s...", opt);
m_user.modules = gf_modules_new(opt, m_user.config);
if (!m_user.modules || !gf_modules_get_count(m_user.modules)) {
LOGE("No modules found in directory %s !", opt);
if (m_user.modules)
gf_modules_del(m_user.modules);
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
/*we don't thread the visual compositor to be able to minimize the app and still have audio running*/
m_user.init_flags = GF_TERM_NO_COMPOSITOR_THREAD;
m_user.opaque = this;
m_user.os_window_handler = m_window;
m_user.os_display = m_session;
m_user.EventProc = GPAC_EventProc;
if (!javaVM){
LOGE("NO JAVA VM FOUND, m_user=%p !!!!\n", &m_user);
return Quit(KErrGeneral);
}
LOGD("Loading GPAC terminal, m_user=%p...", &m_user);
gf_sys_init(0);
gf_fm_request_set_callback(this, on_fm_request);
SetupLogs();
m_term = gf_term_new(&m_user);
if (!m_term) {
LOGE("Cannot load GPAC Terminal with m_user=%p", m_user);
MessageBox("Cannot load GPAC terminal", "Fatal Error", GF_SERVICE_ERROR);
gf_modules_del(m_user.modules);
m_user.modules = NULL;
gf_cfg_del(m_user.config);
m_user.config = NULL;
return Quit(KErrGeneral);
}
//setAudioEnvironment(javaVM);
LOGD("Setting term size m_user=%p...", &m_user);
gf_term_set_size(m_term, m_Width, m_Height);
opt = gf_cfg_get_key(m_user.config, "General", "StartupFile");
LOGD("File loaded at startup=%s.", opt);
if (!urlToLoad)
urlToLoad = opt;
if (urlToLoad){
LOGI("Connecting to %s...", urlToLoad);
gf_term_connect(m_term, urlToLoad);
}
debug_log("init end");
LOGD("Saving config file %s...\n", m_cfg_filename);
gf_cfg_save(m_user.config);
LOGI("Initialization complete, config file saved as %s.\n", m_cfg_filename);
return 0;
}
