void V4SceneGraph::LoadNew()
{
if (m_pSm) {
gf_sr_set_scene(m_pSr, NULL);
gf_sm_del(m_pSm);
m_pSm = NULL;
gf_sg_del(m_pSg);
m_pSg = NULL;
}
if (m_pOriginal_mp4) gf_free(m_pOriginal_mp4);
m_pOriginal_mp4 = NULL;
m_pIs = gf_is_new(NULL);
m_pSg = m_pIs->graph;
gf_sg_set_init_callback(m_pSg, v4s_node_init, this);
gf_sr_set_scene(m_pSr, m_pSg);
m_pSm = gf_sm_new(m_pSg);
/* Create a BIFS stream with one AU with on ReplaceScene */
GF_StreamContext *sc = gf_sm_stream_new(m_pSm, 1, GF_STREAM_SCENE, 0);
GF_AUContext *au = gf_sm_stream_au_new(sc, 0, 0, 1);
GF_Command *command = gf_sg_command_new(m_pSg, GF_SG_SCENE_REPLACE);
gf_list_add(au->commands, command);
// reinitializes the node pool
frame->pools.Clear();
}
void V4SceneManager::LoadCommon()
{
/* Creation and initialization of the structure InlineScene, including the SceneGraph */
m_pIs = gf_inline_new(NULL);
/* Creation of the GPAC Panel which includes the creation of the terminal */
m_gpac_panel = new wxGPACPanel(this, NULL);
/* Connection of the InlineScene to the terminal */
GF_Terminal *term = m_gpac_panel->GetMPEG4Terminal();
term->root_scene = m_pIs;
/*
gf_sc_set_scene(term->compositor, m_pIs->graph);
m_pIs->graph_attached = 1;
*/
/* Creation of a SceneManager to manipulate the scene and streams */
m_pSm = gf_sm_new(m_pIs->graph);
/* Creation of main ObjectManager to manipulate the media */
m_pIs->root_od = gf_odm_new();
m_pIs->root_od->parentscene = NULL;
m_pIs->root_od->subscene = m_pIs;
m_pIs->root_od->term = term;
}
GF_EXPORT
GF_SceneEngine *gf_seng_init_from_string(void *calling_object, char * inputContext, u32 load_type, u32 width, u32 height, Bool usePixelMetrics, char *dump_path)
{
GF_SceneEngine *seng;
GF_Err e = GF_OK;
if (!inputContext) return NULL;
GF_SAFEALLOC(seng, GF_SceneEngine)
if (!seng) return NULL;
seng->calling_object = calling_object;
seng->dump_path = dump_path;
/*Step 1: create context and load input*/
seng->sg = gf_sg_new();
seng->ctx = gf_sm_new(seng->sg);
seng->owns_context = 1;
memset(& seng->loader, 0, sizeof(GF_SceneLoader));
seng->loader.ctx = seng->ctx;
seng->loader.type = load_type;
/*since we're encoding in BIFS we must get MPEG-4 nodes only*/
seng->loader.flags = GF_SM_LOAD_MPEG4_STRICT;
/* assign a loader type only if it was not requested (e.g. DIMS should not be overriden by SVG) */
if (!seng->loader.type) {
if (inputContext[0] == '<') {
if (strstr(inputContext, "<svg ")) seng->loader.type = GF_SM_LOAD_SVG;
else if (strstr(inputContext, "<saf ")) seng->loader.type = GF_SM_LOAD_XSR;
else if (strstr(inputContext, "XMT-A") || strstr(inputContext, "X3D")) seng->loader.type = GF_SM_LOAD_XMTA;
} else {
seng->loader.type = GF_SM_LOAD_BT;
}
}
e = gf_sm_load_string(&seng->loader, inputContext, 0);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[SceneEngine] cannot load context from %s (error %s)\n", inputContext, gf_error_to_string(e)));
goto exit;
}
if (!seng->ctx->root_od) {
seng->ctx->is_pixel_metrics = usePixelMetrics;
seng->ctx->scene_width = width;
seng->ctx->scene_height = height;
}
e = gf_sm_live_setup(seng);
if (e!=GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[SceneEngine] cannot init scene encoder for context (error %s)\n", gf_error_to_string(e)));
goto exit;
}
return seng;
exit:
gf_seng_terminate(seng);
return NULL;
}
GF_EXPORT
GF_BifsEngine *gf_beng_init_from_string(void *calling_object, char * inputContext, u32 width, u32 height, Bool usePixelMetrics)
{
GF_BifsEngine *codec;
GF_Err e = GF_OK;
if (!inputContext) return NULL;
GF_SAFEALLOC(codec, GF_BifsEngine)
if (!codec) return NULL;
codec->calling_object = calling_object;
/*Step 1: create context and load input*/
codec->sg = gf_sg_new();
codec->ctx = gf_sm_new(codec->sg);
memset(&(codec->load), 0, sizeof(GF_SceneLoader));
codec->load.ctx = codec->ctx;
/*since we're encoding in BIFS we must get MPEG-4 nodes only*/
codec->load.flags = GF_SM_LOAD_MPEG4_STRICT;
if (inputContext[0] == '<') {
if (strstr(inputContext, "<svg ")) codec->load.type = GF_SM_LOAD_SVG_DA;
else if (strstr(inputContext, "<saf ")) codec->load.type = GF_SM_LOAD_XSR;
else if (strstr(inputContext, "XMT-A") || strstr(inputContext, "X3D")) codec->load.type = GF_SM_LOAD_XMTA;
} else {
codec->load.type = GF_SM_LOAD_BT;
}
e = gf_sm_load_string(&codec->load, inputContext, 0);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[BENG] cannot load context from %s (error %s)\n", inputContext, gf_error_to_string(e)));
goto exit;
}
if (!codec->ctx->root_od) {
codec->ctx->is_pixel_metrics = usePixelMetrics;
codec->ctx->scene_width = width;
codec->ctx->scene_height = height;
}
e = gf_sm_live_setup(codec);
if (e!=GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[BENG] cannot init scene encoder for context (error %s)\n", gf_error_to_string(e)));
goto exit;
}
return codec;
exit:
gf_beng_terminate(codec);
return NULL;
}
static GF_Err CTXLoad_Setup(GF_BaseDecoder *plug)
{
CTXLoadPriv *priv = (CTXLoadPriv *)plug->privateStack;
if (!priv->file_name) return GF_BAD_PARAM;
priv->ctx = gf_sm_new(priv->scene->graph);
memset(&priv->load, 0, sizeof(GF_SceneLoader));
priv->load.ctx = priv->ctx;
priv->load.is = priv->scene;
priv->load.scene_graph = priv->scene->graph;
priv->load.fileName = priv->file_name;
priv->load.flags = GF_SM_LOAD_FOR_PLAYBACK;
priv->load.localPath = gf_modules_get_option((GF_BaseInterface *)plug, "General", "CacheDirectory");
priv->load.swf_import_flags = GF_SM_SWF_STATIC_DICT | GF_SM_SWF_QUAD_CURVE | GF_SM_SWF_SCALABLE_LINE | GF_SM_SWF_SPLIT_TIMELINE;
return GF_OK;
}
GF_Err decode_svg(GF_LoadCompare *lc, char *item_name, char *item_path, char *svg_out_path)
{
GF_SceneManager *ctx;
GF_SceneGraph *sg;
GF_SceneLoader load;
GF_ISOFile *mp4;
GF_Err e = GF_OK;
char mp4_path[256];
char *ext;
strcpy(mp4_path, item_name);
ext = strrchr(mp4_path, '.');
strcpy(ext, ".mp4");
mp4 = gf_isom_open(mp4_path, GF_ISOM_OPEN_READ, NULL);
if (!mp4) {
if (lc->verbose) fprintf(stdout, "Could not open file %s\n", mp4_path);
e = GF_IO_ERR;
} else {
sg = gf_sg_new();
ctx = gf_sm_new(sg);
memset(&load, 0, sizeof(GF_SceneLoader));
load.isom = mp4;
load.ctx = ctx;
e = gf_sm_load_init(&load);
if (e) {
fprintf(stderr, "Error loading MP4 file\n");
} else {
e = gf_sm_load_run(&load);
if (e) {
fprintf(stderr, "Error loading MP4 file\n");
} else {
gf_sm_load_done(&load);
ext = strrchr(svg_out_path, '.');
ext[0] = 0;
e = gf_sm_dump(ctx, svg_out_path, GF_SM_DUMP_SVG);
if (e) {
fprintf(stderr, "Error dumping SVG from MP4 file\n");
}
}
}
gf_sm_del(ctx);
gf_sg_del(sg);
gf_isom_close(mp4);
}
return e;
}
GF_EXPORT
GF_SceneEngine *gf_seng_init(void *calling_object, char * inputContext, u32 load_type, char *dump_path, Bool embed_resources)
{
GF_SceneEngine *seng;
GF_Err e = GF_OK;
if (!inputContext) return NULL;
GF_SAFEALLOC(seng, GF_SceneEngine)
if (!seng) return NULL;
seng->calling_object = calling_object;
/*Step 1: create context and load input*/
seng->sg = gf_sg_new();
gf_sg_set_node_callback(seng->sg, gf_seng_on_node_modified);
gf_sg_set_private(seng->sg, seng);
seng->dump_path = dump_path;
seng->ctx = gf_sm_new(seng->sg);
seng->owns_context = 1;
memset(&(seng->loader), 0, sizeof(GF_SceneLoader));
seng->loader.ctx = seng->ctx;
seng->loader.type = load_type;
/*since we're encoding in BIFS we must get MPEG-4 nodes only*/
seng->loader.flags = GF_SM_LOAD_MPEG4_STRICT;
if (embed_resources) seng->loader.flags |= GF_SM_LOAD_EMBEDS_RES;
seng->loader.fileName = inputContext;
e = gf_sm_load_init(&(seng->loader));
if (!e) e = gf_sm_load_run(&(seng->loader));
if (e<0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[SceneEngine] Cannot load context from %s (error %s)\n", inputContext, gf_error_to_string(e)));
goto exit;
}
e = gf_sm_live_setup(seng);
if (e!=GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[SceneEngine] cannot init scene encoder for context (error %s)\n", gf_error_to_string(e)));
goto exit;
}
return seng;
exit:
gf_seng_terminate(seng);
return NULL;
}
GF_EXPORT
GF_BifsEngine *gf_beng_init(void *calling_object, char * inputContext)
{
GF_BifsEngine *codec;
GF_Err e = GF_OK;
if (!inputContext) return NULL;
GF_SAFEALLOC(codec, GF_BifsEngine)
if (!codec) return NULL;
codec->calling_object = calling_object;
/*Step 1: create context and load input*/
codec->sg = gf_sg_new();
codec->ctx = gf_sm_new(codec->sg);
memset(&(codec->load), 0, sizeof(GF_SceneLoader));
codec->load.ctx = codec->ctx;
/*since we're encoding in BIFS we must get MPEG-4 nodes only*/
codec->load.flags = GF_SM_LOAD_MPEG4_STRICT;
codec->load.fileName = inputContext;
e = gf_sm_load_init(&(codec->load));
if (!e) e = gf_sm_load_run(&(codec->load));
gf_sm_load_done(&(codec->load));
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[BENG] Cannot load context from %s (error %s)\n", inputContext, gf_error_to_string(e)));
goto exit;
}
e = gf_sm_live_setup(codec);
if (e!=GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[BENG] cannot init scene encoder for context (error %s)\n", gf_error_to_string(e)));
goto exit;
}
return codec;
exit:
gf_beng_terminate(codec);
return NULL;
}
GF_Err gpacctx_load_file(GF_LoadCompare *lc, char *item_path, u32 *loadtime)
{
GF_Err e = GF_OK;
GF_SceneLoader load;
GF_SceneGraph *sg;
u32 i, starttime, endtime;
u32 nb;
if (lc->spread_repeat) nb = 1;
else nb = lc->nbloads ;
*loadtime = 0;
for (i = 0; i<nb; i++) {
memset(&load, 0, sizeof(GF_SceneLoader));
sg = gf_sg_new();
load.ctx = gf_sm_new(sg);
load.OnProgress = load_progress;
load.fileName = item_path;
starttime = gf_sys_clock();
e = gf_sm_load_init(&load);
if (e) {
fprintf(stderr, "Error loading file %s\n", item_path);
} else {
e = gf_sm_load_run(&load);
if (e) {
fprintf(stderr, "Error loading file %s\n", item_path);
} else {
endtime = gf_sys_clock();
*loadtime += endtime-starttime;
}
gf_sm_load_done(&load);
}
gf_sm_del(load.ctx);
gf_sg_del(sg);
}
return e;
}
GF_Err load_mp4(GF_LoadCompare *lc, GF_ISOFile *mp4, u32 *loadtime)
{
GF_Err e = GF_OK;
GF_SceneLoader load;
GF_SceneGraph *sg;
u32 i, starttime, endtime;
u32 nb;
if (lc->spread_repeat) nb = 1;
else nb = lc->nbloads ;
*loadtime = 0;
for (i = 0; i< nb; i++) {
memset(&load, 0, sizeof(GF_SceneLoader));
sg = gf_sg_new();
load.ctx = gf_sm_new(sg);
load.isom = mp4;
starttime = gf_sys_clock();
e = gf_sm_load_init(&load);
if (e) {
fprintf(stderr, "Error loading MP4 file\n");
} else {
e = gf_sm_load_run(&load);
if (e) {
fprintf(stderr, "Error loading MP4 file\n");
} else {
endtime = gf_sys_clock();
*loadtime += endtime-starttime;
}
gf_sm_load_done(&load);
}
gf_sm_del(load.ctx);
gf_sg_del(sg);
}
return e;
}
void V4SceneGraph::LoadFile(const char *path)
{
GF_SceneLoader load;
if (m_pSm) {
gf_sr_set_scene(m_pSr, NULL);
gf_sm_del(m_pSm);
gf_sg_del(m_pSg);
}
// initializes a new scene
// We need an GF_InlineScene, a SceneManager and an GF_ObjectManager
m_pIs = gf_is_new(NULL);
m_pSg = m_pIs->graph;
m_pSm = gf_sm_new(m_pSg);
m_pIs->root_od = gf_odm_new();
m_pIs->root_od->parentscene = NULL;
m_pIs->root_od->subscene = m_pIs;
m_pIs->root_od->term = m_term;
m_term->root_scene = m_pIs;
// TODO : what's the use of this ?
if (m_pOriginal_mp4) gf_free(m_pOriginal_mp4);
m_pOriginal_mp4 = NULL;
/* Loading of a file (BT, MP4 ...) and modification of the SceneManager */
memset(&load, 0, sizeof(GF_SceneLoader));
load.fileName = path;
load.ctx = m_pSm;
load.cbk = this;
if (strstr(path, ".mp4") || strstr(path, ".MP4") ) load.isom = gf_isom_open(path, GF_ISOM_OPEN_READ, NULL);
gf_sm_load_init(&load);
gf_sm_load_run(&load);
gf_sm_load_done(&load);
if (load.isom) gf_isom_delete(load.isom);
/* SceneManager should be initialized and filled correctly */
gf_sg_set_scene_size_info(m_pSg, m_pSm->scene_width, m_pSm->scene_height, m_pSm->is_pixel_metrics);
// TODO : replace with GetBifsStream
GF_StreamContext *sc = (GF_StreamContext *) gf_list_get(m_pSm->streams,0);
if (sc->streamType == 3) {
GF_AUContext *au = (GF_AUContext *) gf_list_get(sc->AUs,0);
GF_Command *c = (GF_Command *) gf_list_get(au->commands,0);
gf_sg_command_apply(m_pSg, c, 0);
/* This is a patch to solve the save pb:
When ApplyCommand is made on a Scene Replace Command
The command node is set to NULL
When we save a BIFS stream whose first command is of this kind,
the file saver thinks the bifs commands should come from an NHNT file
This is a temporary patch */
if (c->tag == GF_SG_SCENE_REPLACE) { c->node = m_pSg->RootNode; }
}
gf_sr_set_scene(m_pSr, m_pSg);
// retrieves all the node from the tree and adds them to the node pool
GF_Node * root = gf_sg_get_root_node(m_pSg);
CreateDictionnary();
}
GF_Err encode_laser(GF_LoadCompare *lc, char *item_path, GF_ISOFile *mp4, GF_SMEncodeOptions *opts)
{
GF_Err e = GF_OK;
GF_SceneLoader load;
GF_SceneManager *ctx;
GF_SceneGraph *sg;
GF_StatManager *statsman = NULL;
memset(&load, 0, sizeof(GF_SceneLoader));
sg = gf_sg_new();
ctx = gf_sm_new(sg);
load.ctx = ctx;
load.fileName = item_path;
e = gf_sm_load_init(&load);
if (e) {
fprintf(stderr, "Error loading file %s\n", item_path);
} else {
e = gf_sm_load_run(&load);
if (e) {
fprintf(stderr, "Error loading file %s\n", item_path);
} else {
if (opts->auto_qant) {
if (lc->verbose) fprintf(stdout, "Analysing Scene for Automatic Quantization\n");
statsman = gf_sm_stats_new();
e = gf_sm_stats_for_scene(statsman, ctx);
if (!e) {
GF_SceneStatistics *stats = gf_sm_stats_get(statsman);
if (opts->resolution > (s32)stats->frac_res_2d) {
if (lc->verbose) fprintf(stdout, " Given resolution %d is (unnecessarily) too high, using %d instead.\n", opts->resolution, stats->frac_res_2d);
opts->resolution = stats->frac_res_2d;
} else if (stats->int_res_2d + opts->resolution <= 0) {
if (lc->verbose) fprintf(stdout, " Given resolution %d is too low, using %d instead.\n", opts->resolution, stats->int_res_2d - 1);
opts->resolution = 1 - stats->int_res_2d;
}
opts->coord_bits = stats->int_res_2d + opts->resolution;
if (lc->verbose) fprintf(stdout, " Coordinates & Lengths encoded using ");
if (opts->resolution < 0) {
if (lc->verbose) fprintf(stdout, "only the %d most significant bits (of %d).\n", opts->coord_bits, stats->int_res_2d);
} else {
if (lc->verbose) fprintf(stdout, "a %d.%d representation\n", stats->int_res_2d, opts->resolution);
}
if (lc->verbose) fprintf(stdout, " Matrix Scale & Skew Coefficients ");
if (opts->coord_bits < stats->scale_int_res_2d) {
opts->scale_bits = stats->scale_int_res_2d - opts->coord_bits;
if (lc->verbose) fprintf(stdout, "encoded using a %d.8 representation\n", stats->scale_int_res_2d);
} else {
opts->scale_bits = 0;
if (lc->verbose) fprintf(stdout, "not encoded.\n");
}
}
gf_sm_stats_del(statsman);
}
e = gf_sm_encode_to_file(ctx, mp4, opts);
if (e) {
fprintf(stderr, "Error while encoding mp4 file\n");
} else {
e = gf_isom_set_brand_info(mp4, GF_ISOM_BRAND_MP42, 1);
if (!e) e = gf_isom_modify_alternate_brand(mp4, GF_ISOM_BRAND_ISOM, 1);
}
gf_sm_load_done(&load);
}
}
gf_sm_del(ctx);
gf_sg_del(sg);
return e;
}
