← Back to branch summary

~ubuntu-branches/ubuntu/raring/gpac/raring

« back to all changes in this revision

Viewing changes to src/scenegraph/base_scenegraph.c

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2007-01-24 23:34:57 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20070124233457-zzlls8afkt0nyakj
Tags: 0.4.2~rc2-0ubuntu1
* New upstream release
  * Most notably MP4 tagging support via MP4Box -itags
* debian/patches/01_64bits.dpatch: dropped; included upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/scenegraph/base_scenegraph.c
30
30
/*X3D tags (for internal nodes)*/
31
31
#include <gpac/nodes_x3d.h>
32
32
 
33
 
 
34
 
#ifdef GPAC_USE_LASeR
35
 
#include "../LASeR/m4_laser_dev.h"
36
 
#endif
37
 
 
38
 
 
39
33
static void ReplaceDEFNode(GF_Node *FromNode, u32 NodeID, GF_Node *newNode, Bool updateOrderedGroup);
40
34
 
 
35
#ifndef GPAC_DISABLE_SVG
 
36
static void ReplaceIRINode(GF_Node *FromNode, GF_Node *oldNode, GF_Node *newNode);
 
37
#endif
 
38
 
41
39
 
42
40
#define DEFAULT_MAX_CYCLIC_RENDER       30
43
41
 
59
57
        tmp->Routes = gf_list_new();
60
58
        tmp->routes_to_activate = gf_list_new();
61
59
        tmp->routes_to_destroy = gf_list_new();
 
60
#ifndef GPAC_DISABLE_SVG
 
61
        tmp->xlink_hrefs = gf_list_new();
 
62
        tmp->smil_timed_elements = gf_list_new();
 
63
#endif
62
64
        return tmp;
63
65
}
64
66
 
75
77
        tmp->SceneCallback = scene->SceneCallback;
76
78
        tmp->GetExternProtoLib = scene->GetExternProtoLib;
77
79
        tmp->js_ifce = scene->js_ifce;
78
 
        tmp->gf_sg_script_load = scene->gf_sg_script_load;
 
80
        tmp->script_load = scene->script_load;
79
81
 
80
82
#ifdef GF_CYCLIC_RENDER_ON
81
83
        tmp->max_cyclic_render = scene->max_cyclic_render;
129
131
 
130
132
        gf_sg_reset(sg);
131
133
 
 
134
#ifndef GPAC_DISABLE_SVG
 
135
        gf_list_del(sg->xlink_hrefs);
 
136
        gf_list_del(sg->smil_timed_elements);
 
137
#endif
132
138
        gf_list_del(sg->Routes);
133
139
        gf_list_del(sg->protos);
134
140
        gf_list_del(sg->unregistered_protos);
169
175
                }
