GF_EXPORT
GF_Err gf_sg_command_apply(GF_SceneGraph *graph, GF_Command *com, Double time_offset)
{
GF_Err e;
GF_CommandField *inf;
GF_FieldInfo field;
GF_Node *def, *node;
void *slot_ptr;
if (!com || !graph) return GF_BAD_PARAM;
e = GF_OK;
switch (com->tag) {
case GF_SG_SCENE_REPLACE:
/*unregister root*/
gf_node_unregister(graph->RootNode, NULL);
/*remove all protos and routes*/
while (gf_list_count(graph->routes_to_activate))
gf_list_rem(graph->routes_to_activate, 0);
/*destroy all routes*/
while (gf_list_count(graph->Routes)) {
GF_Route *r = (GF_Route *)gf_list_get(graph->Routes, 0);
/*this will unregister the route from the graph, so don't delete the chain entry*/
gf_sg_route_del(r);
}
/*destroy all proto*/
while (gf_list_count(graph->protos)) {
GF_Proto *p = (GF_Proto*)gf_list_get(graph->protos, 0);
/*this will unregister the proto from the graph, so don't delete the chain entry*/
gf_sg_proto_del(p);
}
/*DO NOT TOUCH node registry*/
/*DO NOT TOUCH UNREGISTERED PROTOS*/
/*move all protos in graph*/
while (gf_list_count(com->new_proto_list)) {
GF_Proto *p = (GF_Proto*)gf_list_get(com->new_proto_list, 0);
gf_list_rem(com->new_proto_list, 0);
gf_list_del_item(graph->unregistered_protos, p);
gf_list_add(graph->protos, p);
}
/*assign new root (no need to register/unregister)*/
graph->RootNode = com->node;
com->node = NULL;
break;
case GF_SG_NODE_REPLACE:
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_replace(com->node, inf->new_node, 0);
if (inf->new_node) gf_node_register(inf->new_node, NULL);
break;
case GF_SG_MULTIPLE_REPLACE:
case GF_SG_FIELD_REPLACE:
{
u32 j;
GF_ChildNodeItem *list, *cur, *prev;
j=0;
while ((inf = (GF_CommandField*)gf_list_enum(com->command_fields, &j))) {
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
{
node = *((GF_Node **) field.far_ptr);
e = gf_node_unregister(node, com->node);
*((GF_Node **) field.far_ptr) = inf->new_node;
if (!e) gf_node_register(inf->new_node, com->node);
break;
}
case GF_SG_VRML_MFNODE:
gf_node_unregister_children(com->node, * ((GF_ChildNodeItem **) field.far_ptr));
* ((GF_ChildNodeItem **) field.far_ptr) = NULL;
list = * ((GF_ChildNodeItem **) inf->field_ptr);
prev=NULL;
while (list) {
cur = malloc(sizeof(GF_ChildNodeItem));
cur->next = NULL;
cur->node = list->node;
if (prev) {
prev->next = cur;
} else {
* ((GF_ChildNodeItem **) field.far_ptr) = cur;
}
gf_node_register(list->node, com->node);
prev = cur;
list = list->next;
}
break;
default:
/*this is a regular field, reset it and clone - we cannot switch pointers since the
original fields are NOT pointers*/
if (!gf_sg_vrml_is_sf_field(field.fieldType)) {
e = gf_sg_vrml_mf_reset(field.far_ptr, field.fieldType);
}
if (e) return e;
gf_sg_vrml_field_copy(field.far_ptr, inf->field_ptr, field.fieldType);
if (field.fieldType==GF_SG_VRML_SFTIME) *(SFTime *)field.far_ptr = *(SFTime *)field.far_ptr + time_offset;
break;
}
SG_CheckFieldChange(com->node, &field);
}
break;
}
case GF_SG_MULTIPLE_INDEXED_REPLACE:
case GF_SG_INDEXED_REPLACE:
{
u32 sftype, i=0;
while ((inf = (GF_CommandField*)gf_list_enum(com->command_fields, &i))) {
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
/*if MFNode remove the child and set new node*/
if (field.fieldType == GF_SG_VRML_MFNODE) {
/*we must remove the node before in case the new node uses the same ID (not forbidden) and this
command removes the last instance of the node with the same ID*/
gf_node_replace_child(com->node, (GF_ChildNodeItem**) field.far_ptr, inf->pos, inf->new_node);
if (inf->new_node) gf_node_register(inf->new_node, NULL);
}
/*erase the field item*/
else {
if ((inf->pos < 0) || ((u32) inf->pos >= ((GenMFField *) field.far_ptr)->count) ) {
inf->pos = ((GenMFField *)field.far_ptr)->count - 1;
/*may happen with text and default value*/
if (inf->pos < 0) {
inf->pos = 0;
gf_sg_vrml_mf_alloc(field.far_ptr, field.fieldType, 1);
}
}
e = gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, & slot_ptr, inf->pos);
if (e) return e;
sftype = gf_sg_vrml_get_sf_type(field.fieldType);
gf_sg_vrml_field_copy(slot_ptr, inf->field_ptr, sftype);
/*note we don't add time offset, since there's no MFTime*/
}
SG_CheckFieldChange(com->node, &field);
}
break;
}
case GF_SG_ROUTE_REPLACE:
{
GF_Route *r;
char *name;
r = gf_sg_route_find(graph, com->RouteID);
def = gf_sg_find_node(graph, com->fromNodeID);
node = gf_sg_find_node(graph, com->toNodeID);
if (!node || !def) return GF_SG_UNKNOWN_NODE;
name = NULL;
if (r) {
name = r->name;
r->name = NULL;
gf_sg_route_del(r);
}
r = gf_sg_route_new(graph, def, com->fromFieldIndex, node, com->toFieldIndex);
gf_sg_route_set_id(r, com->RouteID);
if (name) {
gf_sg_route_set_name(r, name);
free(name);
}
break;
}
case GF_SG_NODE_DELETE_EX:
case GF_SG_NODE_DELETE:
{
if (com->node) gf_node_replace(com->node, NULL, (com->tag==GF_SG_NODE_DELETE_EX) ? 1 : 0);
break;
}
case GF_SG_ROUTE_DELETE:
{
return gf_sg_route_del_by_id(graph, com->RouteID);
}
case GF_SG_INDEXED_DELETE:
{
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
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;
/*then we need special handling in case of a node*/
if (gf_sg_vrml_get_sf_type(field.fieldType) == GF_SG_VRML_SFNODE) {
e = gf_node_replace_child(com->node, (GF_ChildNodeItem **) field.far_ptr, inf->pos, NULL);
} else {
if ((inf->pos < 0) || ((u32) inf->pos >= ((GenMFField *) field.far_ptr)->count) ) {
inf->pos = ((GenMFField *)field.far_ptr)->count - 1;
}
/*this is a regular MFField, just remove the item (realloc)*/
e = gf_sg_vrml_mf_remove(field.far_ptr, field.fieldType, inf->pos);
}
/*deletion -> node has changed*/
if (!e) SG_CheckFieldChange(com->node, &field);
break;
}
case GF_SG_NODE_INSERT:
{
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_insert_child(com->node, inf->new_node, inf->pos);
if (!e) gf_node_register(inf->new_node, com->node);
if (!e) gf_node_event_out(com->node, inf->fieldIndex);
if (!e) gf_node_changed(com->node, NULL);
break;
}
case GF_SG_ROUTE_INSERT:
{
GF_Route *r;
def = gf_sg_find_node(graph, com->fromNodeID);
node = gf_sg_find_node(graph, com->toNodeID);
if (!node || !def) return GF_SG_UNKNOWN_NODE;
r = gf_sg_route_new(graph, def, com->fromFieldIndex, node, com->toFieldIndex);
if (com->RouteID) gf_sg_route_set_id(r, com->RouteID);
if (com->def_name) {
gf_sg_route_set_name(r, com->def_name);
free(com->def_name);
com->def_name = NULL;
}
break;
}
case GF_SG_INDEXED_INSERT:
{
u32 sftype;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
/*rescale the MFField and parse the SFField*/
if (field.fieldType != GF_SG_VRML_MFNODE) {
if (inf->pos == -1) {
e = gf_sg_vrml_mf_append(field.far_ptr, field.fieldType, & slot_ptr);
} else {
e = gf_sg_vrml_mf_insert(field.far_ptr, field.fieldType, & slot_ptr, inf->pos);
}
if (e) return e;
sftype = gf_sg_vrml_get_sf_type(field.fieldType);
gf_sg_vrml_field_copy(slot_ptr, inf->field_ptr, sftype);
} else {
if (inf->new_node) {
if (inf->pos == -1) {
gf_node_list_add_child( (GF_ChildNodeItem **) field.far_ptr, inf->new_node);
} else {
gf_node_list_insert_child((GF_ChildNodeItem **) field.far_ptr, inf->new_node, inf->pos);
}
gf_node_register(inf->new_node, com->node);
}
}
if (!e) SG_CheckFieldChange(com->node, &field);
break;
}
case GF_SG_PROTO_INSERT:
/*destroy all proto*/
while (gf_list_count(com->new_proto_list)) {
GF_Proto *p = (GF_Proto*)gf_list_get(com->new_proto_list, 0);
gf_list_rem(com->new_proto_list, 0);
gf_list_del_item(graph->unregistered_protos, p);
gf_list_add(graph->protos, p);
}
return GF_OK;
case GF_SG_PROTO_DELETE:
{
u32 i;
for (i=0; i<com->del_proto_list_size; i++) {
/*note this will check for unregistered protos, but since IDs are unique we are sure we will
not destroy an unregistered one*/
GF_Proto *proto = gf_sg_find_proto(graph, com->del_proto_list[i], NULL);
if (proto) gf_sg_proto_del(proto);
}
}
return GF_OK;
case GF_SG_PROTO_DELETE_ALL:
/*destroy all proto*/
while (gf_list_count(graph->protos)) {
GF_Proto *p = (GF_Proto*)gf_list_get(graph->protos, 0);
gf_list_rem(graph->protos, 0);
/*this will unregister the proto from the graph, so don't delete the chain entry*/
gf_sg_proto_del(p);
}
/*DO NOT TOUCH UNREGISTERED PROTOS*/
return GF_OK;
/*only used by BIFS*/
case GF_SG_GLOBAL_QUANTIZER:
return GF_OK;
#ifndef GPAC_DISABLE_SVG
/*laser commands*/
case GF_SG_LSR_NEW_SCENE:
/*DO NOT TOUCH node registry*/
/*assign new root (no need to register/unregister)*/
graph->RootNode = com->node;
com->node = NULL;
break;
case GF_SG_LSR_DELETE:
if (!com->node) return GF_NON_COMPLIANT_BITSTREAM;
if (!gf_list_count(com->command_fields)) {
gf_node_replace(com->node, NULL, 0);
gf_node_deactivate(com->node);
return GF_OK;
}
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
node = gf_node_list_get_child(((SVG_Element *)com->node)->children, inf->pos);
if (node) {
e = gf_node_replace_child(com->node, &((SVG_Element *)com->node)->children, inf->pos, NULL);
gf_node_deactivate(node);
}
break;
case GF_SG_LSR_INSERT:
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
if (!com->node || !inf) return GF_NON_COMPLIANT_BITSTREAM;
if (inf->new_node) {
if (inf->pos<0)
gf_node_list_add_child(& ((SVG_Element *)com->node)->children, inf->new_node);
else
gf_node_list_insert_child(& ((SVG_Element *)com->node)->children, inf->new_node, inf->pos);
gf_node_register(inf->new_node, com->node);
gf_node_activate(inf->new_node);
gf_node_changed(com->node, NULL);
} else {
/*NOT SUPPORTED*/
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[LASeR] VALUE INSERTION NOT SUPPORTED\n"));
}
break;
case GF_SG_LSR_ADD:
case GF_SG_LSR_REPLACE:
inf = (GF_CommandField*)gf_list_get(com->command_fields, 0);
if (!com->node || !inf) return GF_NON_COMPLIANT_BITSTREAM;
if (inf->new_node) {
if (inf->pos<0) {
/*if fieldIndex (eg attributeName) is set, this is children replacement*/
if (inf->fieldIndex>0) {
gf_node_unregister_children_deactivate(com->node, ((SVG_Element *)com->node)->children);
((SVG_Element *)com->node)->children = NULL;
gf_node_list_add_child(& ((SVG_Element *)com->node)->children, inf->new_node);
gf_node_register(inf->new_node, com->node);
gf_node_activate(inf->new_node);
} else {
e = gf_node_replace(com->node, inf->new_node, 0);
gf_node_activate(inf->new_node);
}
} else {
node = gf_node_list_get_child( ((SVG_Element *)com->node)->children, inf->pos);
gf_node_replace_child(com->node, & ((SVG_Element *)com->node)->children, inf->pos, inf->new_node);
gf_node_register(inf->new_node, com->node);
if (node) gf_node_deactivate(node);
gf_node_activate(inf->new_node);
}
/*signal node modif*/
gf_node_changed(com->node, NULL);
return e;
} else if (inf->node_list) {
GF_ChildNodeItem *child, *cur, *prev;
gf_node_unregister_children_deactivate(com->node, ((SVG_Element *)com->node)->children);
((SVG_Element *)com->node)->children = NULL;
prev = NULL;
child = inf->node_list;
while (child) {
cur = (GF_ChildNodeItem*)malloc(sizeof(GF_ChildNodeItem));
cur->next = NULL;
cur->node = child->node;
gf_node_register(child->node, com->node);
gf_node_activate(child->node);
if (prev) prev->next = cur;
else ((SVG_Element *)com->node)->children = cur;
prev = cur;
child = child->next;
}
/*signal node modif*/
gf_node_changed(com->node, NULL);
return GF_OK;
}
/*attribute modif*/
else if (inf->field_ptr) {
GF_FieldInfo a, b;
if (inf->fieldIndex==(u32) -2) {
GF_Point2D scale, translate;
Fixed rotate;
GF_Matrix2D *dest;
gf_node_get_field_by_name(com->node, "transform", &a);
dest = (GF_Matrix2D*)a.far_ptr;
if (com->tag==GF_SG_LSR_REPLACE) {
if (gf_mx2d_decompose(dest, &scale, &rotate, &translate)) {
gf_mx2d_init(*dest);
if (inf->fieldType==SVG_TRANSFORM_SCALE) scale = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldType==SVG_TRANSFORM_TRANSLATE) translate = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldType==SVG_TRANSFORM_ROTATE) rotate = ((SVG_Point_Angle*)inf->field_ptr)->angle;
gf_mx2d_add_scale(dest, scale.x, scale.y);
gf_mx2d_add_rotation(dest, 0, 0, rotate);
gf_mx2d_add_translation(dest, translate.x, translate.y);
}
} else {
GF_Point2D *pt = (GF_Point2D *)inf->field_ptr;
if (inf->fieldType==SVG_TRANSFORM_SCALE) gf_mx2d_add_scale(dest, pt->x, pt->y);
else if (inf->fieldType==SVG_TRANSFORM_TRANSLATE) gf_mx2d_add_translation(dest, pt->x, pt->y);
else if (inf->fieldType == SVG_TRANSFORM_ROTATE) gf_mx2d_add_rotation(dest, 0, 0, ((SVG_Point_Angle*)inf->field_ptr)->angle);
}
} else {
if ((inf->fieldIndex==(u32) -1) && (inf->fieldType==SVG_String_datatype)) {
char *str = *(SVG_String*)inf->field_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
GF_DOMText *t = ((SVG_Element*)com->node)->children ? (GF_DOMText*) ((SVG_Element*)com->node)->children->node :NULL;
if (t && (t->sgprivate->tag==TAG_DOMText)) {
if (t->textContent) free(t->textContent);
t->textContent = NULL;
if (str) t->textContent = strdup(str);
}
} else {
if (str) gf_dom_add_text_node(com->node, strdup(str));
}
}
else if ((inf->fieldIndex==TAG_LSR_ATT_scale)
|| (inf->fieldIndex==TAG_LSR_ATT_translation)
|| (inf->fieldIndex==TAG_LSR_ATT_rotation)
) {
SVG_Transform *mx;
gf_svg_get_attribute_by_tag(com->node, TAG_SVG_ATT_transform, 1, 0, &a);
mx = a.far_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
GF_Point2D scale, translate;
SVG_Point_Angle rotate;
if (gf_mx2d_decompose(&mx->mat, &scale, &rotate.angle, &translate)) {
gf_mx2d_init(mx->mat);
if (inf->fieldIndex==TAG_LSR_ATT_scale) scale = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldIndex==TAG_LSR_ATT_translation) translate = *(GF_Point2D *)inf->field_ptr;
else if (inf->fieldIndex==TAG_LSR_ATT_rotation) rotate = *(SVG_Point_Angle*)inf->field_ptr;
gf_mx2d_add_scale(&mx->mat, scale.x, scale.y);
gf_mx2d_add_rotation(&mx->mat, 0, 0, rotate.angle);
gf_mx2d_add_translation(&mx->mat, translate.x, translate.y);
}
} else {
if (inf->fieldIndex==TAG_LSR_ATT_scale) gf_mx2d_add_scale(&mx->mat, ((GF_Point2D*)inf->field_ptr)->x, ((GF_Point2D*)inf->field_ptr)->y);
if (inf->fieldIndex==TAG_LSR_ATT_translation) gf_mx2d_add_translation(&mx->mat, ((GF_Point2D*)inf->field_ptr)->x, ((GF_Point2D*)inf->field_ptr)->y);
if (inf->fieldIndex==TAG_LSR_ATT_rotation) gf_mx2d_add_rotation(&mx->mat, 0, 0, ((SVG_Point_Angle*)inf->field_ptr)->angle);
}
}
else if (gf_svg_get_attribute_by_tag(com->node, inf->fieldIndex, 1, 0, &a) == GF_OK) {
b = a;
b.far_ptr = inf->field_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
gf_svg_attributes_copy(&a, &b, 0);
} else {
gf_svg_attributes_add(&a, &b, &a, 0);
}
}
b = a;
b.far_ptr = inf->field_ptr;
}
/*signal node modif*/
gf_node_changed(com->node, &a);
} else if (com->fromNodeID) {
GF_FieldInfo a, b;
GF_Node *fromNode = gf_sg_find_node(graph, com->fromNodeID);
if (!fromNode) return GF_NON_COMPLIANT_BITSTREAM;
if (gf_node_get_field(fromNode, com->fromFieldIndex, &b) != GF_OK) return GF_NON_COMPLIANT_BITSTREAM;
if ((inf->fieldIndex==(u32) -1) && (inf->fieldType==SVG_String_datatype)) {
char *str = *(SVG_String*)inf->field_ptr;
if (com->tag == GF_SG_LSR_REPLACE) {
GF_DOMText *t = ((SVG_Element*)com->node)->children ? (GF_DOMText*) ((SVG_Element*)com->node)->children->node :NULL;
if (t && (t->sgprivate->tag==TAG_DOMText)) {
if (t->textContent) free(t->textContent);
t->textContent = NULL;
if (str) t->textContent = strdup(str);
}
} else {
if (str) gf_dom_add_text_node(com->node, strdup(str));
}
} else {
gf_node_get_field(com->node, inf->fieldIndex, &a);
if (com->tag == GF_SG_LSR_REPLACE) {
e = gf_svg_attributes_copy(&a, &b, 0);
} else {
e = gf_svg_attributes_add(&a, &b, &a, 0);
}
}
gf_node_changed(com->node, &a);
return e;
} else {
return GF_NON_COMPLIANT_BITSTREAM;
}
break;
case GF_SG_LSR_ACTIVATE:
gf_node_activate(com->node);
break;
case GF_SG_LSR_DEACTIVATE:
gf_node_deactivate(com->node);
gf_node_changed(com->node, NULL);
break;
#endif
default:
return GF_NOT_SUPPORTED;
}
if (e) return e;
if (com->scripts_to_load) {
while (gf_list_count(com->scripts_to_load)) {
GF_Node *script = (GF_Node *)gf_list_get(com->scripts_to_load, 0);
gf_list_rem(com->scripts_to_load, 0);
gf_sg_script_load(script);
}
gf_list_del(com->scripts_to_load);
com->scripts_to_load = NULL;
}
return GF_OK;
}
GF_Node *gf_bifs_dec_node(GF_BifsDecoder * codec, GF_BitStream *bs, u32 NDT_Tag)
{
u32 nodeID, NDTBits, node_type, node_tag, ProtoID, BVersion;
Bool skip_init, reset_qp14;
GF_Node *new_node;
GF_Err e;
GF_Proto *proto;
void SetupConditional(GF_BifsDecoder *codec, GF_Node *node);
//to store the UseName
char name[1000];
#if 0
/*should only happen with inputSensor, in which case this is BAAAAD*/
if (!codec->info) {
codec->LastError = GF_BAD_PARAM;
return NULL;
}
#endif
BVersion = GF_BIFS_V1;
/*this is a USE statement*/
if (gf_bs_read_int(bs, 1)) {
nodeID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
/*NULL node is encoded as USE with ID = all bits to 1*/
if (nodeID == (u32) (1<<codec->info->config.NodeIDBits))
return NULL;
//find node and return it
new_node = gf_sg_find_node(codec->current_graph, nodeID);
if (!new_node) {
codec->LastError = GF_SG_UNKNOWN_NODE;
} else {
/*restore QP14 length*/
switch (gf_node_get_tag(new_node)) {
case TAG_MPEG4_Coordinate:
{
u32 nbCoord = ((M_Coordinate *)new_node)->point.count;
gf_bifs_dec_qp14_enter(codec, 1);
gf_bifs_dec_qp14_set_length(codec, nbCoord);
gf_bifs_dec_qp14_enter(codec, 0);
}
break;
case TAG_MPEG4_Coordinate2D:
{
u32 nbCoord = ((M_Coordinate2D *)new_node)->point.count;
gf_bifs_dec_qp14_enter(codec, 1);
gf_bifs_dec_qp14_set_length(codec, nbCoord);
gf_bifs_dec_qp14_enter(codec, 0);
}
break;
}
}
return new_node;
}
//this is a new node
nodeID = 0;
name[0] = 0;
node_tag = 0;
proto = NULL;
//browse all node groups
while (1) {
NDTBits = gf_bifs_get_ndt_bits(NDT_Tag, BVersion);
/*this happens in replacescene where no top-level node is present (externProto)*/
if ((BVersion==1) && (NDTBits > 8 * gf_bs_available(bs)) ) {
codec->LastError = GF_OK;
return NULL;
}
node_type = gf_bs_read_int(bs, NDTBits);
if (node_type) break;
//increment BIFS version
BVersion += 1;
//not supported
if (BVersion > GF_BIFS_NUM_VERSION) {
codec->LastError = GF_BIFS_UNKNOWN_VERSION;
return NULL;
}
}
if (BVersion==2 && node_type==1) {
ProtoID = gf_bs_read_int(bs, codec->info->config.ProtoIDBits);
/*look in current graph for the proto - this may be a proto graph*/
proto = gf_sg_find_proto(codec->current_graph, ProtoID, NULL);
/*this was in proto so look in main scene*/
if (!proto && codec->current_graph != codec->scenegraph)
proto = gf_sg_find_proto(codec->scenegraph, ProtoID, NULL);
if (!proto) {
codec->LastError = GF_SG_UNKNOWN_NODE;
return NULL;
}
} else {
node_tag = gf_bifs_ndt_get_node_type(NDT_Tag, node_type, BVersion);
}
/*special handling of 3D mesh*/
if ((node_tag == TAG_MPEG4_IndexedFaceSet) && codec->info->config.Use3DMeshCoding) {
if (gf_bs_read_int(bs, 1)) {
nodeID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
if (codec->UseName) gf_bifs_dec_name(bs, name);
}
/*parse the 3DMesh node*/
return NULL;
}
/*unknow node*/
if (!node_tag && !proto) {
codec->LastError = GF_SG_UNKNOWN_NODE;
return NULL;
}
/*DEF'd flag*/
if (gf_bs_read_int(bs, 1)) {
if (!codec->info->config.NodeIDBits) {
codec->LastError = GF_NON_COMPLIANT_BITSTREAM;
return NULL;
}
nodeID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
if (codec->UseName) gf_bifs_dec_name(bs, name);
}
new_node = NULL;
skip_init = 0;
/*don't check node IDs duplicate since VRML may use them...*/
#if 0
/*if a node with same DEF is already in the scene, use it
we don't do that in memory mode because commands may force replacement
of a node with a new node with same ID, and we want to be able to dump it (otherwise we would
dump a USE)*/
if (nodeID && !codec->dec_memory_mode) {
new_node = gf_sg_find_node(codec->current_graph, nodeID);
if (new_node) {
if (proto) {
if ((gf_node_get_tag(new_node) != TAG_ProtoNode) || (gf_node_get_proto(new_node) != proto)) {
codec->LastError = GF_NON_COMPLIANT_BITSTREAM;
return NULL;
}
skip_init = 1;
} else {
if (gf_node_get_tag(new_node) != node_tag) {
codec->LastError = GF_NON_COMPLIANT_BITSTREAM;
return NULL;
}
skip_init = 1;
}
}
}
#endif
if (!new_node) {
if (proto) {
skip_init = 1;
/*create proto interface*/
new_node = gf_sg_proto_create_instance(codec->current_graph, proto);
} else {
new_node = gf_node_new(codec->current_graph, node_tag);
}
}
if (!new_node) {
codec->LastError = GF_NOT_SUPPORTED;
return NULL;
}
/*VRML: "The transformation hierarchy shall be a directed acyclic graph; results are undefined if a node
in the transformation hierarchy is its own ancestor"
that's good, because the scene graph can't handle cyclic graphs (destroy will never be called).
We therefore only register the node once parsed*/
if (nodeID) {
if (strlen(name)) {
gf_node_set_id(new_node, nodeID, name);
} else {
gf_node_set_id(new_node, nodeID, NULL);
}
}
/*update default time fields except in proto parsing*/
if (!codec->pCurrentProto) UpdateTimeNode(codec, new_node);
/*nodes are only init outside protos */
else skip_init = 1;
/*if coords were not stored for QP14 before coding this node, reset QP14 it when leaving*/
reset_qp14 = !codec->coord_stored;
/*QP 14 is a special quant mode for IndexFace/Line(2D)Set to quantize the
coordonate(2D) child, based on the first field parsed
we must check the type of the node and notfy the QP*/
switch (node_tag) {
case TAG_MPEG4_Coordinate:
case TAG_MPEG4_Coordinate2D:
gf_bifs_dec_qp14_enter(codec, 1);
}
if (gf_bs_read_int(bs, 1)) {
e = gf_bifs_dec_node_mask(codec, bs, new_node, proto ? 1 : 0);
} else {
e = gf_bifs_dec_node_list(codec, bs, new_node, proto ? 1 : 0);
}
if (codec->coord_stored && reset_qp14)
gf_bifs_dec_qp14_reset(codec);
if (e) {
codec->LastError = e;
/*register*/
gf_node_register(new_node, NULL);
/*unregister (deletes)*/
gf_node_unregister(new_node, NULL);
return NULL;
}
if (!skip_init)
gf_node_init(new_node);
switch (node_tag) {
case TAG_MPEG4_Coordinate:
case TAG_MPEG4_Coordinate2D:
gf_bifs_dec_qp14_enter(codec, 0);
break;
case TAG_MPEG4_Script:
/*load script if in main graph (useless to load in proto declaration)*/
if (codec->scenegraph == codec->current_graph) {
gf_sg_script_load(new_node);
}
break;
/*conditionals must be init*/
case TAG_MPEG4_Conditional:
SetupConditional(codec, new_node);
break;
}
/*proto is initialized upon the first traversal to have the same behavior as wth BT/XMT loading*/
#if 0
/*if new node is a proto and we're in the top scene, load proto code*/
if (proto && (codec->scenegraph == codec->current_graph)) {
codec->LastError = gf_sg_proto_load_code(new_node);
}
#endif
return new_node;
}
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;
}