开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
testSAX.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：16k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

testSAX.c：源码内容
  1. /*
  2.  * tester.c : a small tester program for parsing using the SAX API.
  3.  *
  4.  * See Copyright for the status of this software.
  5.  *
  6.  * Daniel.Veillard@w3.org
  7.  */
  9. #ifdef WIN32
  10. #include "win32config.h"
  11. #else
  12. #include "config.h"
  13. #endif
  15. #include <stdio.h>
  16. #include <string.h>
  17. #include <stdarg.h>
  19. #ifdef HAVE_SYS_TYPES_H
  20. #include <sys/types.h>
  21. #endif
  22. #ifdef HAVE_SYS_STAT_H
  23. #include <sys/stat.h>
  24. #endif
  25. #ifdef HAVE_FCNTL_H
  26. #include <fcntl.h>
  27. #endif
  28. #ifdef HAVE_UNISTD_H
  29. #include <unistd.h>
  30. #endif
  31. #ifdef HAVE_STDLIB_H
  32. #include <stdlib.h>
  33. #endif
  34. #ifdef HAVE_STRING_H
  35. #include <string.h>
  36. #endif
  39. #include <libxml/parser.h>
  40. #include <libxml/parserInternals.h> /* only for xmlNewInputFromFile() */
  41. #include <libxml/tree.h>
  42. #include <libxml/debugXML.h>
  43. #include <libxml/xmlmemory.h>
  45. static int debug = 0;
  46. static int copy = 0;
  47. static int recovery = 0;
  48. static int push = 0;
  49. static int speed = 0;
  51. xmlSAXHandler emptySAXHandlerStruct = {
  52.     NULL, /* internalSubset */
  53.     NULL, /* isStandalone */
  54.     NULL, /* hasInternalSubset */
  55.     NULL, /* hasExternalSubset */
  56.     NULL, /* resolveEntity */
  57.     NULL, /* getEntity */
  58.     NULL, /* entityDecl */
  59.     NULL, /* notationDecl */
  60.     NULL, /* attributeDecl */
  61.     NULL, /* elementDecl */
  62.     NULL, /* unparsedEntityDecl */
  63.     NULL, /* setDocumentLocator */
  64.     NULL, /* startDocument */
  65.     NULL, /* endDocument */
  66.     NULL, /* startElement */
  67.     NULL, /* endElement */
  68.     NULL, /* reference */
  69.     NULL, /* characters */
  70.     NULL, /* ignorableWhitespace */
  71.     NULL, /* processingInstruction */
  72.     NULL, /* comment */
  73.     NULL, /* xmlParserWarning */
  74.     NULL, /* xmlParserError */
  75.     NULL, /* xmlParserError */
  76.     NULL, /* getParameterEntity */
  77.     NULL, /* cdataBlock; */
  78. };
  80. xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
  81. extern xmlSAXHandlerPtr debugSAXHandler;
  83. /************************************************************************
  84.  * *
  85.  * Debug Handlers *
  86.  * *
  87.  ************************************************************************/
  89. /**
  90.  * isStandaloneDebug:
  91.  * @ctxt:  An XML parser context
  92.  *
  93.  * Is this document tagged standalone ?
  94.  *
  95.  * Returns 1 if true
  96.  */
  97. int
  98. isStandaloneDebug(void *ctx)
  99. {
  100.     fprintf(stdout, "SAX.isStandalone()n");
  101.     return(0);
  102. }
  104. /**
  105.  * hasInternalSubsetDebug:
  106.  * @ctxt:  An XML parser context
  107.  *
  108.  * Does this document has an internal subset
  109.  *
  110.  * Returns 1 if true
  111.  */
  112. int
  113. hasInternalSubsetDebug(void *ctx)
  114. {
  115.     fprintf(stdout, "SAX.hasInternalSubset()n");
  116.     return(0);
  117. }
  119. /**
  120.  * hasExternalSubsetDebug:
  121.  * @ctxt:  An XML parser context
  122.  *
  123.  * Does this document has an external subset
  124.  *
  125.  * Returns 1 if true
  126.  */
  127. int
  128. hasExternalSubsetDebug(void *ctx)
  129. {
  130.     fprintf(stdout, "SAX.hasExternalSubset()n");
  131.     return(0);
  132. }
  134. /**
  135.  * hasInternalSubsetDebug:
  136.  * @ctxt:  An XML parser context
  137.  *
  138.  * Does this document has an internal subset
  139.  */
  140. void
  141. internalSubsetDebug(void *ctx, const xmlChar *name,
  142.        const xmlChar *ExternalID, const xmlChar *SystemID)
  143. {
  144.     /* xmlDtdPtr externalSubset; */
  146.     fprintf(stdout, "SAX.internalSubset(%s, %s, %s)n",
  147.             name, ExternalID, SystemID);
  149. /***********
  150.     if ((ExternalID != NULL) || (SystemID != NULL)) {
  151.         externalSubset = xmlParseDTD(ExternalID, SystemID);
  152. if (externalSubset != NULL) {
  153.     xmlFreeDtd(externalSubset);
  154. }
  155.     }
  156.  ***********/
  157. }
  159. /**
  160.  * resolveEntityDebug:
  161.  * @ctxt:  An XML parser context
  162.  * @publicId: The public ID of the entity
  163.  * @systemId: The system ID of the entity
  164.  *
  165.  * Special entity resolver, better left to the parser, it has
  166.  * more context than the application layer.
  167.  * The default behaviour is to NOT resolve the entities, in that case
  168.  * the ENTITY_REF nodes are built in the structure (and the parameter
  169.  * values).
  170.  *
  171.  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  172.  */
  173. xmlParserInputPtr
  174. resolveEntityDebug(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
  175. {
  176.     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
  178.     
  179.     fprintf(stdout, "SAX.resolveEntity(");
  180.     if (publicId != NULL)
  181. fprintf(stdout, "%s", (char *)publicId);
  182.     else
  183. fprintf(stdout, " ");
  184.     if (systemId != NULL)
  185. fprintf(stdout, ", %s)n", (char *)systemId);
  186.     else
  187. fprintf(stdout, ", )n");
  188. /*********
  189.     if (systemId != NULL) {
  190.         return(xmlNewInputFromFile(ctxt, (char *) systemId));
  191.     }
  192.  *********/
  193.     return(NULL);
  194. }
  196. /**
  197.  * getEntityDebug:
  198.  * @ctxt:  An XML parser context
  199.  * @name: The entity name
  200.  *
  201.  * Get an entity by name
  202.  *
  203.  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  204.  */
  205. xmlEntityPtr
  206. getEntityDebug(void *ctx, const xmlChar *name)
  207. {
  208.     fprintf(stdout, "SAX.getEntity(%s)n", name);
  209.     return(NULL);
  210. }
  212. /**
  213.  * getParameterEntityDebug:
  214.  * @ctxt:  An XML parser context
  215.  * @name: The entity name
  216.  *
  217.  * Get a parameter entity by name
  218.  *
  219.  * Returns the xmlParserInputPtr
  220.  */
  221. xmlEntityPtr
  222. getParameterEntityDebug(void *ctx, const xmlChar *name)
  223. {
  224.     fprintf(stdout, "SAX.getParameterEntity(%s)n", name);
  225.     return(NULL);
  226. }
  229. /**
  230.  * entityDeclDebug:
  231.  * @ctxt:  An XML parser context
  232.  * @name:  the entity name 
  233.  * @type:  the entity type 
  234.  * @publicId: The public ID of the entity
  235.  * @systemId: The system ID of the entity
  236.  * @content: the entity value (without processing).
  237.  *
  238.  * An entity definition has been parsed
  239.  */
  240. void
  241. entityDeclDebug(void *ctx, const xmlChar *name, int type,
  242.           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
  243. {
  244.     fprintf(stdout, "SAX.entityDecl(%s, %d, %s, %s, %s)n",
  245.             name, type, publicId, systemId, content);
  246. }
  248. /**
  249.  * attributeDeclDebug:
  250.  * @ctxt:  An XML parser context
  251.  * @name:  the attribute name 
  252.  * @type:  the attribute type 
  253.  *
  254.  * An attribute definition has been parsed
  255.  */
  256. void
  257. attributeDeclDebug(void *ctx, const xmlChar *elem, const xmlChar *name,
  258.               int type, int def, const xmlChar *defaultValue,
  259.       xmlEnumerationPtr tree)
  260. {
  261.     fprintf(stdout, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)n",
  262.             elem, name, type, def, defaultValue);
  263. }
  265. /**
  266.  * elementDeclDebug:
  267.  * @ctxt:  An XML parser context
  268.  * @name:  the element name 
  269.  * @type:  the element type 
  270.  * @content: the element value (without processing).
  271.  *
  272.  * An element definition has been parsed
  273.  */
  274. void
  275. elementDeclDebug(void *ctx, const xmlChar *name, int type,
  276.     xmlElementContentPtr content)
  277. {
  278.     fprintf(stdout, "SAX.elementDecl(%s, %d, ...)n",
  279.             name, type);
  280. }
  282. /**
  283.  * notationDeclDebug:
  284.  * @ctxt:  An XML parser context
  285.  * @name: The name of the notation
  286.  * @publicId: The public ID of the entity
  287.  * @systemId: The system ID of the entity
  288.  *
  289.  * What to do when a notation declaration has been parsed.
  290.  */
  291. void
  292. notationDeclDebug(void *ctx, const xmlChar *name,
  293.      const xmlChar *publicId, const xmlChar *systemId)
  294. {
  295.     fprintf(stdout, "SAX.notationDecl(%s, %s, %s)n",
  296.             (char *) name, (char *) publicId, (char *) systemId);
  297. }
  299. /**
  300.  * unparsedEntityDeclDebug:
  301.  * @ctxt:  An XML parser context
  302.  * @name: The name of the entity
  303.  * @publicId: The public ID of the entity
  304.  * @systemId: The system ID of the entity
  305.  * @notationName: the name of the notation
  306.  *
  307.  * What to do when an unparsed entity declaration is parsed
  308.  */
  309. void
  310. unparsedEntityDeclDebug(void *ctx, const xmlChar *name,
  311.    const xmlChar *publicId, const xmlChar *systemId,
  312.    const xmlChar *notationName)
  313. {
  314.     fprintf(stdout, "SAX.unparsedEntityDecl(%s, %s, %s, %s)n",
  315.             (char *) name, (char *) publicId, (char *) systemId,
  316.     (char *) notationName);
  317. }
  319. /**
  320.  * setDocumentLocatorDebug:
  321.  * @ctxt:  An XML parser context
  322.  * @loc: A SAX Locator
  323.  *
  324.  * Receive the document locator at startup, actually xmlDefaultSAXLocator
  325.  * Everything is available on the context, so this is useless in our case.
  326.  */
  327. void
  328. setDocumentLocatorDebug(void *ctx, xmlSAXLocatorPtr loc)
  329. {
  330.     fprintf(stdout, "SAX.setDocumentLocator()n");
  331. }
  333. /**
  334.  * startDocumentDebug:
  335.  * @ctxt:  An XML parser context
  336.  *
  337.  * called when the document start being processed.
  338.  */
  339. void
  340. startDocumentDebug(void *ctx)
  341. {
  342.     fprintf(stdout, "SAX.startDocument()n");
  343. }
  345. /**
  346.  * endDocumentDebug:
  347.  * @ctxt:  An XML parser context
  348.  *
  349.  * called when the document end has been detected.
  350.  */
  351. void
  352. endDocumentDebug(void *ctx)
  353. {
  354.     fprintf(stdout, "SAX.endDocument()n");
  355. }
  357. /**
  358.  * startElementDebug:
  359.  * @ctxt:  An XML parser context
  360.  * @name:  The element name
  361.  *
  362.  * called when an opening tag has been processed.
  363.  */
  364. void
  365. startElementDebug(void *ctx, const xmlChar *name, const xmlChar **atts)
  366. {
  367.     int i;
  369.     fprintf(stdout, "SAX.startElement(%s", (char *) name);
  370.     if (atts != NULL) {
  371.         for (i = 0;(atts[i] != NULL);i++) {
  372.     fprintf(stdout, ", %s='", atts[i++]);
  373.     fprintf(stdout, "%s'", atts[i]);
  374. }
  375.     }
  376.     fprintf(stdout, ")n");
  377. }
  379. /**
  380.  * endElementDebug:
  381.  * @ctxt:  An XML parser context
  382.  * @name:  The element name
  383.  *
  384.  * called when the end of an element has been detected.
  385.  */
  386. void
  387. endElementDebug(void *ctx, const xmlChar *name)
  388. {
  389.     fprintf(stdout, "SAX.endElement(%s)n", (char *) name);
  390. }
  392. /**
  393.  * charactersDebug:
  394.  * @ctxt:  An XML parser context
  395.  * @ch:  a xmlChar string
  396.  * @len: the number of xmlChar
  397.  *
  398.  * receiving some chars from the parser.
  399.  * Question: how much at a time ???
  400.  */
  401. void
  402. charactersDebug(void *ctx, const xmlChar *ch, int len)
  403. {
  404.     int i;
  406.     fprintf(stdout, "SAX.characters(");
  407.     for (i = 0;(i < len) && (i < 30);i++)
  408. fprintf(stdout, "%c", ch[i]);
  409.     fprintf(stdout, ", %d)n", len);
  410. }
  412. /**
  413.  * referenceDebug:
  414.  * @ctxt:  An XML parser context
  415.  * @name:  The entity name
  416.  *
  417.  * called when an entity reference is detected. 
  418.  */
  419. void
  420. referenceDebug(void *ctx, const xmlChar *name)
  421. {
  422.     fprintf(stdout, "SAX.reference(%s)n", name);
  423. }
  425. /**
  426.  * ignorableWhitespaceDebug:
  427.  * @ctxt:  An XML parser context
  428.  * @ch:  a xmlChar string
  429.  * @start: the first char in the string
  430.  * @len: the number of xmlChar
  431.  *
  432.  * receiving some ignorable whitespaces from the parser.
  433.  * Question: how much at a time ???
  434.  */
  435. void
  436. ignorableWhitespaceDebug(void *ctx, const xmlChar *ch, int len)
  437. {
  438.     fprintf(stdout, "SAX.ignorableWhitespace(%.30s, %d)n",
  439.             (char *) ch, len);
  440. }
  442. /**
  443.  * processingInstructionDebug:
  444.  * @ctxt:  An XML parser context
  445.  * @target:  the target name
  446.  * @data: the PI data's
  447.  * @len: the number of xmlChar
  448.  *
  449.  * A processing instruction has been parsed.
  450.  */
  451. void
  452. processingInstructionDebug(void *ctx, const xmlChar *target,
  453.                       const xmlChar *data)
  454. {
  455.     fprintf(stdout, "SAX.processingInstruction(%s, %s)n",
  456.             (char *) target, (char *) data);
  457. }
  459. /**
  460.  * cdataBlockDebug:
  461.  * @ctx: the user data (XML parser context)
  462.  * @value:  The pcdata content
  463.  * @len:  the block length
  464.  *
  465.  * called when a pcdata block has been parsed
  466.  */
  467. void
  468. cdataBlockDebug(void *ctx, const xmlChar *value, int len)
  469. {
  470.     fprintf(stderr, "SAX.pcdata(%.20s, %d)n",
  471.     (char *) value, len);
  472. }
  474. /**
  475.  * commentDebug:
  476.  * @ctxt:  An XML parser context
  477.  * @value:  the comment content
  478.  *
  479.  * A comment has been parsed.
  480.  */
  481. void
  482. commentDebug(void *ctx, const xmlChar *value)
  483. {
  484.     fprintf(stdout, "SAX.comment(%s)n", value);
  485. }
  487. /**
  488.  * warningDebug:
  489.  * @ctxt:  An XML parser context
  490.  * @msg:  the message to display/transmit
  491.  * @...:  extra parameters for the message display
  492.  *
  493.  * Display and format a warning messages, gives file, line, position and
  494.  * extra parameters.
  495.  */
  496. void
  497. warningDebug(void *ctx, const char *msg, ...)
  498. {
  499.     va_list args;
  501.     va_start(args, msg);
  502.     fprintf(stdout, "SAX.warning: ");
  503.     vfprintf(stdout, msg, args);
  504.     va_end(args);
  505. }
  507. /**
  508.  * errorDebug:
  509.  * @ctxt:  An XML parser context
  510.  * @msg:  the message to display/transmit
  511.  * @...:  extra parameters for the message display
  512.  *
  513.  * Display and format a error messages, gives file, line, position and
  514.  * extra parameters.
  515.  */
  516. void
  517. errorDebug(void *ctx, const char *msg, ...)
  518. {
  519.     va_list args;
  521.     va_start(args, msg);
  522.     fprintf(stdout, "SAX.error: ");
  523.     vfprintf(stdout, msg, args);
  524.     va_end(args);
  525. }
  527. /**
  528.  * fatalErrorDebug:
  529.  * @ctxt:  An XML parser context
  530.  * @msg:  the message to display/transmit
  531.  * @...:  extra parameters for the message display
  532.  *
  533.  * Display and format a fatalError messages, gives file, line, position and
  534.  * extra parameters.
  535.  */
  536. void
  537. fatalErrorDebug(void *ctx, const char *msg, ...)
  538. {
  539.     va_list args;
  541.     va_start(args, msg);
  542.     fprintf(stdout, "SAX.fatalError: ");
  543.     vfprintf(stdout, msg, args);
  544.     va_end(args);
  545. }
  547. xmlSAXHandler debugSAXHandlerStruct = {
  548.     internalSubsetDebug,
  549.     isStandaloneDebug,
  550.     hasInternalSubsetDebug,
  551.     hasExternalSubsetDebug,
  552.     resolveEntityDebug,
  553.     getEntityDebug,
  554.     entityDeclDebug,
  555.     notationDeclDebug,
  556.     attributeDeclDebug,
  557.     elementDeclDebug,
  558.     unparsedEntityDeclDebug,
  559.     setDocumentLocatorDebug,
  560.     startDocumentDebug,
  561.     endDocumentDebug,
  562.     startElementDebug,
  563.     endElementDebug,
  564.     referenceDebug,
  565.     charactersDebug,
  566.     ignorableWhitespaceDebug,
  567.     processingInstructionDebug,
  568.     commentDebug,
  569.     warningDebug,
  570.     errorDebug,
  571.     fatalErrorDebug,
  572.     getParameterEntityDebug,
  573.     cdataBlockDebug
  574. };
  576. xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
  578. /************************************************************************
  579.  * *
  580.  * Debug *
  581.  * *
  582.  ************************************************************************/
  584. void parseAndPrintFile(char *filename) {
  585.     int res;
  587.     if (push) {
  588. FILE *f;
  590. /*
  591.  * Empty callbacks for checking
  592.  */
  593. f = fopen(filename, "r");
  594. if (f != NULL) {
  595.     int res;
  596.     char chars[10];
  597.     xmlParserCtxtPtr ctxt;
  599.     res = fread(chars, 1, 4, f);
  600.     if (res > 0) {
  601. ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
  602.     chars, res, filename);
  603. while ((res = fread(chars, 1, 3, f)) > 0) {
  604.     xmlParseChunk(ctxt, chars, res, 0);
  605. }
  606. xmlParseChunk(ctxt, chars, 0, 1);
  607. xmlFreeParserCtxt(ctxt);
  608.     }
  609.     fclose(f);
  610. } else {
  611.     fprintf(stderr, "Cannot read file %sn", filename);
  612. }
  613. /*
  614.  * Debug callback
  615.  */
  616. f = fopen(filename, "r");
  617. if (f != NULL) {
  618.     int res;
  619.     char chars[10];
  620.     xmlParserCtxtPtr ctxt;
  622.     res = fread(chars, 1, 4, f);
  623.     if (res > 0) {
  624. ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
  625.     chars, res, filename);
  626. while ((res = fread(chars, 1, 3, f)) > 0) {
  627.     xmlParseChunk(ctxt, chars, res, 0);
  628. }
  629. res = xmlParseChunk(ctxt, chars, 0, 1);
  630. xmlFreeParserCtxt(ctxt);
  631. if (res != 0) {
  632.     fprintf(stdout,
  633.             "xmlSAXUserParseFile returned error %dn", res);
  634. }
  635.     }
  636.     fclose(f);
  637. }
  638.     } else {
  639. if (!speed) {
  640.     /*
  641.      * Empty callbacks for checking
  642.      */
  643.     res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
  644.     if (res != 0) {
  645. fprintf(stdout, "xmlSAXUserParseFile returned error %dn", res);
  646.     }
  648.     /*
  649.      * Debug callback
  650.      */
  651.     res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
  652.     if (res != 0) {
  653. fprintf(stdout, "xmlSAXUserParseFile returned error %dn", res);
  654.     }
  655. } else {
  656.     /*
  657.      * test 100x the SAX parse
  658.      */
  659.     int i;
  661.     for (i = 0; i<100;i++)
  662. res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
  663.     if (res != 0) {
  664. fprintf(stdout, "xmlSAXUserParseFile returned error %dn", res);
  665.     }
  666. }
  667.     }
  668. }
  671. int main(int argc, char **argv) {
  672.     int i;
  673.     int files = 0;
  675.     for (i = 1; i < argc ; i++) {
  676. if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
  677.     debug++;
  678. else if ((!strcmp(argv[i], "-copy")) || (!strcmp(argv[i], "--copy")))
  679.     copy++;
  680. else if ((!strcmp(argv[i], "-recover")) ||
  681.          (!strcmp(argv[i], "--recover")))
  682.     recovery++;
  683. else if ((!strcmp(argv[i], "-push")) ||
  684.          (!strcmp(argv[i], "--push")))
  685.     push++;
  686. else if ((!strcmp(argv[i], "-speed")) ||
  687.          (!strcmp(argv[i], "--speed")))
  688.     speed++;
  689.     }
  690.     for (i = 1; i < argc ; i++) {
  691. if (argv[i][0] != '-') {
  692.     parseAndPrintFile(argv[i]);
  693.     files ++;
  694. }
  695.     }
  696.     xmlCleanupParser();
  697.     xmlMemoryDump();
  699.     return(0);
  700. }