← Back to branch summary

~ubuntu-branches/debian/experimental/gpac/experimental

« back to all changes in this revision

Viewing changes to src/scene_manager/loader_xmt.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2014-02-22 18:15:00 UTC
  • mfrom: (1.2.2) (3.1.6 sid)
  • Revision ID: package-import@ubuntu.com-20140222181500-b4phupo05gjpmopa
Tags: 0.5.0+svn5104~dfsg1-1
http://bugs.debian.org/730759
http://bugs.debian.org/730497
http://bugs.debian.org/739321
* New  upstream version 0.5.0+svn5104~dfsg1:
  - src/utils/sha1.c is relicensed under LGPLv2.1, Closes: #730759
* Don't install modules in multi-arch directories, Closes: #730497
* Add libusb-1.0.0-dev headers because libfreenect requires this
* Fix install rule
* Follow upstream soname bump
  - Drop the symbols file for now until it has been revised thourougly
* Let binaries produce the correct svn revision
* Refresh patches
* Patch and build against libav10, Closes: #739321
* Bump standards version, no changes necessary

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/scene_manager/loader_xmt.c
757
757
 
758
758
        /*SF string, no inspection*/
759
759
        if (!is_mf) {
760
 
                len = strlen(str);
 
760
                len = (u32) strlen(str);
761
761
                if (val->buffer) gf_free(val->buffer);
762
762
                val->buffer = NULL;
763
763
                if (len) val->buffer = gf_strdup(str);
778
778
        else if (str[i]=='\"') strcpy(sep, "\"");
779
779
        /*handle as a single field (old GPAC XMT & any unknown cases...*/
780
780
        else {
781
 
                len = strlen(str);
 
781
                len = (u32) strlen(str);
782
782
                if (val->buffer) gf_free(val->buffer);
783
783
                val->buffer = NULL;
784
784
                if (len) val->buffer = gf_strdup(str);
785
785
                return len;
786
786
        }
787
787
        k = 0;
788
 
        i += strlen(sep);
 
788
        i += (u32) strlen(sep);
789
789
 
790
790
        value = gf_strdup(str);
791
791
 
803
803
                }
804
804
        }
805
805
        value[k] = 0;
806
 
        len = strlen(sep) + i;
 
806
        len = (u32) strlen(sep) + i;
807
807
        
808
808
        if (val->buffer) gf_free(val->buffer);
809
809
        val->buffer = NULL;
858
858
        if (parser->last_error) return res;
859
859
 
860
860
        if (val->script_text) gf_free(val->script_text);
861
 
        val->script_text = (unsigned char*)sfstr.buffer;
 
861
        val->script_text = (char*)sfstr.buffer;
862
862
        return res;
863
863
}
864
864
 
1093
1093
                        com->RouteID = xmt_get_route(parser, com->unres_name, 0);
1094
1094
                        if (!com->RouteID) {
1095
1095
                                xmt_report(parser, GF_BAD_PARAM, "Cannot resolve GF_Route DEF %s", com->unres_name);
 
1096
                        } else {
 
1097
                                com->unresolved = 0;
1096
1098
                        }
1097
1099
                        gf_free(com->unres_name);
1098
1100
                        com->unres_name = NULL;
1099
 
                        com->unresolved = 0;
1100
1101
                        break;
1101
1102
                }
1102
1103
        }
1844
1845
        if (!parser->parsing_proto && (tag || proto) )
1845
1846
                gf_node_init(node);
1846
1847
 
 
1848
        /*For Ivica: load proto as soon as found when in playback mode*/
 
1849
        if ( (parser->load->flags & GF_SM_LOAD_FOR_PLAYBACK) && proto && !parser->parsing_proto) {
 
1850
                parser->last_error = gf_sg_proto_load_code(node);
 
1851
        }
1847
1852
        return node;
1848
1853
}
1849
1854
 
