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();
}
GF_Err libxml_load_svg(GF_LoadCompare *lc, char *item_path, u32 *loadtime)
{
GF_Err e = GF_OK;
GF_SceneGraph *sg;
u32 i, starttime, endtime;
void *p;
u32 nb;
if (lc->spread_repeat) nb = 1;
else nb = lc->nbloads ;
*loadtime = 0;
for (i = 0; i<nb; i++) {
sg = gf_sg_new();
starttime = gf_sys_clock();
p = DANAE_NewSVGParser(item_path, sg);
DANAE_SVGParser_Parse(p);
DANAE_SVGParser_Terminate();
endtime = gf_sys_clock();
if (lc->verbose) fprintf(stdout, "LibXML single parsing: %d\n", endtime-starttime);
*loadtime += endtime-starttime;
gf_sg_del(sg);
}
return e;
}
GF_EXPORT
void gf_beng_terminate(GF_BifsEngine *codec)
{
if (codec->bifsenc) gf_bifs_encoder_del(codec->bifsenc);
if (codec->ctx) gf_sm_del(codec->ctx);
if (codec->sg) gf_sg_del(codec->sg);
free(codec);
}
static void VTT_CleanExtraScene(VTTDec *vttdec)
{
/* Cleaning scene graph related data */
if (vttdec->sg) {
gf_scene_register_extra_graph(vttdec->scene, vttdec->sg, GF_TRUE);
gf_sg_del(vttdec->sg);
vttdec->sg = NULL;
}
}
int main(int argc, char **argv)
{
SVG_SANI_BIFS_Converter *converter;
GF_SceneDumper *dump;
char *tmp;
gf_sys_init();
GF_SAFEALLOC(converter, SVG_SANI_BIFS_Converter);
converter->sax_parser = gf_xml_sax_new(svg2bifs_node_start, svg2bifs_node_end, svg2bifs_text_content, converter);
converter->svg_sg = gf_sg_new();
gf_svg_properties_init_pointers(&converter->svg_props);
converter->bifs_sg = gf_sg_new();
fprintf(stdout, "Parsing SVG File\n");
gf_xml_sax_parse_file(converter->sax_parser, argv[1], NULL);
fprintf(stdout, "Dumping BIFS scenegraph\n");
tmp = strchr(argv[1], '.');
tmp[0] = 0;
dump = gf_sm_dumper_new(converter->bifs_sg, argv[1], ' ', GF_SM_DUMP_XMTA);
tmp[0] = '.';
gf_sm_dump_graph(dump, 1, 1);
gf_sm_dumper_del(dump);
gf_svg_properties_reset_pointers(&converter->svg_props);
gf_sg_del(converter->svg_sg);
gf_sg_del(converter->bifs_sg);
gf_xml_sax_del(converter->sax_parser);
free(converter);
}
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
void gf_seng_terminate(GF_SceneEngine *seng)
{
#ifndef GPAC_DISABLE_BIFS_ENC
if (seng->bifsenc) gf_bifs_encoder_del(seng->bifsenc);
#endif
#ifndef GPAC_DISABLE_LASER
if (seng->lsrenc) gf_laser_encoder_del(seng->lsrenc);
#endif
gf_sm_load_done(&seng->loader);
if (seng->owns_context) {
if (seng->ctx) gf_sm_del(seng->ctx);
if (seng->sg) gf_sg_del(seng->sg);
}
gf_free(seng);
}
static GF_Err TTD_DetachStream(GF_BaseDecoder *plug, u16 ES_ID)
{
TTDPriv *priv = (TTDPriv *)plug->privateStack;
if (!priv->nb_streams) return GF_BAD_PARAM;
gf_scene_register_extra_graph(priv->inlineScene, priv->sg, 1);
gf_node_unregister((GF_Node *) priv->ts_blink, NULL);
gf_node_unregister((GF_Node *) priv->process_blink, NULL);
gf_node_unregister((GF_Node *) priv->ts_scroll, NULL);
gf_node_unregister((GF_Node *) priv->process_scroll, NULL);
gf_sg_del(priv->sg);
priv->sg = NULL;
if (priv->cfg) gf_odf_desc_del((GF_Descriptor *) priv->cfg);
priv->cfg = NULL;
priv->nb_streams = 0;
gf_list_del(priv->blink_nodes);
return GF_OK;
}
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();
}
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);
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);
/*needed for background2D !!*/
if (first_dump) {
gf_sc_draw_frame(b2v.sr);
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);
}
/*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);
/*needed for background2D !!*/
gf_sc_draw_frame(b2v.sr);
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);
}
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;
}