170
176
                else if (info.fieldType==GF_SG_VRML_MFNODE) {
171
177
                        mflist = *(GF_List **) info.far_ptr;
172
 
                        for (j=0; j<gf_list_count(mflist); j++) {
173
 
                                n = gf_list_get(mflist, j);
 
178
                        j=0;
 
179
                        while ((n = gf_list_enum(mflist, &j))) {
174
180
                                if (n->sgprivate->scenegraph==sg) {
175
181
                                        gf_node_unregister(n, node);
 
182
                                        j--;
176
183
                                        gf_list_rem(mflist, j);
177
 
                                        j--;
178
184
                                } else {
179
185
                                        SG_GraphRemoved(n, sg);
180
186
                                }
183
189
        }
184
190
}
185
191
 
 
192
GFINLINE GF_Node *SG_SearchForNode(GF_SceneGraph *sg, GF_Node *node)
 
193
{
 
194
        u32 i;
 
195
        for (i=0; i<sg->node_reg_size; i++) {
 
196
                if (sg->node_registry[i] == node) {
 
197
                        return sg->node_registry[i];
 
198
                }
 
199
        }
 
200
        return NULL;
 
201
}
 
202
 
186
203
void gf_sg_reset(GF_SceneGraph *sg)
187
204
{
188
 
        u32 i;
 
205
        u32 i, type, count;
189
206
        if (!sg) return;
190
207
 
191
208
        /*inlined graph, remove any of this graph nodes from the parent graph*/
209
226
 
210
227
        }
211
228
 
 
229
 
212
230
        /*WATCHOUT: we may have cyclic dependencies due to
213
231
        1- a node referencing itself (forbidden in VRML)
214
232
        2- nodes refered to in commands of conditionals children of this node (MPEG-4 is mute about that)
 
233
        we recursively preocess from last declared DEF node to first one
215
234
        */
216
 
        for (i=0; i<sg->node_reg_size; i++) {
217
 
                GF_Node *node = sg->node_registry[i];
 
235
restart:
 
236
        for (i=sg->node_reg_size; i>0; i--) {
 
237
                Bool ignore = 0;
 
238
                GF_Node *node = sg->node_registry[i-1];
 
239
                if (!node) continue;
 
240
 
218
241
                /*first replace all instances in parents by NULL WITHOUT UNREGISTERING (to avoid destroying the node).
219
242
                This will take care of nodes referencing themselves*/
220
243
#ifdef GF_ARRAY_PARENT_NODES
221
 
                u32 j;
222
 
                for (j=0; j<gf_list_count(node->sgprivate->parentNodes); j++) {
 
244
                u32 j, count, k;
 
245
                type = node->sgprivate->tag;
 
246
#ifndef GPAC_DISABLE_SVG
 
247
                if ((type>= GF_NODE_RANGE_FIRST_SVG) && (type<= GF_NODE_RANGE_LAST_SVG)) type = 1;
 
248
                else 
 
249
#endif
 
250
                        type = 0;
 
251
                count = gf_list_count(node->sgprivate->parentNodes);
 
252
                for (j=0; j<count; j++) {
223
253
                        GF_Node *par = gf_list_get(node->sgprivate->parentNodes, j);
224
 
                        ReplaceDEFNode(par, node->sgprivate->NodeID, NULL, 0);
 
254
                        if ((par != node) && (SG_SearchForNode(sg, par) != NULL)) {
 
255
                                ignore = 1;
 
256
                                break;
 
257
                        }
 
258
 
 
259
#ifndef GPAC_DISABLE_SVG
 
260
                        if (type) {
 
261
                                ReplaceIRINode(par, node->sgprivate->NodeID, NULL);
 
262
                        } else 
 
263
#endif
 
264
                                ReplaceDEFNode(par, node->sgprivate->NodeID, NULL, 0);
225
265
                }
 
266
                
 
267
                if (ignore) continue;
 
268
 
226
269
                /*then we remove the node from the registry and destroy it. This will take 
227
270
                care of conditional case as we perform special checking when destroying commands*/
228
271
                gf_list_reset(node->sgprivate->parentNodes);
229
272
#else
 
273
                {
230
274
                GF_NodeList *nlist = node->sgprivate->parents;
 
275
                type = node->sgprivate->tag;
 
276
#ifndef GPAC_DISABLE_SVG
 
277
                if ((type>= GF_NODE_RANGE_FIRST_SVG) && (type<= GF_NODE_RANGE_LAST_SVG)) type = 1;
 
278
                else 
 
279
#endif
 
280
                        type = 0;
231
281
                while (nlist) {
232
282
                        GF_NodeList *next = nlist->next;
233
 
                        ReplaceDEFNode(nlist->node, node->sgprivate->NodeID, NULL, 0);
 
283
                        if ((nlist->node!=node) && SG_SearchForNode(sg, nlist->node) != NULL) {
 
284
                                ignore = 1;
 
285
                                break;
 
286
                        }
 
287
#ifndef GPAC_DISABLE_SVG
 
288
                        if (type) {
 
289
                                ReplaceIRINode(nlist->node, node, NULL);
 
290
                        } else 
 
291
#endif
 
292
                                ReplaceDEFNode(nlist->node, node->sgprivate->NodeID, NULL, 0);
 
293
                        
234
294
                        free(nlist);
235
295
                        nlist = next;
236
296
                }
 
297
                if (ignore) {
 
298
                        node->sgprivate->parents = nlist;
 
299
                        continue;
 
300
                }
 
301
 
237
302
                node->sgprivate->parents = NULL;
 
303
                }
238
304
#endif
239
 
                sg->node_registry[i] = NULL;
240
 
                gf_node_del(node);
 
305
                //sg->node_registry[i-1] = NULL;
 
306
                count = sg->node_reg_size;
 
307
                node->sgprivate->num_instances = 1;
 
308
                gf_node_unregister(node, NULL);
 
309
                if (count != sg->node_reg_size) goto restart;
241
310
        }
242
311
        sg->node_reg_size = 0;
243
312
 
253
322
                /*this will unregister the proto from the graph, so don't delete the chain entry*/
254
323
                gf_sg_proto_del(p);
255
324
        }
 
325
#ifndef GPAC_DISABLE_SVG
 
326
        assert(gf_list_count(sg->xlink_hrefs) == 0);
 
327
#endif
256
328
 
257
329
        /*last destroy all routes*/
258
330
        gf_sg_destroy_routes(sg);
273
345
        return NULL;
274
346
}
275
347
 
276
 
GFINLINE GF_Node *SG_SearchForNode(GF_SceneGraph *sg, GF_Node *node)
277
 
{
278
 
        u32 i;
279
 
        for (i=0; i<sg->node_reg_size; i++) {
280
 
                if (sg->node_registry[i] == node) {
281
 
                        return sg->node_registry[i];
282
 
                }
283
 
        }
284
 
        return NULL;
285
 
}
286
 
 
287
348
static GFINLINE u32 node_search(GF_SceneGraph *sg, u32 low_pos, u32 high_pos, u32 ID) 
288
349
{
289
350
        u32 mid_pos;
363
424
 
364
425
Bool gf_sg_use_pixel_metrics(GF_SceneGraph *sg)
365
426
{
366
 
        return (sg ? sg->usePixelMetrics : 0);
 
427
        if (sg) {
 
428
                while (sg->pOwningProto) sg = sg->parent_scene;
 
429
                return sg->usePixelMetrics;
 
430
        }
 
431
        return 0;
367
432
}
368
433
 
369
434
Bool gf_sg_get_scene_size_info(GF_SceneGraph *sg, u32 *width, u32 *height)
389
454
{
390
455
        u32 node_ind, j;
391
456
        GF_SceneGraph *pSG;
 
457
        GF_Route *r;
 
458
 
 
459
//      fprintf(stdout, "unregister %8x from %8x\n", pNode, parentNode);
392
460
 
393
461
        if (!pNode) return GF_OK;
394
462
        pSG = pNode->sgprivate->scenegraph;
396
464
        if (pNode == (GF_Node*)pSG->pOwningProto) pSG = pSG->parent_scene;
397
465
        assert(pSG);
398
466
 
 
467
 
399
468
#ifdef GF_ARRAY_PARENT_NODES
400
469
        if (parentNode) gf_list_rem(pNode->sgprivate->parentNodes, parentNode);
401
470
#else
426
495
        
427
496
        /*this is just an instance removed*/
428
497
        if (pNode->sgprivate->num_instances) return GF_OK;
 
498
 
429
499
        
430
500
#ifdef GF_ARRAY_PARENT_NODES
431
501
        assert(gf_list_count(pNode->sgprivate->parentNodes)==0);
435
505
 
436
506
        /*if def, remove from sg def table*/
437
507
        if (pNode->sgprivate->NodeID) {
438
 
                if (!SG_SearchForNodeIndex(pSG, pNode, &node_ind)) {
439
 
                        assert(0);
 
508
                if (SG_SearchForNodeIndex(pSG, pNode, &node_ind)) {
 
509
                        assert (pNode == pSG->node_registry[node_ind]);
 
510
                        j = pSG->node_reg_size - node_ind - 1;
 
511
                        if (j) memmove( & pSG->node_registry[node_ind], & pSG->node_registry[node_ind+1], j * sizeof(GF_Node *));
 
512
                        pSG->node_reg_size -= 1;
 
513
                } else {
 
514
                        return GF_OK;
440
515
                }
441
 
                assert (pNode == pSG->node_registry[node_ind]);
442
 
                j = pSG->node_reg_size - node_ind - 1;
443
 
                if (j) memmove( & pSG->node_registry[node_ind], & pSG->node_registry[node_ind+1], j * sizeof(GF_Node *));
444
 
                pSG->node_reg_size -= 1;
445
516
        }
446
517
 
447
518
        /*check all routes from or to this node and destroy them - cf spec*/
448
 
        for (j=0; j<gf_list_count(pSG->Routes); j++) {
449
 
                GF_Route *r = gf_list_get(pSG->Routes, j);
 
519
        j=0;
 
520
        while ((r = gf_list_enum(pSG->Routes, &j))) {
450
521
                if ( (r->ToNode == pNode) || (r->FromNode == pNode)) {
451
522
                        gf_sg_route_del(r);
452
523
                        j--;
453
524
                }
454
525
        }
 
526
#if defined(GPAC_HAS_SPIDERMONKEY) && !defined(GPAC_DISABLE_SVG)
 
527
        /*for svg scripts*/
 
528
        if (pSG->svg_js) pSG->svg_js->on_node_destroy(pSG, pNode);
 
529
#endif
455
530
 
456
531
        /*delete the node*/
457
532
        gf_node_del(pNode);
461
536
GF_Err gf_node_register(GF_Node *node, GF_Node *parentNode)
462
537
{
463
538
        GF_SceneGraph *pSG; 
 
539
        if (!node) return GF_OK;
464
540
        
 
541
//      fprintf(stdout, "register %8x in %8x\n", node, parentNode);
 
542
 
465
543
        pSG = node->sgprivate->scenegraph;
466
544
        /*if this is a proto register to the parent graph, not the current*/
467
545
        if (node == (GF_Node*)pSG->pOwningProto) pSG = pSG->parent_scene;
536
614
                        break;
537
615
                case GF_SG_VRML_MFNODE:
538
616
                        container = *(GF_List **) field.far_ptr;
539
 
                        for (j=0; j<gf_list_count(container); j++) {
540
 
                                p = gf_list_get(container, j);
 
617
                        j=0;
 
618
                        while ((p = gf_list_enum(container, &j))) {
541
619
                                /*replace nodes different from newNode but with same ID*/
542
620
                                if ((newNode == p) || (gf_node_get_id(p) != NodeID)) continue;
543
 
 
 
621
                                
 
622
                                j--;
544
623
                                gf_list_rem(container, j);
545
624
                                if (newNode) {
546
625
                                        gf_list_insert(container, newNode, j);
562
641
        gf_node_changed(FromNode, &field);
563
642
}
564
643
 
 
644
#ifndef GPAC_DISABLE_SVG
 
645
 
 
646
static void Replace_IRI(GF_SceneGraph *sg, GF_Node *old_node, GF_Node *newNode)
 
647
{
 
648
        u32 i, count;
 
649
        count = gf_list_count(sg->xlink_hrefs);
 
650
        for (i=0; i<count; i++) {
 
651
                SVG_IRI *iri = gf_list_get(sg->xlink_hrefs, i);
 
652
                if (iri->target == (SVGElement *)old_node) {
 
653
                        iri->target = (SVGElement *)newNode;
 
654
                        if (!newNode) {
 
655
                                gf_list_rem(sg->xlink_hrefs, i);
 
656
                                i--;
 
657
                                count--;
 
658
                        }
 
659
                } 
 
660
        }
 
661
}
 
662
 
 
663
/*replace or remove node instance in the given node (eg in all IRI)*/
 
664
static void ReplaceIRINode(GF_Node *FromNode, GF_Node *old_node, GF_Node *newNode)
 
665
{
 
666
        u32 i, count;
 
667
        GF_List *container;
 
668
 
 
669
        container = ((SVGElement *)FromNode)->children;
 
670
        count = gf_list_count(container);
 
671
        for (i=0; i<count; i++) {
 
672
                GF_Node *p = gf_list_get(container, i);
 
673
                if (old_node!=p) continue;
 
674
                gf_list_rem(container, i);
 
675
                if (newNode) gf_list_insert(container, newNode, i);
 
676
                break;
 
677
        }
 
678
}
 
679
#endif
 
680
 
565
681
/*get all parents of the node and replace, the instance of the node and finally destroy the node*/
566
682
GF_Err gf_node_replace(GF_Node *node, GF_Node *new_node, Bool updateOrderedGroup)
567
683
{
568
 
        u32 i;
 
684
        u32 type;
569
685
        Bool replace_root;
570
686
        GF_Node *par;
571
687
        GF_SceneGraph *pSG = node->sgprivate->scenegraph;
572
688
 
573
689
        /*if this is a proto its is registered in its parent graph, not the current*/
574
690
        if (node == (GF_Node*)pSG->pOwningProto) pSG = pSG->parent_scene;
575
 
        if (!SG_SearchForNodeIndex(pSG, node, &i)) return GF_BAD_PARAM;
576
 
        assert(node == pSG->node_registry[i]);
 
691
//      if (!SG_SearchForNodeIndex(pSG, node, &i)) return GF_BAD_PARAM;
 
692
//      assert(node == pSG->node_registry[i]);
 
693
 
 
694
        type = node->sgprivate->tag;
 
695
#ifndef GPAC_DISABLE_SVG
 
696
        if ((type>= GF_NODE_RANGE_FIRST_SVG) && (type<= GF_NODE_RANGE_LAST_SVG)) {
 
697
                type = 1;
 
698
                Replace_IRI(pSG, node, new_node);
 
699
        } else 
 
700
#endif
 
701
                type = 0;
577
702
 
578
703
        /*first check if this is the root node*/
579
704
        replace_root = (node->sgprivate->scenegraph->RootNode == node) ? 1 : 0;
580
705
 
581
706
#ifdef GF_ARRAY_PARENT_NODES
582
 
        while ( (i = gf_list_count(node->sgprivate->parentNodes)) ) {
 
707
        while ( (u32 i = gf_list_count(node->sgprivate->parentNodes)) ) {
583
708
                par = gf_list_get(node->sgprivate->parentNodes, 0);
584
 
                ReplaceDEFNode(par, node->sgprivate->NodeID, new_node, updateOrderedGroup);
 
709
#ifndef GPAC_DISABLE_SVG
 
710
                if (type) {
 
711
                        ReplaceIRINode(par, node, new_node, updateOrderedGroup);
 
712
                } else 
 
713
#endif
 
714
                        ReplaceDEFNode(par, node->sgprivate->NodeID, new_node, updateOrderedGroup);
585
715
                                
586
716
                /*adds the parent to the new node*/
587
717
                if (new_node) gf_node_register(new_node, par);
595
725
                Bool do_break = node->sgprivate->parents->next ? 0 : 1;
596
726
                par = node->sgprivate->parents->node;
597
727
 
598
 
                ReplaceDEFNode(par, node->sgprivate->NodeID, new_node, updateOrderedGroup);
 
728
#ifndef GPAC_DISABLE_SVG
 
729
                if (type)
 
730
                        ReplaceIRINode(par, node, new_node);
 
731
                else
 
732
#endif
 
733
                        ReplaceDEFNode(par, node->sgprivate->NodeID, new_node, updateOrderedGroup);
 
734
 
599
735
                if (new_node) gf_node_register(new_node, par);
600
736
                gf_node_unregister(node, par);
601
737
                if (do_break) break;
677
813
#ifdef GF_CYCLIC_RENDER_ON
678
814
        u32 max_pass;
679
815
#endif
680
 
        if (!node) return;
 
816
        if (!node || !node->sgprivate) return;
681
817
 
682
818
#ifdef GF_CYCLIC_RENDER_ON
683
819
        max_pass = (node->sgprivate->render_pass>>16);
735
871
{
736
872
        u32 i;
737
873
        GF_Node *ptr;
738
 
        GF_ParentNode *par = (GF_ParentNode *)node;
739
 
        for (i=0; i<gf_list_count(par->children); i++) {
740
 
                ptr = gf_list_get(par->children, i);
741
 
                if (ptr) gf_node_render(ptr, renderStack);
 
874
        GF_ParentNode *par;
 
875
        if (!node->sgprivate) return;
 
876
 
 
877
        par = (GF_ParentNode *)node;
 
878
        i=0;
 
879
        while ((ptr = gf_list_enum(par->children, &i))) {
 
880
                gf_node_render(ptr, renderStack);
742
881
        }
743
882
}
744
883
 
814
953
#endif
815
954
}
816
955
 
817
 
NodePriv *Node_GetPriv(GF_Node *node)
818
 
{
819
 
        return node->sgprivate;
820
 
}
821
 
 
822
956
GF_Node *gf_sg_new_base_node()
823
957
{
824
958
        GF_Node *newnode = malloc(sizeof(GF_Node));
881
1015
{
882
1016
        if (!node) return;
883
1017
 
884
 
        if (node->sgprivate->routes) {
885
 
                assert(gf_list_count(node->sgprivate->routes)==0);
886
 
/*
887
 
                while (gf_list_count(node->sgprivate->routes)) {
888
 
                        GF_Route *r = gf_list_get(node->sgprivate->routes, 0);
889
 
                        gf_list_rem(node->sgprivate->routes, 0);
890
 
                        r->FromNode = NULL;
891
 
                }
892
 
*/
893
 
 
894
 
                gf_list_del(node->sgprivate->routes);
895
 
                node->sgprivate->routes = NULL;
 
1018
        if (node->sgprivate->events) {
 
1019
                /*true for VRML-based graphs, not true for SVG yet*/
 
1020
                //assert(gf_list_count(node->sgprivate->events)==0);
 
1021
                gf_list_del(node->sgprivate->events);
 
1022
                node->sgprivate->events = NULL;
896
1023
        }
897
1024
        if (node->sgprivate->PreDestroyNode) node->sgprivate->PreDestroyNode(node);
898
1025
#ifdef GF_ARRAY_PARENT_NODES
901
1028
#else
902
1029
        assert(! node->sgprivate->parents);
903
1030
#endif
 
1031
 
904
1032
        if (node->sgprivate->NodeName) free(node->sgprivate->NodeName);
905
1033
        free(node->sgprivate);
906
1034
        free(node);
924
1052
        return gf_list_get(node->sgprivate->parentNodes, idx);
925
1053
#else
926
1054
        GF_NodeList *nlist = node->sgprivate->parents;
 
1055
        if (!nlist) return NULL;
927
1056
        while (idx) { nlist = nlist->next; idx--;}
928
1057
        return nlist->node;
929
1058
#endif
1020
1149
{
1021
1150
        GF_SceneGraph *pSG = node->sgprivate->scenegraph;
1022
1151
        assert(pSG);
 
1152
        /*no user-defined init, consider the scenegraph is only used for parsing/encoding/decoding*/
 
1153
        if (!pSG->UserNodeInit) return;
1023
1154
 
1024
1155
        /*internal nodes*/
1025
1156
        if (gf_sg_vrml_node_init(node)) return;
 
1157
#ifndef GPAC_DISABLE_SVG
 
1158
        else if (gf_sg_svg_node_init(node)) return;
 
1159
#endif
1026
1160
        /*user defined init*/
1027
 
        if (pSG->UserNodeInit) pSG->UserNodeInit(pSG->NodeInitCallback, node);
 
1161
        else pSG->UserNodeInit(pSG->NodeInitCallback, node);
1028
1162
}
1029
1163
 
1030
1164
 
1038
1172
 
1039
1173
        /*internal nodes*/
1040
1174
        if (gf_sg_vrml_node_changed(node, field)) return;
1041
 
 
1042
 
        /*THIS IS BAD, LASeR MUST BE REWRITTEN TO USE FIELD TYPES for SF/MF Nodes*/
1043
 
#ifdef GPAC_USE_LASeR
1044
 
        switch (node->sgprivate->tag) {
1045
 
        case TAG_LASeRTransform:
1046
 
        case TAG_LASeRUse:
1047
 
                node->sgprivate->is_dirty |= GF_SG_CHILD_DIRTY;
1048
 
                break;
1049
 
        }
 
1175
#ifndef GPAC_DISABLE_SVG
 
1176
        else if (gf_sg_svg_node_changed(node, field)) return;
1050
1177
#endif
1051
1178
 
1052
1179
        /*force child dirty tag*/
1065
1192
        else if (node->sgprivate->tag<=GF_NODE_RANGE_LAST_MPEG4) gf_sg_mpeg4_node_del(node);
1066
1193
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_X3D) gf_sg_x3d_node_del(node);
1067
1194
#ifndef GPAC_DISABLE_SVG
1068
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) SVGElement_Del((SVGElement *) node);
1069
 
#endif
1070
 
#ifdef GPAC_USE_LASeR
1071
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_LASER) LASeRNode_Del(node);
 
1195
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) {
 
1196
                SVGElement *elt = (SVGElement *) node;
 
1197
                if (elt->sgprivate->animations) gf_smil_anim_delete_animations(elt);
 
1198
                if (elt->timing) gf_smil_timing_delete_runtime_info(elt);
 
1199
                gf_svg_element_del(elt);
 
1200
        }
1072
1201
#endif
1073
1202
        else gf_node_free(node);
1074
1203
#endif
1080
1209
        if (node->sgprivate->tag <= TAG_UndefinedNode) return 0;
1081
1210
        /*for both MPEG4 & X3D*/
1082
1211
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_X3D) return gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_ALL);
1083
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) return SVG_GetAttributeCount(node);
1084
 
#ifdef GPAC_USE_LASeR
1085
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_LASER) return LASeRNode_GetFieldCount(node, 0);
 
1212
#ifndef GPAC_DISABLE_SVG
 
1213
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) return gf_svg_get_attribute_count(node);
1086
1214
#endif
1087
1215
        return 0;
1088
1216
}
1099
1227
        else if (node->sgprivate->tag==TAG_ProtoNode) return ((GF_ProtoInstance*)node)->proto_name;
1100
1228
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_MPEG4) return gf_sg_mpeg4_node_get_class_name(node->sgprivate->tag);
1101
1229
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_X3D) return gf_sg_x3d_node_get_class_name(node->sgprivate->tag);
1102
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) return SVG_GetElementName(node->sgprivate->tag);
1103
 
#ifdef GPAC_USE_LASeR
1104
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_LASER) return LASeR_GetNodeName(node->sgprivate->tag);
 
