void VTT_load_script(VTTDec *vttdec, GF_SceneGraph *graph)
{
GF_Node *n, *root;
GF_FieldInfo info;
const char *path;
FILE *jsfile;
if (!graph) return;
gf_sg_add_namespace(graph, "http://www.w3.org/2000/svg", NULL);
gf_sg_add_namespace(graph, "http://www.w3.org/1999/xlink", "xlink");
gf_sg_add_namespace(graph, "http://www.w3.org/2001/xml-events", "ev");
gf_sg_set_scene_size_info(graph, 800, 600, GF_TRUE);
/* modify the scene with an Inline/Animation pointing to the VTT Renderer */
n = root = gf_node_new(graph, TAG_SVG_svg);
gf_node_register(root, NULL);
gf_sg_set_root_node(graph, root);
gf_node_get_attribute_by_name(n, "xmlns", 0, GF_TRUE, GF_FALSE, &info);
gf_svg_parse_attribute(n, &info, "http://www.w3.org/2000/svg", 0);
VTT_UpdateSizeInfo(vttdec);
gf_node_init(n);
n = gf_node_new(graph, TAG_SVG_script);
gf_node_register(n, root);
gf_node_list_add_child(&((GF_ParentNode *)root)->children, n);
path = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript");
if (!path) {
/* try to find the JS renderer in the default GPAC installation folder */
const char *startuppath = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "General", "StartupFile");
path = gf_url_concatenate(startuppath, "webvtt-renderer.js");
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_modules_set_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript", path);
gf_fclose(jsfile);
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot find Rendering Script [WebVTT:RenderingScript] - check config file\n"));
return;
}
}
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_fclose(jsfile);
gf_node_get_attribute_by_tag(n, TAG_XLINK_ATT_href, GF_TRUE, GF_FALSE, &info);
if (strstr(path, ":\\")) {
gf_svg_parse_attribute(n, &info, (char *) path, 0);
} else {
char szPath[GF_MAX_PATH];
strcpy(szPath, "file://");
strcat(szPath, path);
gf_svg_parse_attribute(n, &info, (char *) szPath, 0);
}
vttdec->has_rendering_script = GF_TRUE;
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot open Rendering Script - %s\n", path));
return;
}
gf_node_init(n);
}
GF_Node *V4SceneGraph::NewNode(u32 tag)
{
GF_Node *n = gf_node_new(m_pSg, tag);
if (!n) return NULL;
gf_node_init(n);
return n;
}
GF_Node *gf_xml_node_clone(GF_SceneGraph *inScene, GF_Node *orig, GF_Node *cloned_parent, char *inst_id, Bool deep)
{
GF_DOMAttribute *att;
GF_Node *clone = gf_node_new(inScene, orig->sgprivate->tag);
if (!clone) return NULL;
if (orig->sgprivate->tag == TAG_DOMText) {
GF_DOMText *n_src,*n_dst;
n_src = (GF_DOMText *)orig;
n_dst = (GF_DOMText *)clone;
n_dst->type = n_src->type;
n_dst->textContent = gf_strdup(n_src->textContent);
} else {
if (orig->sgprivate->tag == TAG_DOMFullNode) {
GF_DOMFullNode *n_src,*n_dst;
n_src = (GF_DOMFullNode *)orig;
n_dst = (GF_DOMFullNode *)clone;
n_dst->ns = n_src->ns;
n_dst->name = gf_strdup(n_dst->name);
}
att = ((GF_DOMNode *)orig)->attributes;
while (att) {
GF_FieldInfo dst, src;
/*create by name*/
if (att->tag==TAG_DOM_ATT_any) {
gf_node_get_attribute_by_name(clone, ((GF_DOMFullAttribute*)att)->name, 0, 1, 0, &dst);
} else {
gf_node_get_attribute_by_tag(clone, att->tag, 1, 0, &dst);
}
src.far_ptr = att->data;
src.fieldType = att->data_type;
src.fieldIndex = att->tag;
gf_svg_attributes_copy(&dst, &src, 0);
if (att->tag==TAG_XLINK_ATT_href) {
XMLRI *iri = (XMLRI *)att->data;
if (iri->target == gf_node_get_parent(orig, 0)) {
((XMLRI *)dst.far_ptr)->target = cloned_parent;
} else {
((XMLRI *)dst.far_ptr)->target = NULL;
}
}
att = att->next;
}
}
if (cloned_parent) {
gf_node_list_add_child( & ((GF_ParentNode*)cloned_parent)->children, clone);
gf_node_register(clone, cloned_parent);
/*TO CLARIFY: can we init the node right now or should we wait for insertion in the scene tree ?*/
gf_node_init(clone);
}
if (deep) {
GF_ChildNodeItem *child = ((GF_ParentNode *)orig)->children;
while (child) {
gf_node_clone(inScene, child->node, clone, inst_id, 1);
child = child->next;
}
}
return clone;
}
GF_Node *V4SceneManager::NewNode(u32 tag)
{
GF_Node *n = gf_node_new(m_pIs->graph, tag);
if (!n) return NULL;
gf_node_init(n);
return n;
}
/*this is ugly but we have no choice, we need to clone the conditional stack because of externProto*/
void BIFS_SetupConditionalClone(GF_Node *node, GF_Node *orig)
{
M_Conditional *ptr;
u32 i;
ConditionalStack *priv_orig, *priv;
priv_orig = (ConditionalStack*)gf_node_get_private(orig);
/*looks we're not in BIFS*/
if (!priv_orig) {
GF_Command *ori_com;
M_Conditional *c_orig, *c_dest;
c_orig = (M_Conditional *)orig;
c_dest = (M_Conditional *)node;
gf_node_init(node);
/*and clone all commands*/
i=0;
while ((ori_com = (GF_Command*)gf_list_enum(c_orig->buffer.commandList, &i))) {
GF_Command *dest_com = gf_sg_command_clone(ori_com, gf_node_get_graph(node));
if (dest_com) gf_list_add(c_dest->buffer.commandList, dest_com);
}
return;
}
priv = (ConditionalStack*)malloc(sizeof(ConditionalStack));
priv->codec = priv_orig->codec;
priv->info = priv_orig->info;
gf_node_set_callback_function(node, Conditional_PreDestroy);
gf_node_set_private(node, priv);
ptr = (M_Conditional *)node;
ptr->on_activate = Conditional_OnActivate;
ptr->on_reverseActivate = Conditional_OnReverseActivate;
}
static GFINLINE GF_Node *ttd_create_node(TTDPriv *ttd, u32 tag, const char *def_name)
{
GF_Node *n = gf_node_new(ttd->sg, tag);
if (n) {
if (def_name) gf_node_set_id(n, gf_sg_get_next_available_node_id(ttd->sg), def_name);
gf_node_init(n);
}
return n;
}
static GFINLINE GF_Node *create_node(GF_OSD *osd, u32 tag, GF_Node *par)
{
GF_Node *n = gf_node_new(osd->odm->subscene->graph, tag);
if (n) {
gf_node_init(n);
if (par) {
gf_node_list_add_child( & ((GF_ParentNode *)par)->children, n);
gf_node_register(n, par);
}
}
return n;
}
GF_Node *CloneNodeForEditing(GF_SceneGraph *inScene, GF_Node *orig) //, GF_Node *cloned_parent)
{
u32 i, j, count;
GF_Node *node, *child, *tmp;
GF_List *list, *list2;
GF_FieldInfo field_orig, field;
/*this is not a mistake*/
if (!orig) return NULL;
/*check for DEF/USE
if (orig->sgprivate->NodeID) {
node = gf_sg_find_node(inScene, orig->sgprivate->NodeID);
//node already created, USE
if (node) {
gf_node_register(node, cloned_parent);
return node;
}
}
*/
/*create a node*/
/*
if (orig->sgprivate->tag == TAG_MPEG4_ProtoNode) {
proto_node = ((GF_ProtoInstance *)orig)->proto_interface;
//create the instance but don't load the code -c we MUST wait for ISed routes to be cloned before
node = gf_sg_proto_create_node(inScene, proto_node, (GF_ProtoInstance *) orig);
} else {
*/
node = gf_node_new(inScene, gf_node_get_tag(orig));
// }
count = gf_node_get_field_count(orig);
/*copy each field*/
for (i=0; i<count; i++) {
gf_node_get_field(orig, i, &field_orig);
/*get target ptr*/
gf_node_get_field(node, i, &field);
assert(field.eventType==field_orig.eventType);
assert(field.fieldType==field_orig.fieldType);
/*duplicate it*/
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
child = CloneNodeForEditing(inScene, (GF_Node *) (* ((GF_Node **) field_orig.far_ptr)));//, node);
*((GF_Node **) field.far_ptr) = child;
break;
case GF_SG_VRML_MFNODE:
list = *( (GF_List **) field_orig.far_ptr);
list2 = *( (GF_List **) field.far_ptr);
for (j=0; j<gf_list_count(list); j++) {
tmp = (GF_Node *)gf_list_get(list, j);
child = CloneNodeForEditing(inScene, tmp);//, node);
gf_list_add(list2, child);
}
break;
default:
gf_sg_vrml_field_copy(field.far_ptr, field_orig.far_ptr, field.fieldType);
break;
}
}
/*register node
if (orig->sgprivate->NodeID) {
Node_SetID(node, orig->sgprivate->NodeID);
gf_node_register(node, cloned_parent);
}*/
/*init node before creating ISed routes so the eventIn handler are in place*/
if (gf_node_get_tag(node) != TAG_ProtoNode) gf_node_init(node);
return node;
}
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;
}