GF_Err gf_bifs_enc_route(GF_BifsEncoder *codec, GF_Route *r, GF_BitStream *bs)
{
GF_Err e;
u32 numBits, ind;
if (!r) return GF_BAD_PARAM;
GF_BIFS_WRITE_INT(codec, bs, r->ID ? 1: 0, 1, "isDEF", NULL);
/*def'ed route*/
if (r->ID) {
GF_BIFS_WRITE_INT(codec, bs, r->ID-1, codec->info->config.RouteIDBits, "routeID", NULL);
if (codec->UseName) gf_bifs_enc_name(codec, bs, r->name);
}
/*origin*/
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(r->FromNode) - 1, codec->info->config.NodeIDBits, "outNodeID", NULL);
numBits = gf_node_get_num_fields_in_mode(r->FromNode, GF_SG_FIELD_CODING_OUT) - 1;
numBits = gf_get_bit_size(numBits);
e = gf_bifs_field_index_by_mode(r->FromNode, r->FromField.fieldIndex, GF_SG_FIELD_CODING_OUT, &ind);
if (e) return e;
GF_BIFS_WRITE_INT(codec, bs, ind, numBits, "outField", NULL);
/*target*/
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(r->ToNode) - 1, codec->info->config.NodeIDBits, "inNodeID", NULL);
numBits = gf_node_get_num_fields_in_mode(r->ToNode, GF_SG_FIELD_CODING_IN) - 1;
numBits = gf_get_bit_size(numBits);
e = gf_bifs_field_index_by_mode(r->ToNode, r->ToField.fieldIndex, GF_SG_FIELD_CODING_IN, &ind);
GF_BIFS_WRITE_INT(codec, bs, ind, numBits, "inField", NULL);
return e;
}
GF_Err BM_ParseRouteInsert(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
GF_Err e;
u8 flag;
GF_Command *com;
GF_Node *InNode, *OutNode;
u32 RouteID, outField, inField, numBits, ind, node_id;
char name[1000];
RouteID = 0;
flag = gf_bs_read_int(bs, 1);
/*def'ed route*/
if (flag) {
RouteID = 1 + gf_bs_read_int(bs, codec->info->config.RouteIDBits);
if (codec->UseName) gf_bifs_dec_name(bs, name);
}
/*origin*/
node_id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
OutNode = gf_sg_find_node(codec->current_graph, node_id);
if (!OutNode) return GF_SG_UNKNOWN_NODE;
numBits = gf_node_get_num_fields_in_mode(OutNode, GF_SG_FIELD_CODING_OUT) - 1;
numBits = gf_get_bit_size(numBits);
ind = gf_bs_read_int(bs, numBits);
e = gf_bifs_get_field_index(OutNode, ind, GF_SG_FIELD_CODING_OUT, &outField);
/*target*/
node_id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
InNode = gf_sg_find_node(codec->current_graph, node_id);
if (!InNode) return GF_SG_UNKNOWN_NODE;
numBits = gf_node_get_num_fields_in_mode(InNode, GF_SG_FIELD_CODING_IN) - 1;
numBits = gf_get_bit_size(numBits);
ind = gf_bs_read_int(bs, numBits);
e = gf_bifs_get_field_index(InNode, ind, GF_SG_FIELD_CODING_IN, &inField);
if (e) return e;
com = gf_sg_command_new(codec->current_graph, GF_SG_ROUTE_INSERT);
com->RouteID = RouteID;
if (codec->UseName) com->def_name = gf_strdup( name);
com->fromNodeID = gf_node_get_id(OutNode);
com->fromFieldIndex = outField;
com->toNodeID = gf_node_get_id(InNode);
com->toFieldIndex = inField;
gf_list_add(com_list, com);
return codec->LastError;
}
GF_Err BE_FieldReplace(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
GF_Err e;
u32 ind, NumBits;
GF_FieldInfo field;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &ind);
GF_BIFS_WRITE_INT(codec, bs, ind, NumBits, "field", NULL);
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
field.far_ptr = inf->field_ptr;
/* Warning: To be changed when proper solution is found */
if (gf_sg_vrml_get_sf_type(field.fieldType) == GF_SG_VRML_SFSCRIPT) codec->is_encoding_command = 1;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
codec->is_encoding_command = 0;
return e;
}
GF_Err BE_IndexDelete(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
u32 NumBits, ind;
GF_Err e;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN) - 1);
e = gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &ind);
if (e) return e;
GF_BIFS_WRITE_INT(codec, bs, ind, NumBits, "field", NULL);
switch (inf->pos) {
case 0:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FIRST", "idw");
break;
case -1:
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "LAST", "idx");
break;
default:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "pos", "idx");
GF_BIFS_WRITE_INT(codec, bs, inf->pos, 16, "pos", NULL);
break;
}
return GF_OK;
}
/*inserts a node in a container (node.children)*/
GF_Err BE_NodeInsert(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
u32 NDT;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
NDT = gf_bifs_get_child_table(com->node);
switch (inf->pos) {
case 0:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FIRST", "idx");
break;
case -1:
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "LAST", "idx");
break;
default:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "pos", "idx");
GF_BIFS_WRITE_INT(codec, bs, inf->pos, 8, "pos", NULL);
break;
}
return gf_bifs_enc_node(codec, inf->new_node, NDT, bs);
}
static GF_Err BE_ExtendedUpdate(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Insert", NULL);
GF_BIFS_WRITE_INT(codec, bs, 1, 2, "ExtendedUpdate", NULL);
switch (com->tag) {
case GF_SG_PROTO_INSERT:
GF_BIFS_WRITE_INT(codec, bs, 0, 8, "MultipleReplace", NULL);
return BE_EncProtoList(codec, com->new_proto_list, bs);
case GF_SG_PROTO_DELETE:
GF_BIFS_WRITE_INT(codec, bs, 1, 8, "ProtoDelete", NULL);
return BE_EncProtoDelete(codec, com, bs);
case GF_SG_PROTO_DELETE_ALL:
GF_BIFS_WRITE_INT(codec, bs, 2, 8, "DeleteAllProtos", NULL);
return GF_OK;
case GF_SG_MULTIPLE_INDEXED_REPLACE:
GF_BIFS_WRITE_INT(codec, bs, 3, 8, "MultipleReplace", NULL);
return BE_MultipleIndexedReplace(codec, com, bs);
case GF_SG_MULTIPLE_REPLACE:
GF_BIFS_WRITE_INT(codec, bs, 4, 8, "MultipleReplace", NULL);
return BE_MultipleReplace(codec, com, bs);
case GF_SG_GLOBAL_QUANTIZER:
GF_BIFS_WRITE_INT(codec, bs, 5, 8, "GlobalQuantizer", NULL);
return BE_GlobalQuantizer(codec, com, bs);
case GF_SG_NODE_DELETE_EX:
GF_BIFS_WRITE_INT(codec, bs, 6, 8, "MultipleReplace", NULL);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
return GF_OK;
case GF_SG_XREPLACE:
GF_BIFS_WRITE_INT(codec, bs, 7, 8, "XReplace", NULL);
return BE_XReplace(codec, com, bs);
default:
return GF_BAD_PARAM;
}
}
// OnAddToTimeLine -- adds a node in the timeline (meaning creating a node ID and adding it to the dictionnary and the pool)
void V4StudioFrame::OnAddToTimeLine(wxCommandEvent &event) {
if (!m_pV4sm) return;
if (!m_selection) return; // don't add nothing
// if object has no node id then create one
if (! gf_node_get_id(m_selection) )
m_pV4sm->CreateIDandAddToPool(m_selection);
// Adds the node to the dictionnary
// m_pV4sm->AddToDictionnary(m_selection);
// calls timeline function to add the line
char c[50];
strcpy(c, gf_node_get_name(m_selection));
timeLine->AddLine( gf_node_get_id(m_selection), wxString(c) );
}
GF_Err BE_NodeReplace(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
return gf_bifs_enc_node(codec, inf->new_node, NDT_SFWorldNode, bs);
}
GF_EXPORT
GF_Err gf_bifs_encoder_get_config(GF_BifsEncoder *codec, u16 ESID, char **out_data, u32 *out_data_length)
{
GF_BitStream *bs;
if (!codec || !out_data || !out_data_length) return GF_BAD_PARAM;
// gf_mx_p(codec->mx);
codec->info = BE_GetStream(codec, ESID);
if (!codec->info) {
// gf_mx_v(codec->mx);
return GF_BAD_PARAM;
}
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
if (codec->info->config.version==2) {
gf_bs_write_int(bs, codec->info->config.Use3DMeshCoding ? 1 : 0, 1);
gf_bs_write_int(bs, codec->info->config.UsePredictiveMFField ? 1 : 0, 1);
}
gf_bs_write_int(bs, codec->info->config.NodeIDBits, 5);
gf_bs_write_int(bs, codec->info->config.RouteIDBits, 5);
if (codec->info->config.version==2) {
gf_bs_write_int(bs, codec->info->config.ProtoIDBits, 5);
}
if (codec->info->config.elementaryMasks) {
u32 i, count;
gf_bs_write_int(bs, 0, 1);
gf_bs_write_int(bs, codec->info->config.BAnimRAP, 1);
count = gf_list_count(codec->info->config.elementaryMasks);
for (i=0; i<count; i++) {
BIFSElementaryMask *em = (BIFSElementaryMask *)gf_list_get(codec->info->config.elementaryMasks, i);
if (em->node) gf_bs_write_int(bs, gf_node_get_id((GF_Node*)em->node), codec->info->config.NodeIDBits);
else gf_bs_write_int(bs, em->node_id, codec->info->config.NodeIDBits);
gf_bs_write_int(bs, (i+1==count) ? 0 : 1, 1);
}
} else {
gf_bs_write_int(bs, 1, 1);
gf_bs_write_int(bs, codec->info->config.PixelMetrics ? 1 : 0, 1);
if (codec->info->config.Width || codec->info->config.Height) {
gf_bs_write_int(bs, 1, 1);
gf_bs_write_int(bs, codec->info->config.Width, 16);
gf_bs_write_int(bs, codec->info->config.Height, 16);
} else {
gf_bs_write_int(bs, 0, 1);
}
}
gf_bs_align(bs);
gf_bs_get_content(bs, out_data, out_data_length);
gf_bs_del(bs);
// gf_mx_v(codec->mx);
return GF_OK;
}
Bool BE_NodeIsUSE(GF_BifsEncoder * codec, GF_Node *node)
{
u32 i, count;
if (!node || !gf_node_get_id(node) ) return GF_FALSE;
count = gf_list_count(codec->encoded_nodes);
for (i=0; i<count; i++) {
if (gf_list_get(codec->encoded_nodes, i) == node) return GF_TRUE;
}
gf_list_add(codec->encoded_nodes, node);
return GF_FALSE;
}
GF_Node *V4SceneGraph::CopyNode(GF_Node *node, GF_Node *parent, bool copy)
{
if (copy) return CloneNodeForEditing(m_pSg, node);
u32 nodeID = gf_node_get_id(node);
if (!nodeID) {
nodeID = gf_sg_get_next_available_node_id(m_pSg);
gf_node_set_id(node, nodeID, NULL);
gf_node_register(node, parent);
}
return node;
}
Bool StatIsUSE(GF_StatManager *st, GF_Node *n)
{
u32 i;
GF_Node *ptr;
if (!n || !gf_node_get_id(n) ) return 0;
i=0;
while ((ptr = (GF_Node*)gf_list_enum(st->def_nodes, &i))) {
if (ptr == n) return 1;
}
gf_list_add(st->def_nodes, n);
return 0;
}
GF_Err BM_ParseRouteReplace(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
GF_Err e;
GF_Command *com;
u32 RouteID, numBits, ind, node_id, fromID, toID;
GF_Route *r;
GF_Node *OutNode, *InNode;
RouteID = 1+gf_bs_read_int(bs, codec->info->config.RouteIDBits);
r = gf_sg_route_find(codec->current_graph, RouteID);
/*origin*/
node_id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
OutNode = gf_sg_find_node(codec->current_graph, node_id);
if (!OutNode) return GF_NON_COMPLIANT_BITSTREAM;
numBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(OutNode, GF_SG_FIELD_CODING_OUT) - 1);
ind = gf_bs_read_int(bs, numBits);
e = gf_bifs_get_field_index(OutNode, ind, GF_SG_FIELD_CODING_OUT, &fromID);
if (e) return e;
/*target*/
node_id = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
InNode = gf_sg_find_node(codec->current_graph, node_id);
if (!InNode) return GF_NON_COMPLIANT_BITSTREAM;
numBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(InNode, GF_SG_FIELD_CODING_IN) - 1);
ind = gf_bs_read_int(bs, numBits);
e = gf_bifs_get_field_index(InNode, ind, GF_SG_FIELD_CODING_IN, &toID);
if (e) return e;
com = gf_sg_command_new(codec->current_graph, GF_SG_ROUTE_REPLACE);
com->RouteID = RouteID;
com->fromNodeID = gf_node_get_id(OutNode);
com->fromFieldIndex = fromID;
com->toNodeID = gf_node_get_id(InNode);
com->toFieldIndex = toID;
gf_list_add(com_list, com);
return codec->LastError;
}
void InitTimeSensor(GF_Renderer *sr, GF_Node *node)
{
TimeSensorStack *st;
GF_SAFEALLOC(st, TimeSensorStack);
st->time_handle.UpdateTimeNode = UpdateTimeSensor;
st->time_handle.obj = node;
st->store_info = 1;
st->compositor = sr;
st->is_x3d = (gf_node_get_tag(node)==TAG_X3D_TimeSensor) ? 1 : 0;
gf_node_set_private(node, st);
gf_node_set_callback_function(node, DestroyTimeSensor);
/*time sensor needs to be run only if def'ed, otherwise it doesn't impact scene*/
if (gf_node_get_id(node)) gf_sr_register_time_node(sr, &st->time_handle);
}
GF_Err BM_SceneReplace(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
GF_Command *com;
GF_Node *backup_root;
GF_List *backup_routes;
GF_Err BD_DecSceneReplace(GF_BifsDecoder * codec, GF_BitStream *bs, GF_List *proto_list);
backup_routes = codec->scenegraph->Routes;
backup_root = codec->scenegraph->RootNode;
com = gf_sg_command_new(codec->current_graph, GF_SG_SCENE_REPLACE);
codec->scenegraph->Routes = gf_list_new();
codec->current_graph = codec->scenegraph;
codec->LastError = BD_DecSceneReplace(codec, bs, com->new_proto_list);
com->use_names = codec->UseName;
/*restore*/
com->node = codec->scenegraph->RootNode;
codec->scenegraph->RootNode = backup_root;
gf_list_add(com_list, com);
/*insert routes*/
while (gf_list_count(codec->scenegraph->Routes)) {
GF_Route *r = (GF_Route*)gf_list_get(codec->scenegraph->Routes, 0);
GF_Command *ri = gf_sg_command_new(codec->current_graph, GF_SG_ROUTE_INSERT);
gf_list_rem(codec->scenegraph->Routes, 0);
ri->fromFieldIndex = r->FromField.fieldIndex;
ri->fromNodeID = gf_node_get_id(r->FromNode);
ri->toFieldIndex = r->ToField.fieldIndex;
ri->toNodeID = gf_node_get_id(r->ToNode);
if (r->ID) ri->RouteID = r->ID;
ri->def_name = r->name ? gf_strdup(r->name) : NULL;
gf_list_add(com_list, ri);
gf_sg_route_del(r);
}
gf_list_del(codec->scenegraph->Routes);
codec->scenegraph->Routes = backup_routes;
return codec->LastError;
}
static GF_Err BE_MultipleReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i, j, nbBits, count, numFields, allField;
Bool use_list;
GF_FieldInfo field;
GF_Err e;
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
count = gf_list_count(com->command_fields);
use_list = 1;
numFields = gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_DEF);
nbBits = gf_get_bit_size(numFields - 1);
if (count < 1+count*(1+nbBits)) use_list = 0;
GF_BIFS_WRITE_INT(codec, bs, use_list ? 0 : 1, 1, "isMask", NULL);
for (i=0; i<numFields; i++) {
GF_CommandField *inf = NULL;
gf_bifs_get_field_index(com->node, i, GF_SG_FIELD_CODING_DEF, &allField);
for (j=0; j<count; j++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, j);
if (inf->fieldIndex==allField) break;
inf = NULL;
}
if (!inf) {
if (!use_list) GF_BIFS_WRITE_INT(codec, bs, 0, 1, "Mask", NULL);
continue;
}
/*common case*/
gf_node_get_field(com->node, inf->fieldIndex, &field);
if (use_list) {
/*not end flag*/
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "end", NULL);
} else {
/*mask flag*/
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "Mask", NULL);
}
if (use_list) GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", (char*)field.name);
field.far_ptr = inf->field_ptr;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
if (e) return e;
}
/*end flag*/
if (use_list) GF_BIFS_WRITE_INT(codec, bs, 1, 1, "end", NULL);
return GF_OK;
}
GF_Err BE_IndexInsert(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
GF_Err e;
u32 NumBits, ind;
GF_FieldInfo field, sffield;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
/*index insertion uses IN mode for field index*/
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &ind);
GF_BIFS_WRITE_INT(codec, bs, ind, NumBits, "field", NULL);
switch (inf->pos) {
case 0:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FIRST", "idx");
break;
case -1:
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "LAST", "idx");
break;
default:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "pos", "idx");
GF_BIFS_WRITE_INT(codec, bs, inf->pos, 16, "pos", NULL);
break;
}
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
if (gf_sg_vrml_is_sf_field(field.fieldType))
return GF_NON_COMPLIANT_BITSTREAM;
memcpy(&sffield, &field, sizeof(GF_FieldInfo));
sffield.fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
sffield.far_ptr = inf->field_ptr;
/*rescale the MFField and parse the SFField*/
if (field.fieldType==GF_SG_VRML_MFNODE) {
return gf_bifs_enc_node(codec, inf->new_node, field.NDTtype, bs);
} else {
return gf_bifs_enc_sf_field(codec, bs, com->node, &sffield);
}
}
static GF_Err BE_MultipleIndexedReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i,nbBits, count, maxPos, nbBitsPos;
GF_FieldInfo field;
GF_Err e;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", NULL);
gf_node_get_field(com->node, inf->fieldIndex, &field);
field.fieldType = inf->fieldType;
count = gf_list_count(com->command_fields);
maxPos = 0;
for (i=0; i<count; i++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, i);
if (maxPos < (u32) inf->pos) maxPos = inf->pos;
}
nbBitsPos = gf_get_bit_size(maxPos);
GF_BIFS_WRITE_INT(codec, bs, nbBitsPos, 5, "nbBitsPos", NULL);
nbBits = gf_get_bit_size(count);
GF_BIFS_WRITE_INT(codec, bs, nbBits, 5, "nbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, count, nbBits, "count", NULL);
for (i=0; i<count; i++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, i);
GF_BIFS_WRITE_INT(codec, bs, inf->pos, nbBitsPos, "idx", NULL);
field.far_ptr = inf->field_ptr;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
if (e) return e;
}
return GF_OK;
}
// AddRecursive -- recursively adds items with an ID to the dictionnary
void V4SceneManager::AddRecursive(GF_Node * node, bool parentAdded) {
// skips empty nodes
if (!node) return;
// skips the dictionnary
const char * c = gf_node_get_name(node);
if ( (c != NULL) && (!strcmp(c, DICTNAME)) ) return;
// if node as an id adds it to the dictionnary and the node pool
u32 id = gf_node_get_id(node);
if (id) {
pools.Add(node);
// children of added node are not added to the dictionnary
if (!parentAdded) AddEffective(node);
parentAdded = true;
}
GF_FieldInfo field;
GF_ChildNodeItem * list;
int count = gf_node_get_field_count(node);
// tests all fields, if a field is a node then adds it and process its children recursively
for (int i=0; i<count; i++) {
gf_node_get_field(node, i, &field);
// single value node field
if (field.fieldType == GF_SG_VRML_SFNODE)
AddRecursive( * ((GF_Node **) field.far_ptr), parentAdded );
// multiple value node field
if (field.fieldType == GF_SG_VRML_MFNODE) {
list = *( (GF_ChildNodeItem **) field.far_ptr);
for (u32 j=0; j<gf_node_list_get_count(list); j++)
AddRecursive( (GF_Node *) gf_node_list_get_child(list, j), parentAdded );
}
}
}
GF_Err gf_bifs_enc_sf_field(GF_BifsEncoder *codec, GF_BitStream *bs, GF_Node *node, GF_FieldInfo *field)
{
GF_Err e;
if (node) {
e = gf_bifs_enc_quant_field(codec, bs, node, field);
if (e != GF_EOS) return e;
}
switch (field->fieldType) {
case GF_SG_VRML_SFBOOL:
GF_BIFS_WRITE_INT(codec, bs, * ((SFBool *)field->far_ptr), 1, "SFBool", NULL);
break;
case GF_SG_VRML_SFCOLOR:
BE_WriteSFFloat(codec, ((SFColor *)field->far_ptr)->red, bs, "color.red");
BE_WriteSFFloat(codec, ((SFColor *)field->far_ptr)->green, bs, "color.green");
BE_WriteSFFloat(codec, ((SFColor *)field->far_ptr)->blue, bs, "color.blue");
break;
case GF_SG_VRML_SFFLOAT:
BE_WriteSFFloat(codec, * ((SFFloat *)field->far_ptr), bs, NULL);
break;
case GF_SG_VRML_SFINT32:
GF_BIFS_WRITE_INT(codec, bs, * ((SFInt32 *)field->far_ptr), 32, "SFInt32", NULL);
break;
case GF_SG_VRML_SFROTATION:
BE_WriteSFFloat(codec, ((SFRotation *)field->far_ptr)->x, bs, "rot.x");
BE_WriteSFFloat(codec, ((SFRotation *)field->far_ptr)->y, bs, "rot.y");
BE_WriteSFFloat(codec, ((SFRotation *)field->far_ptr)->z, bs, "rot.z");
BE_WriteSFFloat(codec, ((SFRotation *)field->far_ptr)->q, bs, "rot.theta");
break;
case GF_SG_VRML_SFSTRING:
if (node && (node->sgprivate->tag==TAG_MPEG4_CacheTexture) && (field->fieldIndex<=2)) {
u32 size, val;
char buf[4096];
char *res_src = NULL;
const char *src = ((SFString*)field->far_ptr)->buffer;
FILE *f;
if (codec->src_url) res_src = gf_url_concatenate(codec->src_url, src);
f = gf_fopen(res_src ? res_src : src, "rb");
if (!f) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[BIFS] Cannot open source file %s for encoding CacheTexture\n", res_src ? res_src : src));
return GF_URL_ERROR;
}
if (res_src) gf_free(res_src);
gf_fseek(f, 0, SEEK_END);
size = (u32) gf_ftell(f);
val = gf_get_bit_size(size);
GF_BIFS_WRITE_INT(codec, bs, val, 5, "nbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, size, val, "length", NULL);
gf_fseek(f, 0, SEEK_SET);
while (size) {
u32 read = (u32) fread(buf, 1, 4096, f);
gf_bs_write_data(bs, buf, read);
size -= read;
}
} else {
u32 i, val, len;
char *str = (char *) ((SFString*)field->far_ptr)->buffer;
if (node && (node->sgprivate->tag==TAG_MPEG4_BitWrapper) ) {
len = ((M_BitWrapper*)node)->buffer_len;
} else {
len = str ? (u32) strlen(str) : 0;
}
val = gf_get_bit_size(len);
GF_BIFS_WRITE_INT(codec, bs, val, 5, "nbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, len, val, "length", NULL);
for (i=0; i<len; i++) gf_bs_write_int(bs, str[i], 8);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] string\t\t%d\t\t%s\n", 8*len, str) );
}
break;
case GF_SG_VRML_SFTIME:
gf_bs_write_double(bs, *((SFTime *)field->far_ptr));
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] SFTime\t\t%d\t\t%g\n", 64, *((SFTime *)field->far_ptr)));
break;
case GF_SG_VRML_SFVEC2F:
BE_WriteSFFloat(codec, ((SFVec2f *)field->far_ptr)->x, bs, "vec2f.x");
BE_WriteSFFloat(codec, ((SFVec2f *)field->far_ptr)->y, bs, "vec2f.y");
break;
case GF_SG_VRML_SFVEC3F:
BE_WriteSFFloat(codec, ((SFVec3f *)field->far_ptr)->x, bs, "vec3f.x");
BE_WriteSFFloat(codec, ((SFVec3f *)field->far_ptr)->y, bs, "vec3f.y");
BE_WriteSFFloat(codec, ((SFVec3f *)field->far_ptr)->z, bs, "vec3f.z");
break;
case GF_SG_VRML_SFURL:
{
SFURL *url = (SFURL *) field->far_ptr;
GF_BIFS_WRITE_INT(codec, bs, (url->OD_ID>0) ? 1 : 0, 1, "hasODID", "SFURL");
if (url->OD_ID>0) {
GF_BIFS_WRITE_INT(codec, bs, url->OD_ID, 10, "ODID", "SFURL");
} else {
u32 i, len = url->url ? (u32) strlen(url->url) : 0;
u32 val = gf_get_bit_size(len);
GF_BIFS_WRITE_INT(codec, bs, val, 5, "nbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, len, val, "length", NULL);
for (i=0; i<len; i++) gf_bs_write_int(bs, url->url[i], 8);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] string\t\t%d\t\t%s\t\t//SFURL\n", 8*len, url->url));
}
}
break;
case GF_SG_VRML_SFIMAGE:
{
u32 size, i;
SFImage *img = (SFImage *)field->far_ptr;
GF_BIFS_WRITE_INT(codec, bs, img->width, 12, "width", "SFImage");
GF_BIFS_WRITE_INT(codec, bs, img->height, 12, "height", "SFImage");
GF_BIFS_WRITE_INT(codec, bs, img->numComponents - 1, 2, "nbComp", "SFImage");
size = img->width * img->height * img->numComponents;
for (i=0; i<size; i++) gf_bs_write_int(bs, img->pixels[i], 8);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] pixels\t\t%d\t\tnot dumped\t\t//SFImage\n", 8*size));
}
break;
case GF_SG_VRML_SFCOMMANDBUFFER:
{
SFCommandBuffer *cb = (SFCommandBuffer *) field->far_ptr;
if (cb->buffer) gf_free(cb->buffer);
cb->buffer = NULL;
cb->bufferSize = 0;
if (gf_list_count(cb->commandList)) {
u32 i, nbBits;
GF_BitStream *bs_cond = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] /*SFCommandBuffer*/\n" ));
e = gf_bifs_enc_commands(codec, cb->commandList, bs_cond);
if (!e) gf_bs_get_content(bs_cond, (char**)&cb->buffer, &cb->bufferSize);
gf_bs_del(bs_cond);
if (e) return e;
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] /*End SFCommandBuffer*/\n"));
nbBits = gf_get_bit_size(cb->bufferSize);
GF_BIFS_WRITE_INT(codec, bs, nbBits, 5, "NbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, cb->bufferSize, nbBits, "BufferSize", NULL);
for (i=0; i<cb->bufferSize; i++) GF_BIFS_WRITE_INT(codec, bs, cb->buffer[i], 8, "buffer byte", NULL);
}
/*empty command buffer*/
else {
GF_BIFS_WRITE_INT(codec, bs, 0, 5, "NbBits", NULL);
}
}
break;
case GF_SG_VRML_SFNODE:
return gf_bifs_enc_node(codec, *((GF_Node **)field->far_ptr), field->NDTtype, bs, node);
case GF_SG_VRML_SFSCRIPT:
#ifdef GPAC_HAS_SPIDERMONKEY
codec->LastError = SFScript_Encode(codec, (SFScript *)field->far_ptr, bs, node);
#else
return GF_NOT_SUPPORTED;
#endif
break;
case GF_SG_VRML_SFATTRREF:
{
u32 idx=0;
SFAttrRef *ar = (SFAttrRef *)field->far_ptr;
u32 nbBitsDEF = gf_get_bit_size(gf_node_get_num_fields_in_mode(ar->node, GF_SG_FIELD_CODING_DEF) - 1);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(ar->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
gf_bifs_field_index_by_mode(ar->node, ar->fieldIndex, GF_SG_FIELD_CODING_DEF, &idx);
GF_BIFS_WRITE_INT(codec, bs, idx, nbBitsDEF, "field", NULL);
}
break;
default:
return GF_NOT_SUPPORTED;
}
return codec->LastError;
}
GF_Err gf_bifs_enc_node(GF_BifsEncoder * codec, GF_Node *node, u32 NDT_Tag, GF_BitStream *bs, GF_Node *parent_node)
{
u32 NDTBits, node_type, node_tag, BVersion, node_id;
const char *node_name;
Bool flag, reset_qp14;
GF_Node *new_node;
GF_Err e;
assert(codec->info);
GF_LOG(GF_LOG_DEBUG, GF_LOG_CODEC, ("[BIFS] Encode node %s\n", gf_node_get_class_name(node) ));
/*NULL node is a USE of maxID*/
if (!node) {
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "USE", NULL);
GF_BIFS_WRITE_INT(codec, bs, (1<<codec->info->config.NodeIDBits) - 1 , codec->info->config.NodeIDBits, "NodeID", "NULL");
return GF_OK;
}
flag = BE_NodeIsUSE(codec, node);
GF_BIFS_WRITE_INT(codec, bs, flag ? 1 : 0, 1, "USE", (char*)gf_node_get_class_name(node));
if (flag) {
gf_bs_write_int(bs, gf_node_get_id(node) - 1, codec->info->config.NodeIDBits);
new_node = gf_bifs_enc_find_node(codec, gf_node_get_id(node) );
if (!new_node)
return codec->LastError = GF_SG_UNKNOWN_NODE;
/*restore QP14 length*/
switch (gf_node_get_tag(new_node)) {
case TAG_MPEG4_Coordinate:
{
u32 nbCoord = ((M_Coordinate *)new_node)->point.count;
gf_bifs_enc_qp14_enter(codec, GF_TRUE);
gf_bifs_enc_qp14_set_length(codec, nbCoord);
gf_bifs_enc_qp14_enter(codec, GF_FALSE);
}
break;
case TAG_MPEG4_Coordinate2D:
{
u32 nbCoord = ((M_Coordinate2D *)new_node)->point.count;
gf_bifs_enc_qp14_enter(codec, GF_TRUE);
gf_bifs_enc_qp14_set_length(codec, nbCoord);
gf_bifs_enc_qp14_enter(codec, GF_FALSE);
}
break;
}
return GF_OK;
}
BVersion = GF_BIFS_V1;
node_tag = node->sgprivate->tag;
while (1) {
node_type = gf_bifs_get_node_type(NDT_Tag, node_tag, BVersion);
NDTBits = gf_bifs_get_ndt_bits(NDT_Tag, BVersion);
if (BVersion==2 && (node_tag==TAG_ProtoNode)) node_type = 1;
GF_BIFS_WRITE_INT(codec, bs, node_type, NDTBits, "ndt", NULL);
if (node_type) break;
BVersion += 1;
if (BVersion > GF_BIFS_NUM_VERSION) {
if (parent_node) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[BIFS] Cannot encode node %s as a child of %s\n", gf_node_get_class_name(node), gf_node_get_class_name(parent_node) ));
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[BIFS] Cannot encode node %s in the SFWorldNode context\n", gf_node_get_class_name(node) ));
}
return codec->LastError = GF_BIFS_UNKNOWN_VERSION;
}
}
if (BVersion==2 && node_type==1) {
GF_Proto *proto = ((GF_ProtoInstance *)node)->proto_interface;
GF_BIFS_WRITE_INT(codec, bs, proto->ID, codec->info->config.ProtoIDBits, "protoID", NULL);
}
/*special handling of 3D mesh*/
/*DEF'd node*/
node_name = gf_node_get_name_and_id(node, &node_id);
GF_BIFS_WRITE_INT(codec, bs, node_id ? 1 : 0, 1, "DEF", NULL);
if (node_id) {
GF_BIFS_WRITE_INT(codec, bs, node_id - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
if (codec->UseName) gf_bifs_enc_name(codec, bs, (char*) node_name );
}
/*no updates of time fields for now - NEEDED FOR A LIVE ENCODER*/
/*if coords were not stored for QP14 before coding this node, reset QP14 it when leaving*/
reset_qp14 = !codec->coord_stored;
/*QP14 case*/
switch (node_tag) {
case TAG_MPEG4_Coordinate:
case TAG_MPEG4_Coordinate2D:
gf_bifs_enc_qp14_enter(codec, GF_TRUE);
}
e = EncNodeFields(codec, bs, node);
if (e) return e;
if (codec->coord_stored && reset_qp14)
gf_bifs_enc_qp14_reset(codec);
switch (node_tag) {
case TAG_MPEG4_Coordinate:
case TAG_MPEG4_Coordinate2D:
gf_bifs_enc_qp14_enter(codec, GF_FALSE);
break;
}
return GF_OK;
}
static void svg2bifs_node_start(void *sax_cbck, const char *name, const char *name_space, const GF_XMLAttribute *attributes, u32 nb_attributes)
{
u32 i;
SVG2BIFS_Converter *converter = (SVG2BIFS_Converter *)sax_cbck;
SVGPropertiesPointers *backup_props;
char *id_string = NULL;
u32 tag;
SVG_Element *elt;
SVG_DeferedAnimation *anim = NULL;
tag = gf_xml_get_element_tag(name, 0);
elt = (SVG_Element*)gf_node_new(converter->svg_sg, tag);
if (!gf_sg_get_root_node(converter->svg_sg)) {
gf_node_register((GF_Node *)elt, NULL);
gf_sg_set_root_node(converter->svg_sg, (GF_Node *)elt);
} else {
gf_node_register((GF_Node *)elt, converter->svg_parent);
//gf_node_list_add_child(&((GF_ParentNode*)converter->svg_parent)->children, (GF_Node *)elt);
}
// fprintf(stdout, "Converting %s\n", gf_node_get_class_name((GF_Node *)elt));
// if (converter->bifs_parent) fprintf(stdout, "%s\n", gf_node_get_class_name(converter->bifs_parent));
if (gf_svg_is_animation_tag(tag)) {
GF_SAFEALLOC(anim, SVG_DeferedAnimation);
/*default anim target is parent node*/
anim->animation_elt = elt;
if (converter->svg_parent) {
anim->target = anim->anim_parent = (SVG_Element*) converter->svg_parent;
}
}
for (i=0; i<nb_attributes; i++) {
GF_XMLAttribute *att = (GF_XMLAttribute *)&attributes[i];
if (!att->value || !strlen(att->value)) continue;
if (!stricmp(att->name, "style")) {
gf_svg_parse_style((GF_Node *)elt, att->value);
} else if (!stricmp(att->name, "id") || !stricmp(att->name, "xml:id")) {
gf_svg_parse_element_id((GF_Node *)elt, att->value, 0);
id_string = att->value;
} else if (anim && !stricmp(att->name, "to")) {
anim->to = gf_strdup(att->value);
} else if (anim && !stricmp(att->name, "from")) {
anim->from = gf_strdup(att->value);
} else if (anim && !stricmp(att->name, "by")) {
anim->by = gf_strdup(att->value);
} else if (anim && !stricmp(att->name, "values")) {
anim->values = gf_strdup(att->value);
} else if (anim && (tag == TAG_SVG_animateTransform) && !stricmp(att->name, "type")) {
anim->type = gf_strdup(att->value);
} else {
GF_FieldInfo info;
if (gf_node_get_field_by_name((GF_Node *)elt, att->name, &info)==GF_OK) {
gf_svg_parse_attribute((GF_Node *)elt, &info, att->value, 0);
} else {
fprintf(stdout, "Skipping attribute %s\n", att->name);
}
}
}
if (anim) {
svg_parse_animation(converter->svg_sg, anim);
}
memset(&converter->all_atts, 0, sizeof(SVGAllAttributes));
gf_svg_flatten_attributes(elt, &converter->all_atts);
backup_props = gf_malloc(sizeof(SVGPropertiesPointers));
memcpy(backup_props, &converter->svg_props, sizeof(SVGPropertiesPointers));
gf_node_set_private((GF_Node *)elt, backup_props);
gf_svg_apply_inheritance(&converter->all_atts, &converter->svg_props);
fprintf(stdout, "START\t%s\t%s\t%s", converter->svg_parent ? gf_node_get_class_name(converter->svg_parent) : "none", converter->bifs_parent ? gf_node_get_class_name(converter->bifs_parent) : "none", name);
converter->svg_parent = (GF_Node *)elt;
if (!gf_sg_get_root_node(converter->bifs_sg)) {
if (tag == TAG_SVG_svg) {
GF_Node *node, *child;
converter->bifs_sg->usePixelMetrics = 1;
if (converter->all_atts.width && converter->all_atts.width->type == SVG_NUMBER_VALUE) {
converter->bifs_sg->width = FIX2INT(converter->all_atts.width->value);
} else {
converter->bifs_sg->width = 320;
}
if (converter->all_atts.height && converter->all_atts.height->type == SVG_NUMBER_VALUE) {
converter->bifs_sg->height = FIX2INT(converter->all_atts.height->value);
} else {
converter->bifs_sg->height = 200;
}
node = gf_node_new(converter->bifs_sg, TAG_MPEG4_OrderedGroup);
gf_node_register(node, NULL);
gf_sg_set_root_node(converter->bifs_sg, node);
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_QuantizationParameter);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_QuantizationParameter *qp = (M_QuantizationParameter *)child;
qp->useEfficientCoding = 1;
}
/* SVG to BIFS coordinate transformation */
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Viewport);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Viewport *vp = (M_Viewport*)child;
if (converter->all_atts.viewBox) {
vp->size.x = converter->all_atts.viewBox->width;
vp->size.y = converter->all_atts.viewBox->height;
vp->position.x = converter->all_atts.viewBox->x+converter->all_atts.viewBox->width/2;
vp->position.y = -(converter->all_atts.viewBox->y+converter->all_atts.viewBox->height/2);
} else {
vp->size.x = INT2FIX(converter->bifs_sg->width);
vp->size.y = INT2FIX(converter->bifs_sg->height);
vp->position.x = INT2FIX(converter->bifs_sg->width)/2;
vp->position.y = -INT2FIX(converter->bifs_sg->height)/2;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Background2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Background2D *b = (M_Background2D *)child;
b->backColor.red = FIX_ONE;
b->backColor.green = FIX_ONE;
b->backColor.blue = FIX_ONE;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
{
M_Transform2D *tr = (M_Transform2D *)node;
tr->scale.y = -FIX_ONE;
}
converter->bifs_parent = node;
}
} else {
GF_Node *node, *child;
node = converter->bifs_parent;
switch(tag) {
case TAG_SVG_g:
{
if (converter->all_atts.transform) {
node = add_transform_matrix(converter, node);
converter->bifs_parent = node;
} else {
M_Group *g = (M_Group*)gf_node_new(converter->bifs_sg, TAG_MPEG4_Group);
gf_node_register((GF_Node *)g, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, (GF_Node *)g);
node = (GF_Node *)g;
converter->bifs_parent = node;
}
}
break;
case TAG_SVG_rect:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform_matrix(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->force_transform) {
node = add_transform2d(converter, node);
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
if (converter->all_atts.x || converter->all_atts.y) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
{
M_Transform2D *tr = (M_Transform2D *)node;
if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value + (converter->all_atts.width?converter->all_atts.width->value/2:0);
if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value + (converter->all_atts.height?converter->all_atts.height->value/2:0);
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_Rectangle);
gf_node_register(shape->geometry, (GF_Node *)shape);
{
M_Rectangle *rect = (M_Rectangle *)shape->geometry;
if (converter->all_atts.width) rect->size.x = converter->all_atts.width->value;
if (converter->all_atts.height) rect->size.y = converter->all_atts.height->value;
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_path:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform_matrix(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->force_transform) {
node = add_transform2d(converter, node);
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
if (converter->all_atts.x || converter->all_atts.y) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
{
M_Transform2D *tr = (M_Transform2D *)node;
if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value;
if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_XCurve2D);
gf_node_register(shape->geometry, (GF_Node *)shape);
if (converter->all_atts.d) {
M_Coordinate2D *c2d;
M_XCurve2D *xc = (M_XCurve2D *)shape->geometry;
u32 i, j, c, k;
xc->point = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D);
c2d = (M_Coordinate2D *)xc->point;
gf_node_register(xc->point, (GF_Node *)xc);
gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, converter->all_atts.d->n_points);
gf_sg_vrml_mf_alloc(&xc->type, GF_SG_VRML_MFINT32, converter->all_atts.d->n_points);
c = 0;
k = 0;
j = 0;
c2d->point.vals[k] = converter->all_atts.d->points[0];
k++;
xc->type.vals[0] = 0;
for (i = 1; i < converter->all_atts.d->n_points; ) {
switch(converter->all_atts.d->tags[i]) {
case GF_PATH_CURVE_ON:
c2d->point.vals[k] = converter->all_atts.d->points[i];
k++;
if (i-1 == converter->all_atts.d->contours[c]) {
xc->type.vals[j] = 0;
c++;
} else {
xc->type.vals[j] = 1;
}
i++;
break;
case GF_PATH_CURVE_CUBIC:
c2d->point.vals[k] = converter->all_atts.d->points[i];
c2d->point.vals[k+1] = converter->all_atts.d->points[i+1];
c2d->point.vals[k+2] = converter->all_atts.d->points[i+2];
k+=3;
xc->type.vals[j] = 2;
if (converter->all_atts.d->tags[i+2]==GF_PATH_CLOSE) {
j++;
xc->type.vals[j] = 6;
}
i+=3;
break;
case GF_PATH_CLOSE:
xc->type.vals[j] = 6;
i++;
break;
case GF_PATH_CURVE_CONIC:
c2d->point.vals[k] = converter->all_atts.d->points[i];
c2d->point.vals[k+1] = converter->all_atts.d->points[i+1];
k+=2;
xc->type.vals[j] = 7;
if (converter->all_atts.d->tags[i+1]==GF_PATH_CLOSE) {
j++;
xc->type.vals[j] = 6;
}
i+=2;
break;
}
j++;
}
xc->type.count = j;
c2d->point.count = k;
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_polyline:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform_matrix(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->force_transform) {
node = add_transform2d(converter, node);
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_IndexedFaceSet2D);
gf_node_register(shape->geometry, (GF_Node *)shape);
if (converter->all_atts.points) {
M_Coordinate2D *c2d;
M_IndexedFaceSet2D *ifs = (M_IndexedFaceSet2D *)shape->geometry;
u32 i;
ifs->coord = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D);
c2d = (M_Coordinate2D *)ifs->coord;
gf_node_register(ifs->coord, (GF_Node *)ifs);
gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, gf_list_count(*converter->all_atts.points));
for (i = 0; i < gf_list_count(*converter->all_atts.points); i++) {
SVG_Point *p = (SVG_Point *)gf_list_get(*converter->all_atts.points, i);
c2d->point.vals[i].x = p->x;
c2d->point.vals[i].y = p->y;
}
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_text:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform_matrix(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->force_transform) {
node = add_transform2d(converter, node);
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Transform2D *tr = (M_Transform2D *)child;
if (converter->all_atts.text_x) tr->translation.x = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_x, 0))->value;
if (converter->all_atts.text_y) tr->translation.y = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_y, 0))->value;
tr->scale.y = -FIX_ONE;
}
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_FontStyle *fs;
M_Text *text;
M_Shape *shape = (M_Shape *)node;
text = (M_Text *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Text);
shape->geometry = (GF_Node *)text;
converter->bifs_text_node = shape->geometry;
gf_node_register(shape->geometry, (GF_Node *)shape);
fs = (M_FontStyle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_XFontStyle);
gf_node_register((GF_Node *)fs, (GF_Node*)text);
text->fontStyle = (GF_Node *)fs;
gf_sg_vrml_mf_alloc(&fs->family, GF_SG_VRML_MFSTRING, 1);
fs->family.vals[0] = gf_strdup(converter->svg_props.font_family->value);
fs->size = converter->svg_props.font_size->value;
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_ellipse:
case TAG_SVG_circle:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform_matrix(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->force_transform) {
node = add_transform2d(converter, node);
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
if (converter->all_atts.cx || converter->all_atts.cy) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Transform2D *tr = (M_Transform2D *)child;
if (converter->all_atts.cx) tr->translation.x = converter->all_atts.cx->value;
if (converter->all_atts.cy) tr->translation.y = converter->all_atts.cy->value;
}
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
if (tag == TAG_SVG_ellipse) {
M_Ellipse *e = (M_Ellipse *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Ellipse);
shape->geometry = (GF_Node *)e;
e->radius.x = converter->all_atts.rx->value;
e->radius.y = converter->all_atts.ry->value;
} else {
M_Circle *c = (M_Circle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Circle);
shape->geometry = (GF_Node *)c;
c->radius = converter->all_atts.r->value;
}
gf_node_register(shape->geometry, (GF_Node *)shape);
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_defs:
{
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Switch);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
{
M_Switch *sw = (M_Switch *)node;
sw->whichChoice = -1;
}
converter->bifs_parent = node;
}
break;
case TAG_SVG_solidColor:
{
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
converter->bifs_parent = node;
}
break;
case TAG_SVG_animateTransform:
{
GF_Node *child_ts;
if (!gf_node_get_id(node)) {
gf_node_set_id(node, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);
}
child_ts = gf_node_new(converter->bifs_sg, TAG_MPEG4_TimeSensor);
if (!gf_node_get_id(child_ts)) {
gf_node_set_id(child_ts, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);
}
gf_node_register(child_ts, node);
gf_node_list_add_child(&((GF_ParentNode *)node)->children, child_ts);
{
M_TimeSensor *ts = (M_TimeSensor *)child_ts;
if (converter->all_atts.dur) {
ts->cycleInterval = converter->all_atts.dur->clock_value;
}
if (converter->all_atts.repeatCount && converter->all_atts.repeatCount->type == SMIL_REPEATCOUNT_INDEFINITE) {
ts->loop = 1;
}
}
if (converter->all_atts.transform_type) {
GF_FieldInfo fromField, toField;
switch (*converter->all_atts.transform_type) {
case SVG_TRANSFORM_ROTATE:
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_PositionInterpolator2D);
if (!gf_node_get_id(child)) {
gf_node_set_id(child, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);
}
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode *)node)->children, child);
gf_node_get_field_by_name(child_ts, "fraction_changed", &fromField);
gf_node_get_field_by_name(child, "set_fraction", &toField);
gf_sg_route_new(converter->bifs_sg, child_ts, fromField.fieldIndex, child, toField.fieldIndex);
gf_node_get_field_by_name(child, "value_changed", &fromField);
gf_node_get_field_by_name(node, "rotationAngle", &toField);
gf_sg_route_new(converter->bifs_sg, child, fromField.fieldIndex, node, toField.fieldIndex);
{
M_PositionInterpolator2D *pi2d = (M_PositionInterpolator2D *)child;
if (converter->all_atts.keyTimes) {
SFFloat *g;
u32 count, i;
count = gf_list_count(*converter->all_atts.keyTimes);
for (i = 0; i < count; i++) {
Fixed *f = gf_list_get(*converter->all_atts.keyTimes, i);
gf_sg_vrml_mf_append(&pi2d->key, GF_SG_VRML_MFFLOAT, &g);
*g = *f;
}
}
if (converter->all_atts.values) {
SFVec2f *g;
u32 count, i;
count = gf_list_count(converter->all_atts.values->values);
for (i = 0; i < count; i++) {
SVG_Point_Angle *p;
p = gf_list_get(converter->all_atts.values->values, i);
gf_sg_vrml_mf_append(&pi2d->keyValue, GF_SG_VRML_MFVEC2F, &g);
g->x = p->x;
g->y = p->y;
}
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_ScalarInterpolator);
if (!gf_node_get_id(child)) {
gf_node_set_id(child, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);
}
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode *)node)->children, child);
gf_node_get_field_by_name(child_ts, "fraction_changed", &fromField);
gf_node_get_field_by_name(child, "set_fraction", &toField);
gf_sg_route_new(converter->bifs_sg, child_ts, fromField.fieldIndex, child, toField.fieldIndex);
gf_node_get_field_by_name(child, "value_changed", &fromField);
gf_node_get_field_by_name(node, "center", &toField);
gf_sg_route_new(converter->bifs_sg, child, fromField.fieldIndex, node, toField.fieldIndex);
{
M_ScalarInterpolator *si = (M_ScalarInterpolator *)child;
if (converter->all_atts.keyTimes) {
SFFloat *g;
u32 count, i;
count = gf_list_count(*converter->all_atts.keyTimes);
for (i = 0; i < count; i++) {
Fixed *f = gf_list_get(*converter->all_atts.keyTimes, i);
gf_sg_vrml_mf_append(&si->key, GF_SG_VRML_MFFLOAT, &g);
*g = *f;
}
}
if (converter->all_atts.values) {
SFFloat *g;
u32 count, i;
count = gf_list_count(converter->all_atts.values->values);
for (i = 0; i < count; i++) {
SVG_Point_Angle *p;
p = gf_list_get(converter->all_atts.values->values, i);
gf_sg_vrml_mf_append(&si->keyValue, GF_SG_VRML_MFFLOAT, &g);
*g = p->angle;
}
}
}
break;
case SVG_TRANSFORM_SCALE:
case SVG_TRANSFORM_TRANSLATE:
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_PositionInterpolator2D);
if (!gf_node_get_id(child)) {
gf_node_set_id(child, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);
}
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode *)node)->children, child);
gf_node_get_field_by_name(child_ts, "fraction_changed", &fromField);
gf_node_get_field_by_name(child, "set_fraction", &toField);
gf_sg_route_new(converter->bifs_sg, child_ts, fromField.fieldIndex, child, toField.fieldIndex);
gf_node_get_field_by_name(child, "value_changed", &fromField);
if (*converter->all_atts.transform_type == SVG_TRANSFORM_SCALE)
gf_node_get_field_by_name(node, "scale", &toField);
else
gf_node_get_field_by_name(node, "translation", &toField);
gf_sg_route_new(converter->bifs_sg, child, fromField.fieldIndex, node, toField.fieldIndex);
{
M_PositionInterpolator2D *pi2d = (M_PositionInterpolator2D *)child;
if (converter->all_atts.keyTimes) {
SFFloat *g;
u32 count, i;
count = gf_list_count(*converter->all_atts.keyTimes);
for (i = 0; i < count; i++) {
Fixed *f = gf_list_get(*converter->all_atts.keyTimes, i);
gf_sg_vrml_mf_append(&pi2d->key, GF_SG_VRML_MFFLOAT, &g);
*g = *f;
}
}
if (converter->all_atts.values) {
SFVec2f *g;
u32 count, i;
count = gf_list_count(converter->all_atts.values->values);
for (i = 0; i < count; i++) {
SVG_Point *p;
p = gf_list_get(converter->all_atts.values->values, i);
gf_sg_vrml_mf_append(&pi2d->keyValue, GF_SG_VRML_MFVEC2F, &g);
g->x = p->x;
g->y = p->y;
}
}
}
break;
default:
fprintf(stdout, "Warning: transformation type not supported \n");
}
}
//converter->bifs_parent = node;
}
break;
default:
{
fprintf(stdout, "Warning: element %s not supported \n", gf_node_get_class_name((GF_Node *)elt));
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
//gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
converter->bifs_parent = node;
}
break;
}
if (id_string)
gf_node_set_id(converter->bifs_parent, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);//gf_node_get_name((GF_Node *)elt));
}
fprintf(stdout, "\t%s\n", converter->bifs_parent ? gf_node_get_class_name(converter->bifs_parent) : "none");
}
static GF_Err BE_XReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i,nbBits;
GF_FieldInfo field;
GF_Err e;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_BAD_PARAM;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", NULL);
gf_node_get_field(com->node, inf->fieldIndex, &field);
if (!gf_sg_vrml_is_sf_field(field.fieldType)) {
if ((inf->pos != -2) || com->toNodeID) {
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "indexedReplacement", NULL);
if (com->toNodeID) {
GF_Node *n = gf_bifs_enc_find_node(codec, com->toNodeID);
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "dynamicIndex", NULL);
GF_BIFS_WRITE_INT(codec, bs, com->toNodeID-1, codec->info->config.NodeIDBits, "idxNodeID", NULL);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(n, GF_SG_FIELD_CODING_DEF)-1);
gf_bifs_field_index_by_mode(n, com->toFieldIndex, GF_SG_FIELD_CODING_DEF, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "idxField", NULL);
} else {
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "dynamicIndex", NULL);
if (inf->pos==-1) {
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "replacementPosition", NULL);
} else if (inf->pos==0) {
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "replacementPosition", NULL);
} else {
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "replacementPosition", NULL);
GF_BIFS_WRITE_INT(codec, bs, inf->pos, 16, "position", NULL);
}
}
} else {
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "indexedReplacement", NULL);
}
}
if (field.fieldType==GF_SG_VRML_MFNODE) {
if (com->ChildNodeTag) {
GF_Node *n;
if (com->ChildNodeTag>0) {
n = gf_node_new(codec->scene_graph, com->ChildNodeTag);
} else {
GF_Proto *proto = gf_sg_find_proto(codec->scene_graph, -com->ChildNodeTag , NULL);
if (!proto) return GF_SG_UNKNOWN_NODE;
n = gf_sg_proto_create_instance(codec->scene_graph, proto);
}
if (!n) return GF_SG_UNKNOWN_NODE;
gf_node_register(n, NULL);
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "childField", NULL);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(n, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(n, com->child_field, GF_SG_FIELD_CODING_IN, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "childField", NULL);
gf_node_unregister(n, NULL);
} else {
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "childField", NULL);
}
}
if (com->fromNodeID) {
GF_Node *n = gf_bifs_enc_find_node(codec, com->fromNodeID);
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "valueFromNode", NULL);
GF_BIFS_WRITE_INT(codec, bs, com->fromNodeID-1, codec->info->config.NodeIDBits, "sourceNodeID", NULL);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(n, GF_SG_FIELD_CODING_DEF)-1);
gf_bifs_field_index_by_mode(n, com->fromFieldIndex, GF_SG_FIELD_CODING_DEF, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "sourceField", NULL);
return GF_OK;
}
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "valueFromNode", NULL);
field.far_ptr = inf->field_ptr;
field.fieldType = inf->fieldType;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
return e;
}
GF_Err gf_bifs_enc_commands(GF_BifsEncoder *codec, GF_List *comList, GF_BitStream *bs)
{
u32 i;
u32 count;
GF_List *routes;
GF_Err e = GF_OK;
routes = NULL;
codec->LastError = GF_OK;
count = gf_list_count(comList);
for (i=0; i<count; i++) {
GF_Command *com = (GF_Command*)gf_list_get(comList, i);
switch (com->tag) {
case GF_SG_SCENE_REPLACE:
{
/*reset node context*/
while (gf_list_count(codec->encoded_nodes)) gf_list_rem(codec->encoded_nodes, 0);
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "SceneReplace", NULL);
if (!com->aggregated) {
routes = gf_list_new();
/*now the trick: get all following InsertRoutes and convert as routes*/
for (; i<count-1; i++) {
GF_Route *r;
GF_Command *rcom = (GF_Command*)gf_list_get(comList, i+1);
if (rcom->tag!=GF_SG_ROUTE_INSERT) break;
GF_SAFEALLOC(r, GF_Route);
r->FromField.fieldIndex = rcom->fromFieldIndex;
r->FromNode = gf_sg_find_node(codec->scene_graph, rcom->fromNodeID);
r->ToField.fieldIndex = rcom->toFieldIndex;
r->ToNode = gf_sg_find_node(codec->scene_graph, rcom->toNodeID);
r->ID = rcom->RouteID;
r->name = rcom->def_name;
gf_list_add(routes, r);
}
e = BE_SceneReplaceEx(codec, com, bs, routes);
while (gf_list_count(routes)) {
GF_Route *r = (GF_Route*)gf_list_get(routes, 0);
gf_list_rem(routes, 0);
gf_free(r);
}
gf_list_del(routes);
} else {
e = BE_SceneReplaceEx(codec, com, bs, codec->scene_graph->Routes);
}
}
break;
/*replace commands*/
case GF_SG_NODE_REPLACE:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "Replace", NULL);
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Node", NULL);
e = BE_NodeReplace(codec, com, bs);
break;
case GF_SG_FIELD_REPLACE:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "Replace", NULL);
GF_BIFS_WRITE_INT(codec, bs, 1, 2, "Field", NULL);
e = BE_FieldReplace(codec, com, bs);
break;
case GF_SG_INDEXED_REPLACE:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "Replace", NULL);
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FieldIndex", NULL);
e = BE_IndexFieldReplace(codec, com, bs);
break;
case GF_SG_ROUTE_REPLACE:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "Replace", NULL);
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "Route", NULL);
e = BE_RouteReplace(codec, com, bs, 0);
break;
case GF_SG_NODE_INSERT:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Insert", NULL);
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Node", NULL);
e = BE_NodeInsert(codec, com, bs);
break;
case GF_SG_INDEXED_INSERT:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Insert", NULL);
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FieldIndex", NULL);
e = BE_IndexInsert(codec, com, bs);
break;
case GF_SG_ROUTE_INSERT:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Insert", NULL);
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "Route", NULL);
e = BE_RouteReplace(codec, com, bs, 1);
break;
case GF_SG_NODE_DELETE:
GF_BIFS_WRITE_INT(codec, bs, 1, 2, "Delete", NULL);
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "Node", NULL);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
break;
case GF_SG_INDEXED_DELETE:
GF_BIFS_WRITE_INT(codec, bs, 1, 2, "Delete", NULL);
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FieldIndex", NULL);
e = BE_IndexDelete(codec, com, bs);
break;
case GF_SG_ROUTE_DELETE:
GF_BIFS_WRITE_INT(codec, bs, 1, 2, "Delete", NULL);
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "Route", NULL);
GF_BIFS_WRITE_INT(codec, bs, com->RouteID - 1, codec->info->config.RouteIDBits, "RouteID", NULL);
break;
default:
e = BE_ExtendedUpdate(codec, com, bs);
break;
}
if (e) break;
GF_BIFS_WRITE_INT(codec, bs, (i+1==count) ? 0 : 1, 1, "moreCommands", NULL);
}
while (gf_list_count(codec->QPs)) gf_bifs_enc_qp_remove(codec, 1);
return e;
}
static u32 store_or_aggregate(GF_StreamContext *sc, GF_Command *com, GF_List *commands, Bool *has_modif)
{
#ifndef GPAC_DISABLE_VRML
u32 i, count, j, nb_fields;
GF_CommandField *field, *check_field;
/*if our command deals with a node inserted in the commands list, apply command list*/
if (node_in_commands_subtree(com->node, commands)) return 0;
/*otherwise, check if we can substitute a previous command with this one*/
count = gf_list_count(commands);
for (i=0; i<count; i++) {
GF_Command *check = gf_list_get(commands, i);
if (sc->streamType == GF_STREAM_SCENE) {
Bool check_index=0;
Bool original_is_index = 0;
Bool apply;
switch (com->tag) {
case GF_SG_INDEXED_REPLACE:
check_index=1;
case GF_SG_MULTIPLE_INDEXED_REPLACE:
case GF_SG_FIELD_REPLACE:
case GF_SG_MULTIPLE_REPLACE:
if (check->node != com->node) break;
/*we may aggregate an indexed insertion and a replace one*/
if (check_index) {
if (check->tag == GF_SG_INDEXED_REPLACE) {}
else if (check->tag == GF_SG_INDEXED_INSERT) {
original_is_index = 1;
}
else {
break;
}
} else {
if (check->tag != com->tag) break;
}
nb_fields = gf_list_count(com->command_fields);
if (gf_list_count(check->command_fields) != nb_fields) break;
apply=1;
for (j=0; j<nb_fields; j++) {
field = gf_list_get(com->command_fields, j);
check_field = gf_list_get(check->command_fields, j);
if ((field->pos != check_field->pos) || (field->fieldIndex != check_field->fieldIndex)) {
apply=0;
break;
}
}
/*same target node+fields, destroy first command and store new one*/
if (apply) {
/*if indexed, change command tag*/
if (original_is_index) com->tag = GF_SG_INDEXED_INSERT;
gf_sg_command_del((GF_Command *)check);
gf_list_rem(commands, i);
if (has_modif) *has_modif = 1;
return 1;
}
break;
case GF_SG_NODE_REPLACE:
if (check->tag != GF_SG_NODE_REPLACE) {
break;
}
/*TODO - THIS IS NOT SUPPORTED IN GPAC SINCE WE NEVER ALLOW FOR DUPLICATE NODE IDs IN THE SCENE !!!*/
if (gf_node_get_id(check->node) != gf_node_get_id(com->node) ) {
break;
}
/*same node ID, destroy first command and store new one*/
gf_sg_command_del((GF_Command *)check);
gf_list_rem(commands, i);
if (has_modif) *has_modif = 1;
return 1;
case GF_SG_INDEXED_DELETE:
/*look for an indexed insert before the indexed delete with same target pos and node. If found, discard both commands!*/
if (check->tag != GF_SG_INDEXED_INSERT) break;
if (com->node != check->node) break;
field = gf_list_get(com->command_fields, 0);
check_field = gf_list_get(check->command_fields, 0);
if (!field || !check_field) break;
if (field->pos != check_field->pos) break;
if (field->fieldIndex != check_field->fieldIndex) break;
gf_sg_command_del((GF_Command *)check);
gf_list_rem(commands, i);
if (has_modif) *has_modif = 1;
return 2;
default:
GF_LOG(GF_LOG_ERROR, GF_LOG_SCENE, ("[Scene Manager] Stream Aggregation not implemented for command - aggregating on main scene\n"));
break;
}
}
}
/*the command modifies another stream than associated current carousel stream, we have to store it.*/
if (has_modif) *has_modif=1;
#endif
return 1;
}
static void svg2bifs_node_start(void *sax_cbck, const char *name, const char *name_space, const GF_XMLAttribute *attributes, u32 nb_attributes)
{
u32 i;
SVG_SANI_BIFS_Converter *converter = (SVG_SANI_BIFS_Converter *)sax_cbck;
SVGPropertiesPointers *backup_props;
char *id_string = NULL;
u32 tag = gf_svg_get_element_tag(name);
SVG_Element *elt = (SVG_Element*)gf_node_new(converter->svg_sg, tag);
if (!gf_sg_get_root_node(converter->svg_sg)) {
gf_node_register((GF_Node *)elt, NULL);
gf_sg_set_root_node(converter->svg_sg, (GF_Node *)elt);
} else {
gf_node_register((GF_Node *)elt, converter->svg_parent);
//gf_node_list_add_child(&((GF_ParentNode*)converter->svg_parent)->children, (GF_Node *)elt);
}
converter->svg_parent = (GF_Node *)elt;
// fprintf(stdout, "Converting %s\n", gf_node_get_class_name((GF_Node *)elt));
// if (converter->bifs_parent) fprintf(stdout, "%s\n", gf_node_get_class_name(converter->bifs_parent));
for (i=0; i<nb_attributes; i++) {
GF_XMLAttribute *att = (GF_XMLAttribute *)&attributes[i];
if (!att->value || !strlen(att->value)) continue;
if (!stricmp(att->name, "style")) {
gf_svg_parse_style((GF_Node *)elt, att->value);
} else if (!stricmp(att->name, "id") || !stricmp(att->name, "xml:id")) {
gf_svg_parse_element_id((GF_Node *)elt, att->value, 0);
id_string = att->value;
} else {
GF_FieldInfo info;
if (gf_node_get_field_by_name((GF_Node *)elt, att->name, &info)==GF_OK) {
gf_svg_parse_attribute((GF_Node *)elt, &info, att->value, 0);
} else {
fprintf(stdout, "Skipping attribute %s\n", att->name);
}
}
}
memset(&converter->all_atts, 0, sizeof(SVGAllAttributes));
gf_svg_flatten_attributes(elt, &converter->all_atts);
backup_props = gf_malloc(sizeof(SVGPropertiesPointers));
memcpy(backup_props, &converter->svg_props, sizeof(SVGPropertiesPointers));
gf_node_set_private((GF_Node *)elt, backup_props);
gf_svg_apply_inheritance(&converter->all_atts, &converter->svg_props);
if (!gf_sg_get_root_node(converter->bifs_sg)) {
if (tag == TAG_SVG_svg) {
GF_Node *node, *child;
converter->bifs_sg->usePixelMetrics = 1;
if (converter->all_atts.width && converter->all_atts.width->type == SVG_NUMBER_VALUE) {
converter->bifs_sg->width = FIX2INT(converter->all_atts.width->value);
} else {
converter->bifs_sg->width = 320;
}
if (converter->all_atts.height && converter->all_atts.height->type == SVG_NUMBER_VALUE) {
converter->bifs_sg->height = FIX2INT(converter->all_atts.height->value);
} else {
converter->bifs_sg->height = 200;
}
node = gf_node_new(converter->bifs_sg, TAG_MPEG4_OrderedGroup);
gf_node_register(node, NULL);
gf_sg_set_root_node(converter->bifs_sg, node);
/* SVG to BIFS coordinate transformation */
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Viewport);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
if (converter->all_atts.viewBox) {
M_Viewport *vp = (M_Viewport*)child;
vp->size.x = converter->all_atts.viewBox->width;
vp->size.y = converter->all_atts.viewBox->height;
vp->position.x = converter->all_atts.viewBox->x+converter->all_atts.viewBox->width/2;
vp->position.y = -(converter->all_atts.viewBox->y+converter->all_atts.viewBox->height/2);
} else {
M_Viewport *vp = (M_Viewport*)child;
vp->size.x = INT2FIX(converter->bifs_sg->width);
vp->size.y = INT2FIX(converter->bifs_sg->height);
vp->position.x = INT2FIX(converter->bifs_sg->width)/2;
vp->position.y = -INT2FIX(converter->bifs_sg->height)/2;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Background2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Background2D *b = (M_Background2D *)child;
b->backColor.red = FIX_ONE;
b->backColor.green = FIX_ONE;
b->backColor.blue = FIX_ONE;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
{
M_Transform2D *tr = (M_Transform2D *)node;
tr->scale.y = -FIX_ONE;
}
converter->bifs_parent = node;
}
} else {
GF_Node *node, *child;
node = converter->bifs_parent;
switch(tag) {
case TAG_SVG_g:
{
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
} else {
M_Group *g = (M_Group*)gf_node_new(converter->bifs_sg, TAG_MPEG4_Group);
gf_node_register((GF_Node *)g, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, (GF_Node *)g);
node = (GF_Node *)g;
converter->bifs_parent = node;
}
}
break;
case TAG_SVG_rect:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->all_atts.x || converter->all_atts.y) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
{
M_Transform2D *tr = (M_Transform2D *)node;
if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value + (converter->all_atts.width?converter->all_atts.width->value/2:0);
if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value + (converter->all_atts.height?converter->all_atts.height->value/2:0);
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_Rectangle);
gf_node_register(shape->geometry, (GF_Node *)shape);
{
M_Rectangle *rect = (M_Rectangle *)shape->geometry;
if (converter->all_atts.width) rect->size.x = converter->all_atts.width->value;
if (converter->all_atts.height) rect->size.y = converter->all_atts.height->value;
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_path:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->all_atts.x || converter->all_atts.y) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
{
M_Transform2D *tr = (M_Transform2D *)node;
if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value;
if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_XCurve2D);
gf_node_register(shape->geometry, (GF_Node *)shape);
if (converter->all_atts.d) {
M_Coordinate2D *c2d;
M_XCurve2D *xc = (M_XCurve2D *)shape->geometry;
u32 i, j, c;
xc->point = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D);
c2d = (M_Coordinate2D *)xc->point;
gf_node_register(xc->point, (GF_Node *)xc);
gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, converter->all_atts.d->n_points);
j= 0;
for (i = 0; i < converter->all_atts.d->n_points; i++) {
if (converter->all_atts.d->tags[i] != GF_PATH_CLOSE || i == converter->all_atts.d->n_points-1) {
c2d->point.vals[j] = converter->all_atts.d->points[i];
j++;
}
}
c2d->point.count = j;
gf_sg_vrml_mf_alloc(&xc->type, GF_SG_VRML_MFINT32, converter->all_atts.d->n_points);
c = 0;
j = 0;
xc->type.vals[0] = 0;
for (i = 1; i < converter->all_atts.d->n_points; i++) {
switch(converter->all_atts.d->tags[i]) {
case GF_PATH_CURVE_ON:
if (c < converter->all_atts.d->n_contours &&
i-1 == converter->all_atts.d->contours[c]) {
xc->type.vals[j] = 0;
c++;
} else {
xc->type.vals[j] = 1;
}
break;
case GF_PATH_CURVE_CUBIC:
xc->type.vals[j] = 2;
i+=2;
break;
case GF_PATH_CLOSE:
xc->type.vals[j] = 6;
break;
case GF_PATH_CURVE_CONIC:
xc->type.vals[j] = 7;
i++;
break;
}
j++;
}
xc->type.count = j;
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_polyline:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_IndexedFaceSet2D);
gf_node_register(shape->geometry, (GF_Node *)shape);
if (converter->all_atts.points) {
M_Coordinate2D *c2d;
M_IndexedFaceSet2D *ifs = (M_IndexedFaceSet2D *)shape->geometry;
u32 i;
ifs->coord = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D);
c2d = (M_Coordinate2D *)ifs->coord;
gf_node_register(ifs->coord, (GF_Node *)ifs);
gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, gf_list_count(*converter->all_atts.points));
for (i = 0; i < gf_list_count(*converter->all_atts.points); i++) {
SVG_Point *p = (SVG_Point *)gf_list_get(*converter->all_atts.points, i);
c2d->point.vals[i].x = p->x;
c2d->point.vals[i].y = p->y;
}
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_text:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Transform2D *tr = (M_Transform2D *)child;
if (converter->all_atts.text_x) tr->translation.x = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_x, 0))->value;
if (converter->all_atts.text_y) tr->translation.y = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_y, 0))->value;
tr->scale.y = -FIX_ONE;
}
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_FontStyle *fs;
M_Text *text;
M_Shape *shape = (M_Shape *)node;
text = (M_Text *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Text);
shape->geometry = (GF_Node *)text;
converter->bifs_text_node = shape->geometry;
gf_node_register(shape->geometry, (GF_Node *)shape);
fs = (M_FontStyle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_XFontStyle);
gf_node_register((GF_Node *)fs, (GF_Node*)text);
text->fontStyle = (GF_Node *)fs;
gf_sg_vrml_mf_alloc(&fs->family, GF_SG_VRML_MFSTRING, 1);
fs->family.vals[0] = strdup(converter->svg_props.font_family->value);
fs->size = converter->svg_props.font_size->value;
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_ellipse:
case TAG_SVG_circle:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->all_atts.cx || converter->all_atts.cy) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Transform2D *tr = (M_Transform2D *)child;
if (converter->all_atts.cx) tr->translation.x = converter->all_atts.cx->value;
if (converter->all_atts.cy) tr->translation.y = converter->all_atts.cy->value;
}
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
if (tag == TAG_SVG_ellipse) {
M_Ellipse *e = (M_Ellipse *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Ellipse);
shape->geometry = (GF_Node *)e;
e->radius.x = converter->all_atts.rx->value;
e->radius.y = converter->all_atts.ry->value;
} else {
M_Circle *c = (M_Circle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Circle);
shape->geometry = (GF_Node *)c;
c->radius = converter->all_atts.r->value;
}
gf_node_register(shape->geometry, (GF_Node *)shape);
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_defs:
{
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Switch);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
{
M_Switch *sw = (M_Switch *)node;
sw->whichChoice = -1;
}
converter->bifs_parent = node;
}
break;
case TAG_SVG_solidColor:
{
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
converter->bifs_parent = node;
}
break;
default:
{
fprintf(stdout, "Warning: element %s not supported \n", gf_node_get_class_name((GF_Node *)elt));
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
converter->bifs_parent = node;
}
break;
}
if (id_string)
gf_node_set_id(converter->bifs_parent, gf_node_get_id((GF_Node *)elt), gf_node_get_name((GF_Node *)elt));
}
}