1230
#ifndef GPAC_DISABLE_SVG
 
1231
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) return gf_svg_get_element_name(node->sgprivate->tag);
1105
1232
#endif
1106
1233
        else return "UnsupportedNode";
1107
1234
#endif
1117
1244
        else if (tag <= GF_NODE_RANGE_LAST_MPEG4) node = gf_sg_mpeg4_node_new(tag);
1118
1245
        else if (tag <= GF_NODE_RANGE_LAST_X3D) node = gf_sg_x3d_node_new(tag);
1119
1246
#ifndef GPAC_DISABLE_SVG
1120
 
        else if (tag <= GF_NODE_RANGE_LAST_SVG) node = (GF_Node *) SVG_CreateNode(tag);
1121
 
#endif
1122
 
#ifdef GPAC_USE_LASeR
1123
 
        else if (tag <= GF_NODE_RANGE_LAST_LASER) node = LASeR_CreateNode(tag);
 
1247
        else if (tag <= GF_NODE_RANGE_LAST_SVG) node = (GF_Node *) gf_svg_create_node(tag);
1124
1248
#endif
1125
1249
        else node = NULL;
1126
1250
 
1147
1271
                return gf_sg_script_get_field(node, info);
1148
1272
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_MPEG4) return gf_sg_mpeg4_node_get_field(node, info);
1149
1273
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_X3D) return gf_sg_x3d_node_get_field(node, info);
1150
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) return SVG_GetAttributeInfo(node, info);
1151
 
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_LASER) return GF_NOT_SUPPORTED;
 
1274
#ifndef GPAC_DISABLE_SVG
 
1275
        else if (node->sgprivate->tag <= GF_NODE_RANGE_LAST_SVG) return gf_svg_get_attribute_info(node, info);
 
1276
#endif
1152
1277
#endif
1153
1278
        return GF_NOT_SUPPORTED;
1154
1279
}
1155
1280
 
1156
 
/*LASeR specifc, to clean up!!*/
1157
 
u32 gf_node_get_active(GF_Node*p)
 
1281
u32 gf_node_get_num_instances(GF_Node *node)
1158
1282
{
1159
 
#ifdef GPAC_USE_LASeR
1160
 
        return p->sgprivate->active;
1161
 
#else
1162
 
        return 1;
1163
 
#endif
 
1283
        return node->sgprivate->num_instances;
1164
1284
}
1165
1285