1852
1857
{
1853
1858
        GF_Err e;
1854
1859
        u32 i;
1855
 
        Bool fake_desc = 0;
 
1860
        u32 fake_desc = 0;
1856
1861
        GF_Descriptor *desc;
1857
1862
        char *xmt_desc_name = NULL, *ocr_ref = NULL, *dep_ref = NULL;
1858
1863
        u32 binaryID = 0;
1911
1916
                else if (!strcmp(att->name, "ES_ID")) xmt_desc_name = att->value;
1912
1917
                else if (!strcmp(att->name, "OCR_ES_ID")) ocr_ref = att->value;
1913
1918
                else if (!strcmp(att->name, "dependsOn_ES_ID")) dep_ref = att->value;
1914
 
                else {
 
1919
                else if ((desc->tag==GF_ODF_MUXINFO_TAG) && (!stricmp(att->name, "fileName") || !stricmp(att->name, "url"))) {
 
1920
                        char *res_name = gf_url_concatenate(parser->load->fileName, att->value);
 
1921
                        e = gf_odf_set_field(desc, att->name, res_name ? res_name : att->value);
 
1922
                        if (e) xmt_report(parser, e, "Warning: %s not a valid attribute for descriptor %s", att->name, name);
 
1923
                        if (res_name)
 
1924
                                gf_free(res_name);
 
1925
                } else {
1915
1926
                        e = gf_odf_set_field(desc, att->name, att->value);
1916
1927
                        if (e) xmt_report(parser, e, "Warning: %s not a valid attribute for descriptor %s", att->name, name);
1917
1928
                }
2683
2694
                        else if (!strcmp(name, "Replace") || !strcmp(name, "Insert") || !strcmp(name, "Delete") )  {
2684
2695
                                /*restore parent command if in CommandBuffer*/
2685
2696
                                if (parser->command && parser->command_buffer && parser->command_buffer->buffer) {
 
2697
                                        //empty <Insert>
 
2698
                                        if ((parser->command->tag==GF_SG_ROUTE_INSERT) && !parser->command->fromNodeID) {
 
2699
                                                gf_list_del_item(parser->command_buffer->commandList, parser->command);
 
2700
                                        }
 
2701
 
2686
2702
                                        parser->command = (GF_Command*) parser->command_buffer->buffer;
2687
2703
                                        parser->command_buffer->buffer = NULL;
2688
2704
                                        parser->command_buffer = NULL;
2689
2705
                                } else {
 
2706
                                        //empty <Insert>
 
2707
                                        if ((parser->command->tag==GF_SG_ROUTE_INSERT) && !parser->command->fromNodeID) {
 
2708
                                                gf_list_del_item(parser->scene_au->commands, parser->command);
 
2709
                                        }
2690
2710
                                        parser->command = NULL;
2691
2711
                                }
2692
2712
                        }
2866
2886
                                                gf_node_register(node, NULL);
2867
2887
                                                gf_node_unregister(node, NULL);
2868
2888
                                        } else {
2869
 
                                                gf_node_list_add_child(& gr->children, node);
2870
 
                                                gf_node_register(node, NULL);
 
2889
                                                //node has already been added to its parent with X3d parsing, because of the default container resolving
 
2890
//                                              gf_node_list_add_child(& gr->children, node);
 
2891
//                                              gf_node_register(node, NULL);
2871
2892
                                        }
2872
2893
                                }
2873
2894
                        }
2925
2946
        node = top->node;
2926
2947
 
2927
2948
        buf = text_content;
2928
 
        len = strlen(buf);
 
2949
        len = (u32) strlen(buf);
2929
2950
 
2930
2951
        if (!len) return;
2931
2952
 
3064
3085
        }
3065
3086
 
3066
3087
        e = gf_xml_sax_parse_file(parser->sax_parser, (const char *)load->fileName, xmt_progress);
 
3088
        if (e==GF_OK) e = parser->last_error;
3067
3089
 
3068
3090
        xmt_resolve_routes(parser);
3069
3091
        xmt_resolve_od_links(parser);
3082
3104
                return load_xmt_initialize(load, str);
3083
3105
        }
3084
3106
        e = gf_xml_sax_parse(parser->sax_parser, str);
 
3107
        if (e==GF_OK) e = parser->last_error;
3085
3108
 
3086
3109
        xmt_resolve_routes(parser);
3087
3110
        xmt_resolve_od_links(parser);