/src/3rdparty/libmng/libmng_hlapi.c

https://bitbucket.org/ultra_iter/qt-vtl · C · 3001 lines · 2259 code · 420 blank · 322 comment · 207 complexity · 9a8a578c20fc316cbfe619debea91761 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /* ************************************************************************** */
    2. 

  2. /* *             For conditions of distribution and use,                    * */
    3. 

  3. /* *                see copyright notice in libmng.h                        * */
    4. 

  4. /* ************************************************************************** */
    5. 

  5. /* *                                                                        * */
    6. 

  6. /* * project   : libmng                                                     * */
    7. 

  7. /* * file      : libmng_hlapi.c            copyright (c) 2000-2007 G.Juyn   * */
    8. 

  8. /* * version   : 1.0.10                                                     * */
    9. 

  9. /* *                                                                        * */
    10. 

  10. /* * purpose   : high-level application API (implementation)                * */
    11. 

  11. /* *                                                                        * */
    12. 

  12. /* * author    : G.Juyn                                                     * */
    13. 

  13. /* *                                                                        * */
    14. 

  14. /* * comment   : implementation of the high-level function interface        * */
    15. 

  15. /* *             for applications.                                          * */
    16. 

  16. /* *                                                                        * */
    17. 

  17. /* * changes   : 0.5.1 - 05/06/2000 - G.Juyn                                * */
    18. 

  18. /* *             - added init of iPLTEcount                                 * */
    19. 

  19. /* *             0.5.1 - 05/08/2000 - G.Juyn                                * */
    20. 

  20. /* *             - changed calling-convention definition                    * */
    21. 

  21. /* *             - changed status-handling of display-routines              * */
    22. 

  22. /* *             - added versioning-control routines                        * */
    23. 

  23. /* *             - filled the write routine                                 * */
    24. 

  24. /* *             - changed strict-ANSI stuff                                * */
    25. 

  25. /* *             0.5.1 - 05/11/2000 - G.Juyn                                * */
    26. 

  26. /* *             - added callback error-reporting support                   * */
    27. 

  27. /* *             0.5.1 - 05/12/2000 - G.Juyn                                * */
    28. 

  28. /* *             - changed trace to macro for callback error-reporting      * */
    29. 

  29. /* *             0.5.1 - 05/13/2000 - G.Juyn                                * */
    30. 

  30. /* *             - added eMNGma hack (will be removed in 1.0.0 !!!)         * */
    31. 

  31. /* *             - added TERM animation object pointer (easier reference)   * */
    32. 

  32. /* *             0.5.1 - 05/14/2000 - G.Juyn                                * */
    33. 

  33. /* *             - added cleanup of saved-data (SAVE/SEEK processing)       * */
    34. 

  34. /* *             0.5.1 - 05/16/2000 - G.Juyn                                * */
    35. 

  35. /* *             - moved the actual write_graphic functionality from here   * */
    36. 

  36. /* *               to its appropriate function in the mng_write module      * */
    37. 

  37. /* *                                                                        * */
    38. 

  38. /* *             0.5.2 - 05/19/2000 - G.Juyn                                * */
    39. 

  39. /* *             - cleaned up some code regarding mixed support             * */
    40. 

  40. /* *             - added JNG support                                        * */
    41. 

  41. /* *             0.5.2 - 05/24/2000 - G.Juyn                                * */
    42. 

  42. /* *             - moved init of default zlib parms here from "mng_zlib.c"  * */
    43. 

  43. /* *             - added init of default IJG parms                          * */
    44. 

  44. /* *             0.5.2 - 05/29/2000 - G.Juyn                                * */
    45. 

  45. /* *             - fixed inconsistancy with freeing global iCCP profile     * */
    46. 

  46. /* *             0.5.2 - 05/30/2000 - G.Juyn                                * */
    47. 

  47. /* *             - added delta-image field initialization                   * */
    48. 

  48. /* *             0.5.2 - 06/06/2000 - G.Juyn                                * */
    49. 

  49. /* *             - added initialization of the buffer-suspend parameter     * */
    50. 

  50. /* *                                                                        * */
    51. 

  51. /* *             0.5.3 - 06/16/2000 - G.Juyn                                * */
    52. 

  52. /* *             - added initialization of update-region for refresh        * */
    53. 

  53. /* *             - added initialization of Needrefresh parameter            * */
    54. 

  54. /* *             0.5.3 - 06/17/2000 - G.Juyn                                * */
    55. 

  55. /* *             - added initialization of Deltaimmediate                   * */
    56. 

  56. /* *             0.5.3 - 06/21/2000 - G.Juyn                                * */
    57. 

  57. /* *             - added initialization of Speed                            * */
    58. 

  58. /* *             - added initialization of Imagelevel                       * */
    59. 

  59. /* *             0.5.3 - 06/26/2000 - G.Juyn                                * */
    60. 

  60. /* *             - changed userdata variable to mng_ptr                     * */
    61. 

  61. /* *             0.5.3 - 06/29/2000 - G.Juyn                                * */
    62. 

  62. /* *             - fixed initialization routine for new mng_handle type     * */
    63. 

  63. /* *                                                                        * */
    64. 

  64. /* *             0.9.1 - 07/06/2000 - G.Juyn                                * */
    65. 

  65. /* *             - changed mng_display_resume to allow to be called after   * */
    66. 

  66. /* *               a suspension return with MNG_NEEDMOREDATA                * */
    67. 

  67. /* *             - added returncode MNG_NEEDTIMERWAIT for timer breaks      * */
    68. 

  68. /* *             0.9.1 - 07/07/2000 - G.Juyn                                * */
    69. 

  69. /* *             - implemented support for freeze/reset/resume & go_xxxx    * */
    70. 

  70. /* *             0.9.1 - 07/08/2000 - G.Juyn                                * */
    71. 

  71. /* *             - added support for improved timing                        * */
    72. 

  72. /* *             - added support for improved I/O-suspension                * */
    73. 

  73. /* *             0.9.1 - 07/14/2000 - G.Juyn                                * */
    74. 

  74. /* *             - changed EOF processing behavior                          * */
    75. 

  75. /* *             0.9.1 - 07/15/2000 - G.Juyn                                * */
    76. 

  76. /* *             - added callbacks for SAVE/SEEK processing                 * */
    77. 

  77. /* *             - added variable for NEEDSECTIONWAIT breaks                * */
    78. 

  78. /* *             - added variable for freeze & reset processing             * */
    79. 

  79. /* *             0.9.1 - 07/17/2000 - G.Juyn                                * */
    80. 

  80. /* *             - added error cleanup processing                           * */
    81. 

  81. /* *             - fixed support for mng_display_reset()                    * */
    82. 

  82. /* *             - fixed suspension-buffering for 32K+ chunks               * */
    83. 

  83. /* *                                                                        * */
    84. 

  84. /* *             0.9.2 - 07/29/2000 - G.Juyn                                * */
    85. 

  85. /* *             - fixed small bugs in display processing                   * */
    86. 

  86. /* *             0.9.2 - 07/31/2000 - G.Juyn                                * */
    87. 

  87. /* *             - fixed wrapping of suspension parameters                  * */
    88. 

  88. /* *             0.9.2 - 08/04/2000 - G.Juyn                                * */
    89. 

  89. /* *             - B111096 - fixed large-buffer read-suspension             * */
    90. 

  90. /* *             0.9.2 - 08/05/2000 - G.Juyn                                * */
    91. 

  91. /* *             - changed file-prefixes                                    * */
    92. 

  92. /* *                                                                        * */
    93. 

  93. /* *             0.9.3 - 09/07/2000 - G.Juyn                                * */
    94. 

  94. /* *             - added support for new filter_types                       * */
    95. 

  95. /* *             0.9.3 - 09/10/2000 - G.Juyn                                * */
    96. 

  96. /* *             - fixed DEFI behavior                                      * */
    97. 

  97. /* *             0.9.3 - 10/11/2000 - G.Juyn                                * */
    98. 

  98. /* *             - added support for nEED                                   * */
    99. 

  99. /* *             0.9.3 - 10/16/2000 - G.Juyn                                * */
    100. 

  100. /* *             - added optional support for bKGD for PNG images           * */
    101. 

  101. /* *             - raised initial maximum canvas size                       * */
    102. 

  102. /* *             - added support for JDAA                                   * */
    103. 

  103. /* *             0.9.3 - 10/17/2000 - G.Juyn                                * */
    104. 

  104. /* *             - added callback to process non-critical unknown chunks    * */
    105. 

  105. /* *             - fixed support for delta-images during read() / display() * */
    106. 

  106. /* *             0.9.3 - 10/18/2000 - G.Juyn                                * */
    107. 

  107. /* *             - added closestream() processing for mng_cleanup()         * */
    108. 

  108. /* *             0.9.3 - 10/27/2000 - G.Juyn                                * */
    109. 

  109. /* *             - fixed separate read() & display() processing             * */
    110. 

  110. /* *                                                                        * */
    111. 

  111. /* *             0.9.4 - 11/20/2000 - G.Juyn                                * */
    112. 

  112. /* *             - fixed unwanted repetition in mng_readdisplay()           * */
    113. 

  113. /* *             0.9.4 - 11/24/2000 - G.Juyn                                * */
    114. 

  114. /* *             - moved restore of object 0 to libmng_display              * */
    115. 

  115. /* *                                                                        * */
    116. 

  116. /* *             1.0.1 - 02/08/2001 - G.Juyn                                * */
    117. 

  117. /* *             - added MEND processing callback                           * */
    118. 

  118. /* *             1.0.1 - 02/13/2001 - G.Juyn                                * */
    119. 

  119. /* *             - fixed first FRAM_MODE=4 timing problem                   * */
    120. 

  120. /* *             1.0.1 - 04/21/2001 - G.Juyn                                * */
    121. 

  121. /* *             - fixed bug with display_reset/display_resume (Thanks G!)  * */
    122. 

  122. /* *             1.0.1 - 04/22/2001 - G.Juyn                                * */
    123. 

  123. /* *             - fixed memory-leak (Thanks Gregg!)                        * */
    124. 

  124. /* *             1.0.1 - 04/23/2001 - G.Juyn                                * */
    125. 

  125. /* *             - fixed reset_rundata to drop all objects                  * */
    126. 

  126. /* *             1.0.1 - 04/25/2001 - G.Juyn                                * */
    127. 

  127. /* *             - moved mng_clear_cms to libmng_cms                        * */
    128. 

  128. /* *                                                                        * */
    129. 

  129. /* *             1.0.2 - 06/23/2001 - G.Juyn                                * */
    130. 

  130. /* *             - added optimization option for MNG-video playback         * */
    131. 

  131. /* *             - added processterm callback                               * */
    132. 

  132. /* *             1.0.2 - 06/25/2001 - G.Juyn                                * */
    133. 

  133. /* *             - added option to turn off progressive refresh             * */
    134. 

  134. /* *                                                                        * */
    135. 

  135. /* *             1.0.5 - 07/08/2002 - G.Juyn                                * */
    136. 

  136. /* *             - B578572 - removed eMNGma hack (thanks Dimitri!)          * */
    137. 

  137. /* *             1.0.5 - 07/16/2002 - G.Juyn                                * */
    138. 

  138. /* *             - B581625 - large chunks fail with suspension reads        * */
    139. 

  139. /* *             1.0.5 - 08/19/2002 - G.Juyn                                * */
    140. 

  140. /* *             - B597134 - libmng pollutes the linker namespace           * */
    141. 

  141. /* *             1.0.5 - 09/15/2002 - G.Juyn                                * */
    142. 

  142. /* *             - fixed LOOP iteration=0 special case                      * */
    143. 

  143. /* *             1.0.5 - 10/07/2002 - G.Juyn                                * */
    144. 

  144. /* *             - added another fix for misplaced TERM chunk               * */
    145. 

  145. /* *             - completed support for condition=2 in TERM chunk          * */
    146. 

  146. /* *             - added beta version function & constant                   * */
    147. 

  147. /* *             1.0.5 - 10/11/2002 - G.Juyn                                * */
    148. 

  148. /* *             - added mng_status_dynamic to supports function            * */
    149. 

  149. /* *             1.0.5 - 11/04/2002 - G.Juyn                                * */
    150. 

  150. /* *             - changed FRAMECOUNT/LAYERCOUNT/PLAYTIME error to warning  * */
    151. 

  151. /* *             1.0.5 - 11/07/2002 - G.Juyn                                * */
    152. 

  152. /* *             - added support to get totals after mng_read()             * */
    153. 

  153. /* *             1.0.5 - 11/29/2002 - G.Juyn                                * */
    154. 

  154. /* *             - fixed goxxxxx() support for zero values                  * */
    155. 

  155. /* *                                                                        * */
    156. 

  156. /* *             1.0.6 - 05/25/2003 - G.R-P                                 * */
    157. 

  157. /* *             - added MNG_SKIPCHUNK_cHNK footprint optimizations         * */
    158. 

  158. /* *             1.0.6 - 07/11/2003 - G.R-P                                 * */
    159. 

  159. /* *             - added conditionals zlib and jpeg property accessors      * */
    160. 

  160. /* *             1.0.6 - 07/14/2003 - G.R-P                                 * */
    161. 

  161. /* *             - added conditionals around "mng_display_go*" and other    * */
    162. 

  162. /* *               unused functions                                         * */
    163. 

  163. /* *             1.0.6 - 07/29/2003 - G.R-P                                 * */
    164. 

  164. /* *             - added conditionals around PAST chunk support             * */
    165. 

  165. /* *                                                                        * */
    166. 

  166. /* *             1.0.7 - 03/07/2004 - G. Randers-Pehrson                    * */
    167. 

  167. /* *             - put gamma, cms-related declarations inside #ifdef        * */
    168. 

  168. /* *             1.0.7 - 03/10/2004 - G.R-P                                 * */
    169. 

  169. /* *             - added conditionals around openstream/closestream         * */
    170. 

  170. /* *             1.0.7 - 03/24/2004 - G.R-P                                 * */
    171. 

  171. /* *             - fixed zTXT -> zTXt typo                                  * */
    172. 

  172. /* *                                                                        * */
    173. 

  173. /* *             1.0.8 - 04/02/2004 - G.Juyn                                * */
    174. 

  174. /* *             - added CRC existence & checking flags                     * */
    175. 

  175. /* *             1.0.8 - 04/10/2004 - G.Juyn                                * */
    176. 

  176. /* *             - added data-push mechanisms for specialized decoders      * */
    177. 

  177. /* *             1.0.8 - 07/06/2004 - G.R-P                                 * */
    178. 

  178. /* *             - defend against using undefined openstream function       * */
    179. 

  179. /* *             1.0.8 - 08/02/2004 - G.Juyn                                * */
    180. 

  180. /* *             - added conditional to allow easier writing of large MNG's * */
    181. 

  181. /* *                                                                        * */
    182. 

  182. /* *             1.0.9 - 08/17/2004 - G.R-P                                 * */
    183. 

  183. /* *             - added more SKIPCHUNK conditionals                        * */
    184. 

  184. /* *             1.0.9 - 09/25/2004 - G.Juyn                                * */
    185. 

  185. /* *             - replaced MNG_TWEAK_LARGE_FILES with permanent solution   * */
    186. 

  186. /* *             1.0.9 - 10/03/2004 - G.Juyn                                * */
    187. 

  187. /* *             - added function to retrieve current FRAM delay            * */
    188. 

  188. /* *             1.0.9 - 12/20/2004 - G.Juyn                                * */
    189. 

  189. /* *             - cleaned up macro-invocations (thanks to D. Airlie)       * */
    190. 

  190. /* *                                                                        * */
    191. 

  191. /* *             1.0.10 - 07/06/2005 - G.R-P                                * */
    192. 

  192. /* *             - added more SKIPCHUNK conditionals                        * */
    193. 

  193. /* *             1.0.10 - 04/08/2007 - G.Juyn                               * */
    194. 

  194. /* *             - added support for mPNG proposal                          * */
    195. 

  195. /* *             1.0.10 - 04/12/2007 - G.Juyn                               * */
    196. 

  196. /* *             - added support for ANG proposal                           * */
    197. 

  197. /* *             1.0.10 - 07/06/2007 - G.R-P bugfix by Lucas Quintana       * */
    198. 

  198. /* *                                                                        * */
    199. 

  199. /* ************************************************************************** */
    200. 

  200. 

  201. #include "libmng.h"
    202. 

  202. #include "libmng_data.h"
    203. 

  203. #include "libmng_error.h"
    204. 

  204. #include "libmng_trace.h"
    205. 

  205. #ifdef __BORLANDC__
    206. 

  206. #pragma hdrstop
    207. 

  207. #endif
    208. 

  208. #include "libmng_objects.h"
    209. 

  209. #include "libmng_object_prc.h"
    210. 

  210. #include "libmng_chunks.h"
    211. 

  211. #include "libmng_memory.h"
    212. 

  212. #include "libmng_read.h"
    213. 

  213. #include "libmng_write.h"
    214. 

  214. #include "libmng_display.h"
    215. 

  215. #include "libmng_zlib.h"
    216. 

  216. #include "libmng_jpeg.h"
    217. 

  217. #include "libmng_cms.h"
    218. 

  218. #include "libmng_pixels.h"
    219. 

  219. 

  220. #if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
    221. 

  221. #pragma option -A                      /* force ANSI-C */
    222. 

  222. #endif
    223. 

  223. 

  224. /* ************************************************************************** */
    225. 

  225. /* *                                                                        * */
    226. 

  226. /* * local routines                                                         * */
    227. 

  227. /* *                                                                        * */
    228. 

  228. /* ************************************************************************** */
    229. 

  229. 

  230. #ifdef MNG_SUPPORT_DISPLAY
    231. 

  231. MNG_LOCAL mng_retcode mng_drop_objects (mng_datap pData,
    232. 

  232.                                         mng_bool  bDropaniobj)
    233. 

  233. {
    234. 

  234.   mng_objectp       pObject;
    235. 

  235.   mng_objectp       pNext;
    236. 

  236.   mng_cleanupobject fCleanup;
    237. 

  237. 

  238. #ifdef MNG_SUPPORT_TRACE
    239. 

  239.   MNG_TRACE (pData, MNG_FN_DROP_OBJECTS, MNG_LC_START);
    240. 

  240. #endif
    241. 

  241. 

  242.   pObject = pData->pFirstimgobj;       /* get first stored image-object (if any) */
    243. 

  243. 

  244.   while (pObject)                      /* more objects to discard ? */
    245. 

  245.   {
    246. 

  246.     pNext = ((mng_object_headerp)pObject)->pNext;
    247. 

  247.                                        /* call appropriate cleanup */
    248. 

  248.     fCleanup = ((mng_object_headerp)pObject)->fCleanup;
    249. 

  249.     fCleanup (pData, pObject);
    250. 

  250. 

  251.     pObject = pNext;                   /* neeeext */
    252. 

  252.   }
    253. 

  253. 

  254.   pData->pFirstimgobj = MNG_NULL;      /* clean this up!!! */
    255. 

  255.   pData->pLastimgobj  = MNG_NULL;
    256. 

  256. 

  257.   if (bDropaniobj)                     /* drop animation objects ? */
    258. 

  258.   {
    259. 

  259.     pObject = pData->pFirstaniobj;     /* get first stored animation-object (if any) */
    260. 

  260. 

  261.     while (pObject)                    /* more objects to discard ? */
    262. 

  262.     {
    263. 

  263.       pNext = ((mng_object_headerp)pObject)->pNext;
    264. 

  264.                                        /* call appropriate cleanup */
    265. 

  265.       fCleanup = ((mng_object_headerp)pObject)->fCleanup;
    266. 

  266.       fCleanup (pData, pObject);
    267. 

  267. 

  268.       pObject = pNext;                 /* neeeext */
    269. 

  269.     }
    270. 

  270. 

  271.     pData->pFirstaniobj = MNG_NULL;    /* clean this up!!! */
    272. 

  272.     pData->pLastaniobj  = MNG_NULL;
    273. 

  273. 

  274. #ifdef MNG_SUPPORT_DYNAMICMNG
    275. 

  275.     pObject = pData->pFirstevent;      /* get first event-object (if any) */
    276. 

  276. 

  277.     while (pObject)                    /* more objects to discard ? */
    278. 

  278.     {
    279. 

  279.       pNext = ((mng_object_headerp)pObject)->pNext;
    280. 

  280.                                        /* call appropriate cleanup */
    281. 

  281.       fCleanup = ((mng_object_headerp)pObject)->fCleanup;
    282. 

  282.       fCleanup (pData, pObject);
    283. 

  283. 

  284.       pObject = pNext;                 /* neeeext */
    285. 

  285.     }
    286. 

  286. 

  287.     pData->pFirstevent = MNG_NULL;     /* clean this up!!! */
    288. 

  288.     pData->pLastevent  = MNG_NULL;
    289. 

  289. #endif
    290. 

  290.   }
    291. 

  291. 

  292. #ifdef MNG_INCLUDE_MPNG_PROPOSAL
    293. 

  293.   if (pData->pMPNG)                    /* drop MPNG data (if any) */
    294. 

  294.   {
    295. 

  295.     fCleanup = ((mng_object_headerp)pData->pMPNG)->fCleanup;
    296. 

  296.     fCleanup (pData, pData->pMPNG);
    297. 

  297.     pData->pMPNG = MNG_NULL;
    298. 

  298.   }
    299. 

  299. #endif
    300. 

  300. 

  301. #ifdef MNG_INCLUDE_ANG_PROPOSAL
    302. 

  302.   if (pData->pANG)                     /* drop ANG data (if any) */
    303. 

  303.   {
    304. 

  304.     fCleanup = ((mng_object_headerp)pData->pANG)->fCleanup;
    305. 

  305.     fCleanup (pData, pData->pANG);
    306. 

  306.     pData->pANG = MNG_NULL;
    307. 

  307.   }
    308. 

  308. #endif
    309. 

  309. 

  310. #ifdef MNG_SUPPORT_TRACE
    311. 

  311.   MNG_TRACE (pData, MNG_FN_DROP_OBJECTS, MNG_LC_END);
    312. 

  312. #endif
    313. 

  313. 

  314.   return MNG_NOERROR;
    315. 

  315. }
    316. 

  316. #endif /* MNG_SUPPORT_DISPLAY */
    317. 

  317. 

  318. /* ************************************************************************** */
    319. 

  319. 

  320. #ifdef MNG_SUPPORT_DISPLAY
    321. 

  321. #ifndef MNG_SKIPCHUNK_SAVE
    322. 

  322. MNG_LOCAL mng_retcode mng_drop_savedata (mng_datap pData)
    323. 

  323. {
    324. 

  324. #ifdef MNG_SUPPORT_TRACE
    325. 

  325.   MNG_TRACE (pData, MNG_FN_DROP_SAVEDATA, MNG_LC_START);
    326. 

  326. #endif
    327. 

  327. 

  328.   if (pData->pSavedata)                /* sanity check */
    329. 

  329.   {                                    /* address it more directly */
    330. 

  330.     mng_savedatap pSave = pData->pSavedata;
    331. 

  331. 

  332.     if (pSave->iGlobalProfilesize)     /* cleanup the profile ? */
    333. 

  333.       MNG_FREEX (pData, pSave->pGlobalProfile, pSave->iGlobalProfilesize);
    334. 

  334.                                        /* cleanup the save structure */
    335. 

  335.     MNG_FREE (pData, pData->pSavedata, sizeof (mng_savedata));
    336. 

  336.   }
    337. 

  337. 

  338. #ifdef MNG_SUPPORT_TRACE
    339. 

  339.   MNG_TRACE (pData, MNG_FN_DROP_SAVEDATA, MNG_LC_END);
    340. 

  340. #endif
    341. 

  341. 

  342.   return MNG_NOERROR;
    343. 

  343. }
    344. 

  344. #endif
    345. 

  345. #endif /* MNG_SUPPORT_DISPLAY */
    346. 

  346. 

  347. /* ************************************************************************** */
    348. 

  348. 

  349. #ifdef MNG_SUPPORT_DISPLAY
    350. 

  350. MNG_LOCAL mng_retcode mng_reset_rundata (mng_datap pData)
    351. 

  351. {
    352. 

  352.   mng_drop_invalid_objects (pData);    /* drop invalidly stored objects */
    353. 

  353. #ifndef MNG_SKIPCHUNK_SAVE
    354. 

  354.   mng_drop_savedata        (pData);    /* drop stored savedata */
    355. 

  355. #endif
    356. 

  356.   mng_reset_objzero        (pData);    /* reset object 0 */
    357. 

  357.                                        /* drop stored objects (if any) */
    358. 

  358.   mng_drop_objects         (pData, MNG_FALSE);
    359. 

  359. 

  360.   pData->bFramedone            = MNG_FALSE;
    361. 

  361.   pData->iFrameseq             = 0;    /* reset counters & stuff */
    362. 

  362.   pData->iLayerseq             = 0;
    363. 

  363.   pData->iFrametime            = 0;
    364. 

  364. 

  365.   pData->bSkipping             = MNG_FALSE;
    366. 

  366. 

  367. #ifdef MNG_SUPPORT_DYNAMICMNG
    368. 

  368.   pData->bRunningevent         = MNG_FALSE;
    369. 

  369.   pData->bStopafterseek        = MNG_FALSE;
    370. 

  370.   pData->iEventx               = 0;
    371. 

  371.   pData->iEventy               = 0;
    372. 

  372.   pData->pLastmousemove        = MNG_NULL;
    373. 

  373. #endif
    374. 

  374. 

  375.   pData->iRequestframe         = 0;
    376. 

  376.   pData->iRequestlayer         = 0;
    377. 

  377.   pData->iRequesttime          = 0;
    378. 

  378.   pData->bSearching            = MNG_FALSE;
    379. 

  379. 

  380.   pData->iRuntime              = 0;
    381. 

  381.   pData->iSynctime             = 0;
    382. 

  382.   pData->iStarttime            = 0;
    383. 

  383.   pData->iEndtime              = 0;
    384. 

  384.   pData->bRunning              = MNG_FALSE;
    385. 

  385.   pData->bTimerset             = MNG_FALSE;
    386. 

  386.   pData->iBreakpoint           = 0;
    387. 

  387.   pData->bSectionwait          = MNG_FALSE;
    388. 

  388.   pData->bFreezing             = MNG_FALSE;
    389. 

  389.   pData->bResetting            = MNG_FALSE;
    390. 

  390.   pData->bNeedrefresh          = MNG_FALSE;
    391. 

  391.   pData->bOnlyfirstframe       = MNG_FALSE;
    392. 

  392.   pData->iFramesafterTERM      = 0;
    393. 

  393. 

  394.   pData->iIterations           = 0;
    395. 

  395.                                        /* start of animation objects! */
    396. 

  396.   pData->pCurraniobj           = MNG_NULL;
    397. 

  397. 

  398.   pData->iUpdateleft           = 0;    /* reset region */
    399. 

  399.   pData->iUpdateright          = 0;
    400. 

  400.   pData->iUpdatetop            = 0;
    401. 

  401.   pData->iUpdatebottom         = 0;
    402. 

  402.   pData->iPLTEcount            = 0;    /* reset PLTE data */
    403. 

  403. 

  404. #ifndef MNG_SKIPCHUNK_DEFI
    405. 

  405.   pData->iDEFIobjectid         = 0;    /* reset DEFI data */
    406. 

  406.   pData->bDEFIhasdonotshow     = MNG_FALSE;
    407. 

  407.   pData->iDEFIdonotshow        = 0;
    408. 

  408.   pData->bDEFIhasconcrete      = MNG_FALSE;
    409. 

  409.   pData->iDEFIconcrete         = 0;
    410. 

  410.   pData->bDEFIhasloca          = MNG_FALSE;
    411. 

  411.   pData->iDEFIlocax            = 0;
    412. 

  412.   pData->iDEFIlocay            = 0;
    413. 

  413.   pData->bDEFIhasclip          = MNG_FALSE;
    414. 

  414.   pData->iDEFIclipl            = 0;
    415. 

  415.   pData->iDEFIclipr            = 0;
    416. 

  416.   pData->iDEFIclipt            = 0;
    417. 

  417.   pData->iDEFIclipb            = 0;
    418. 

  418. #endif
    419. 

  419. 

  420. #ifndef MNG_SKIPCHUNK_BACK
    421. 

  421.   pData->iBACKred              = 0;    /* reset BACK data */
    422. 

  422.   pData->iBACKgreen            = 0;
    423. 

  423.   pData->iBACKblue             = 0;
    424. 

  424.   pData->iBACKmandatory        = 0;
    425. 

  425.   pData->iBACKimageid          = 0;
    426. 

  426.   pData->iBACKtile             = 0;
    427. 

  427. #endif
    428. 

  428. 

  429. #ifndef MNG_SKIPCHUNK_FRAM
    430. 

  430.   pData->iFRAMmode             = 1;     /* default global FRAM variables */
    431. 

  431.   pData->iFRAMdelay            = 1;
    432. 

  432.   pData->iFRAMtimeout          = 0x7fffffffl;
    433. 

  433.   pData->bFRAMclipping         = MNG_FALSE;
    434. 

  434.   pData->iFRAMclipl            = 0;
    435. 

  435.   pData->iFRAMclipr            = 0;
    436. 

  436.   pData->iFRAMclipt            = 0;
    437. 

  437.   pData->iFRAMclipb            = 0;
    438. 

  438. 

  439.   pData->iFramemode            = 1;     /* again for the current frame */
    440. 

  440.   pData->iFramedelay           = 1;
    441. 

  441.   pData->iFrametimeout         = 0x7fffffffl;
    442. 

  442.   pData->bFrameclipping        = MNG_FALSE;
    443. 

  443.   pData->iFrameclipl           = 0;
    444. 

  444.   pData->iFrameclipr           = 0;
    445. 

  445.   pData->iFrameclipt           = 0;
    446. 

  446.   pData->iFrameclipb           = 0;
    447. 

  447. 

  448.   pData->iNextdelay            = 1;
    449. 

  449. 

  450.   pData->bForcedelay           = MNG_FALSE;
    451. 

  451.   pData->iAccumdelay           = 0;
    452. 

  452. #endif
    453. 

  453. 

  454. #ifndef MNG_SKIPCHUNK_SHOW
    455. 

  455.   pData->iSHOWmode             = 0;    /* reset SHOW data */
    456. 

  456.   pData->iSHOWfromid           = 0;
    457. 

  457.   pData->iSHOWtoid             = 0;
    458. 

  458.   pData->iSHOWnextid           = 0;
    459. 

  459.   pData->iSHOWskip             = 0;
    460. 

  460. #endif
    461. 

  461. 

  462.   pData->iGlobalPLTEcount      = 0;    /* reset global PLTE data */
    463. 

  463. 

  464.   pData->iGlobalTRNSrawlen     = 0;    /* reset global tRNS data */
    465. 

  465. 

  466.   pData->iGlobalGamma          = 0;    /* reset global gAMA data */
    467. 

  467. 

  468. #ifndef MNG_SKIPCHUNK_cHRM
    469. 

  469.   pData->iGlobalWhitepointx    = 0;    /* reset global cHRM data */
    470. 

  470.   pData->iGlobalWhitepointy    = 0;
    471. 

  471.   pData->iGlobalPrimaryredx    = 0;
    472. 

  472.   pData->iGlobalPrimaryredy    = 0;
    473. 

  473.   pData->iGlobalPrimarygreenx  = 0;
    474. 

  474.   pData->iGlobalPrimarygreeny  = 0;
    475. 

  475.   pData->iGlobalPrimarybluex   = 0;
    476. 

  476.   pData->iGlobalPrimarybluey   = 0;
    477. 

  477. #endif
    478. 

  478. 

  479. #ifndef MNG_SKIPCHUNK_sRGB
    480. 

  480.   pData->iGlobalRendintent     = 0;    /* reset global sRGB data */
    481. 

  481. #endif
    482. 

  482. 

  483. #ifndef MNG_SKIPCHUNK_iCCP
    484. 

  484.   if (pData->iGlobalProfilesize)       /* drop global profile (if any) */
    485. 

  485.     MNG_FREE (pData, pData->pGlobalProfile, pData->iGlobalProfilesize);
    486. 

  486. 

  487.   pData->iGlobalProfilesize    = 0;    
    488. 

  488. #endif
    489. 

  489. 

  490. #ifndef MNG_SKIPCHUNK_bKGD
    491. 

  491.   pData->iGlobalBKGDred        = 0;    /* reset global bKGD data */
    492. 

  492.   pData->iGlobalBKGDgreen      = 0;
    493. 

  493.   pData->iGlobalBKGDblue       = 0;
    494. 

  494. #endif
    495. 

  495. #ifndef MNG_NO_DELTA_PNG
    496. 

  496.                                        /* reset delta-image */
    497. 

  497.   pData->pDeltaImage           = MNG_NULL;
    498. 

  498.   pData->iDeltaImagetype       = 0;
    499. 

  499.   pData->iDeltatype            = 0;
    500. 

  500.   pData->iDeltaBlockwidth      = 0;
    501. 

  501.   pData->iDeltaBlockheight     = 0;
    502. 

  502.   pData->iDeltaBlockx          = 0;
    503. 

  503.   pData->iDeltaBlocky          = 0;
    504. 

  504.   pData->bDeltaimmediate       = MNG_FALSE;
    505. 

  505. 

  506.   pData->fDeltagetrow          = MNG_NULL;
    507. 

  507.   pData->fDeltaaddrow          = MNG_NULL;
    508. 

  508.   pData->fDeltareplacerow      = MNG_NULL;
    509. 

  509.   pData->fDeltaputrow          = MNG_NULL;
    510. 

  510. 

  511.   pData->fPromoterow           = MNG_NULL;
    512. 

  512.   pData->fPromBitdepth         = MNG_NULL;
    513. 

  513.   pData->pPromBuf              = MNG_NULL;
    514. 

  514.   pData->iPromColortype        = 0;
    515. 

  515.   pData->iPromBitdepth         = 0;
    516. 

  516.   pData->iPromFilltype         = 0;
    517. 

  517.   pData->iPromWidth            = 0;
    518. 

  518.   pData->pPromSrc              = MNG_NULL;
    519. 

  519.   pData->pPromDst              = MNG_NULL;
    520. 

  520. #endif
    521. 

  521. 

  522. #ifndef MNG_SKIPCHUNK_MAGN
    523. 

  523.   pData->iMAGNfromid           = 0;
    524. 

  524.   pData->iMAGNtoid             = 0;
    525. 

  525. #endif
    526. 

  526. 

  527. #ifndef MNG_SKIPCHUNK_PAST
    528. 

  528.   pData->iPastx                = 0;
    529. 

  529.   pData->iPasty                = 0;
    530. 

  530. #endif
    531. 

  531. 

  532.   pData->pLastseek             = MNG_NULL;
    533. 

  533. 

  534.   return MNG_NOERROR;
    535. 

  535. }
    536. 

  536. #endif /* MNG_SUPPORT_DISPLAY */
    537. 

  537. 

  538. /* ************************************************************************** */
    539. 

  539. 

  540. MNG_LOCAL void cleanup_errors (mng_datap pData)
    541. 

  541. {
    542. 

  542.   pData->iErrorcode = MNG_NOERROR;
    543. 

  543.   pData->iSeverity  = 0;
    544. 

  544.   pData->iErrorx1   = 0;
    545. 

  545.   pData->iErrorx2   = 0;
    546. 

  546.   pData->zErrortext = MNG_NULL;
    547. 

  547. 

  548.   return;
    549. 

  549. }
    550. 

  550. 

  551. /* ************************************************************************** */
    552. 

  552. 

  553. #ifdef MNG_SUPPORT_READ
    554. 

  554. MNG_LOCAL mng_retcode make_pushbuffer (mng_datap       pData,
    555. 

  555.                                        mng_ptr         pPushdata,
    556. 

  556.                                        mng_size_t      iLength,
    557. 

  557.                                        mng_bool        bTakeownership,
    558. 

  558.                                        mng_pushdatap * pPush)
    559. 

  559. {
    560. 

  560.   mng_pushdatap pTemp;
    561. 

  561. 

  562.   MNG_ALLOC (pData, pTemp, sizeof(mng_pushdata));
    563. 

  563. 

  564.   pTemp->pNext      = MNG_NULL;
    565. 

  565. 

  566.   if (bTakeownership)                  /* are we going to own the buffer? */
    567. 

  567.   {                                    /* then just copy the pointer */
    568. 

  568.     pTemp->pData    = (mng_uint8p)pPushdata;
    569. 

  569.   }
    570. 

  570.   else
    571. 

  571.   {                                    /* otherwise create new buffer */
    572. 

  572.     MNG_ALLOCX (pData, pTemp->pData, iLength);
    573. 

  573.     if (!pTemp->pData)                 /* succeeded? */
    574. 

  574.     {
    575. 

  575.       MNG_FREEX (pData, pTemp, sizeof(mng_pushdata));
    576. 

  576.       MNG_ERROR (pData, MNG_OUTOFMEMORY);
    577. 

  577.     }
    578. 

  578.                                        /* and copy the bytes across */
    579. 

  579.     MNG_COPY (pTemp->pData, pPushdata, iLength);
    580. 

  580.   }
    581. 

  581. 

  582.   pTemp->iLength    = iLength;
    583. 

  583.   pTemp->bOwned     = bTakeownership;
    584. 

  584.   pTemp->pDatanext  = pTemp->pData;
    585. 

  585.   pTemp->iRemaining = iLength;
    586. 

  586. 

  587.   *pPush            = pTemp;           /* return it */
    588. 

  588. 

  589.   return MNG_NOERROR;                  /* and all's well */
    590. 

  590. }
    591. 

  591. #endif
    592. 

  592. 

  593. #ifdef MNG_VERSION_QUERY_SUPPORT
    594. 

  594. /* ************************************************************************** */
    595. 

  595. /* *                                                                        * */
    596. 

  596. /* *  Versioning control                                                    * */
    597. 

  597. /* *                                                                        * */
    598. 

  598. /* ************************************************************************** */
    599. 

  599. 

  600. mng_pchar MNG_DECL mng_version_text    (void)
    601. 

  601. {
    602. 

  602.   return MNG_VERSION_TEXT;
    603. 

  603. }
    604. 

  604. 

  605. /* ************************************************************************** */
    606. 

  606. 

  607. mng_uint8 MNG_DECL mng_version_so      (void)
    608. 

  608. {
    609. 

  609.   return MNG_VERSION_SO;
    610. 

  610. }
    611. 

  611. 

  612. /* ************************************************************************** */
    613. 

  613. 

  614. mng_uint8 MNG_DECL mng_version_dll     (void)
    615. 

  615. {
    616. 

  616.   return MNG_VERSION_DLL;
    617. 

  617. }
    618. 

  618. 

  619. /* ************************************************************************** */
    620. 

  620. 

  621. mng_uint8 MNG_DECL mng_version_major   (void)
    622. 

  622. {
    623. 

  623.   return MNG_VERSION_MAJOR;
    624. 

  624. }
    625. 

  625. 

  626. /* ************************************************************************** */
    627. 

  627. 

  628. mng_uint8 MNG_DECL mng_version_minor   (void)
    629. 

  629. {
    630. 

  630.   return MNG_VERSION_MINOR;
    631. 

  631. }
    632. 

  632. 

  633. /* ************************************************************************** */
    634. 

  634. 

  635. mng_uint8 MNG_DECL mng_version_release (void)
    636. 

  636. {
    637. 

  637.   return MNG_VERSION_RELEASE;
    638. 

  638. }
    639. 

  639. 

  640. /* ************************************************************************** */
    641. 

  641. 

  642. mng_bool MNG_DECL mng_version_beta (void)
    643. 

  643. {
    644. 

  644.   return MNG_VERSION_BETA;
    645. 

  645. }
    646. 

  646. #endif
    647. 

  647. 

  648. /* ************************************************************************** */
    649. 

  649. /* *                                                                        * */
    650. 

  650. /* * 'supports' function                                                    * */
    651. 

  651. /* *                                                                        * */
    652. 

  652. /* ************************************************************************** */
    653. 

  653. 

  654. #ifdef MNG_SUPPORT_FUNCQUERY
    655. 

  655. typedef struct {
    656. 

  656.                  mng_pchar  zFunction;
    657. 

  657.                  mng_uint8  iMajor;    /* Major == 0 means not implemented ! */ 
    658. 

  658.                  mng_uint8  iMinor;
    659. 

  659.                  mng_uint8  iRelease;
    660. 

  660.                } mng_func_entry;
    661. 

  661. typedef mng_func_entry const * mng_func_entryp;
    662. 

  662. 

  663. MNG_LOCAL mng_func_entry const func_table [] =
    664. 

  664.   {                                    /* keep it alphabetically sorted !!!!! */
    665. 

  665.     {"mng_cleanup",                1, 0, 0},
    666. 

  666.     {"mng_copy_chunk",             1, 0, 5},
    667. 

  667.     {"mng_create",                 1, 0, 0},
    668. 

  668.     {"mng_display",                1, 0, 0},
    669. 

  669.     {"mng_display_freeze",         1, 0, 0},
    670. 

  670. #ifndef MNG_NO_DISPLAY_GO_SUPPORTED
    671. 

  671.     {"mng_display_goframe",        1, 0, 0},
    672. 

  672.     {"mng_display_golayer",        1, 0, 0},
    673. 

  673.     {"mng_display_gotime",         1, 0, 0},
    674. 

  674. #endif
    675. 

  675.     {"mng_display_reset",          1, 0, 0},
    676. 

  676.     {"mng_display_resume",         1, 0, 0},
    677. 

  677.     {"mng_get_alphabitdepth",      1, 0, 0},
    678. 

  678.     {"mng_get_alphacompression",   1, 0, 0},
    679. 

  679.     {"mng_get_alphadepth",         1, 0, 0},
    680. 

  680.     {"mng_get_alphafilter",        1, 0, 0},
    681. 

  681.     {"mng_get_alphainterlace",     1, 0, 0},
    682. 

  682.     {"mng_get_bgcolor",            1, 0, 0},
    683. 

  683.     {"mng_get_bitdepth",           1, 0, 0},
    684. 

  684.     {"mng_get_bkgdstyle",          1, 0, 0},
    685. 

  685.     {"mng_get_cacheplayback",      1, 0, 2},
    686. 

  686.     {"mng_get_canvasstyle",        1, 0, 0},
    687. 

  687.     {"mng_get_colortype",          1, 0, 0},
    688. 

  688.     {"mng_get_compression",        1, 0, 0},
    689. 

  689. #ifndef MNG_NO_CURRENT_INFO
    690. 

  690.     {"mng_get_currentframe",       1, 0, 0},
    691. 

  691.     {"mng_get_currentlayer",       1, 0, 0},
    692. 

  692.     {"mng_get_currentplaytime",    1, 0, 0},
    693. 

  693. #endif
    694. 

  694.     {"mng_get_currframdelay",      1, 0, 9},
    695. 

  695. #ifndef MNG_NO_DFLT_INFO
    696. 

  696.     {"mng_get_dfltimggamma",       1, 0, 0},
    697. 

  697.     {"mng_get_dfltimggammaint",    1, 0, 0},
    698. 

  698. #endif
    699. 

  699.     {"mng_get_displaygamma",       1, 0, 0},
    700. 

  700.     {"mng_get_displaygammaint",    1, 0, 0},
    701. 

  701.     {"mng_get_doprogressive",      1, 0, 2},
    702. 

  702.     {"mng_get_filter",             1, 0, 0},
    703. 

  703.     {"mng_get_framecount",         1, 0, 0},
    704. 

  704.     {"mng_get_imageheight",        1, 0, 0},
    705. 

  705.     {"mng_get_imagelevel",         1, 0, 0},
    706. 

  706.     {"mng_get_imagetype",          1, 0, 0},
    707. 

  707.     {"mng_get_imagewidth",         1, 0, 0},
    708. 

  708.     {"mng_get_interlace",          1, 0, 0},
    709. 

  709. #ifdef MNG_ACCESS_JPEG
    710. 

  710.     {"mng_get_jpeg_dctmethod",     1, 0, 0},
    711. 

  711.     {"mng_get_jpeg_maxjdat",       1, 0, 0},
    712. 

  712.     {"mng_get_jpeg_optimized",     1, 0, 0},
    713. 

  713.     {"mng_get_jpeg_progressive",   1, 0, 0},
    714. 

  714.     {"mng_get_jpeg_quality",       1, 0, 0},
    715. 

  715.     {"mng_get_jpeg_smoothing",     1, 0, 0},
    716. 

  716. #endif
    717. 

  717.     {"mng_get_lastbackchunk",      1, 0, 3},
    718. 

  718.     {"mng_get_lastseekname",       1, 0, 5},
    719. 

  719.     {"mng_get_layercount",         1, 0, 0},
    720. 

  720. #ifndef MNG_SKIP_MAXCANVAS
    721. 

  721.     {"mng_get_maxcanvasheight",    1, 0, 0},
    722. 

  722.     {"mng_get_maxcanvaswidth",     1, 0, 0},
    723. 

  723. #endif
    724. 

  724.     {"mng_get_playtime",           1, 0, 0},
    725. 

  725.     {"mng_get_refreshpass",        1, 0, 0},
    726. 

  726.     {"mng_get_runtime",            1, 0, 0},
    727. 

  727.     {"mng_get_sectionbreaks",      1, 0, 0},
    728. 

  728.     {"mng_get_sigtype",            1, 0, 0},
    729. 

  729.     {"mng_get_simplicity",         1, 0, 0},
    730. 

  730.     {"mng_get_speed",              1, 0, 0},
    731. 

  731.     {"mng_get_srgb",               1, 0, 0},
    732. 

  732.     {"mng_get_starttime",          1, 0, 0},
    733. 

  733.     {"mng_get_storechunks",        1, 0, 0},
    734. 

  734.     {"mng_get_suspensionmode",     1, 0, 0},
    735. 

  735.     {"mng_get_ticks",              1, 0, 0},
    736. 

  736. #ifndef MNG_NO_CURRENT_INFO
    737. 

  737.     {"mng_get_totalframes",        1, 0, 5},
    738. 

  738.     {"mng_get_totallayers",        1, 0, 5},
    739. 

  739.     {"mng_get_totalplaytime",      1, 0, 5},
    740. 

  740. #endif
    741. 

  741.     {"mng_get_usebkgd",            1, 0, 0},
    742. 

  742.     {"mng_get_userdata",           1, 0, 0},
    743. 

  743. #if defined(MNG_FULL_CMS) || defined(MNG_GAMMA_ONLY) || defined(MNG_APP_CMS)
    744. 

  744.     {"mng_get_viewgamma",          1, 0, 0},
    745. 

  745.     {"mng_get_viewgammaint",       1, 0, 0},
    746. 

  746. #endif
    747. 

  747. #ifdef MNG_ACCESS_ZLIB
    748. 

  748.     {"mng_get_zlib_level",         1, 0, 0},
    749. 

  749.     {"mng_get_zlib_maxidat",       1, 0, 0},
    750. 

  750.     {"mng_get_zlib_memlevel",      1, 0, 0},
    751. 

  751.     {"mng_get_zlib_method",        1, 0, 0},
    752. 

  752.     {"mng_get_zlib_strategy",      1, 0, 0},
    753. 

  753.     {"mng_get_zlib_windowbits",    1, 0, 0},
    754. 

  754. #endif
    755. 

  755. #ifndef MNG_NO_OPEN_CLOSE_STREAM
    756. 

  756.     {"mng_getcb_closestream",      1, 0, 0},
    757. 

  757. #endif
    758. 

  758.     {"mng_getcb_errorproc",        1, 0, 0},
    759. 

  759.     {"mng_getcb_getalphaline",     1, 0, 0},
    760. 

  760.     {"mng_getcb_getbkgdline",      1, 0, 0},
    761. 

  761.     {"mng_getcb_getcanvasline",    1, 0, 0},
    762. 

  762.     {"mng_getcb_gettickcount",     1, 0, 0},
    763. 

  763.     {"mng_getcb_memalloc",         1, 0, 0},
    764. 

  764.     {"mng_getcb_memfree",          1, 0, 0},
    765. 

  765. #ifndef MNG_NO_OPEN_CLOSE_STREAM
    766. 

  766.     {"mng_getcb_openstream",       1, 0, 0},
    767. 

  767. #endif
    768. 

  768.     {"mng_getcb_processarow",      1, 0, 0},
    769. 

  769.     {"mng_getcb_processchroma",    1, 0, 0},
    770. 

  770.     {"mng_getcb_processgamma",     1, 0, 0},
    771. 

  771.     {"mng_getcb_processheader",    1, 0, 0},
    772. 

  772.     {"mng_getcb_processiccp",      1, 0, 0},
    773. 

  773.     {"mng_getcb_processmend",      1, 0, 1},
    774. 

  774.     {"mng_getcb_processneed",      1, 0, 0},
    775. 

  775.     {"mng_getcb_processsave",      1, 0, 0},
    776. 

  776.     {"mng_getcb_processseek",      1, 0, 0},
    777. 

  777.     {"mng_getcb_processsrgb",      1, 0, 0},
    778. 

  778.     {"mng_getcb_processterm",      1, 0, 2},
    779. 

  779.     {"mng_getcb_processtext",      1, 0, 0},
    780. 

  780.     {"mng_getcb_processunknown",   1, 0, 0},
    781. 

  781.     {"mng_getcb_readdata",         1, 0, 0},
    782. 

  782.     {"mng_getcb_refresh",          1, 0, 0},
    783. 

  783.     {"mng_getcb_releasedata",      1, 0, 8},
    784. 

  784.     {"mng_getcb_settimer",         1, 0, 0},
    785. 

  785.     {"mng_getcb_traceproc",        1, 0, 0},
    786. 

  786.     {"mng_getcb_writedata",        1, 0, 0},
    787. 

  787.     {"mng_getchunk_back",          1, 0, 0},
    788. 

  788.     {"mng_getchunk_basi",          1, 0, 0},
    789. 

  789. #ifndef MNG_SKIPCHUNK_bKGD
    790. 

  790.     {"mng_getchunk_bkgd",          1, 0, 0},
    791. 

  791. #endif
    792. 

  792. #ifndef MNG_SKIPCHUNK_cHRM
    793. 

  793.     {"mng_getchunk_chrm",          1, 0, 0},
    794. 

  794. #endif
    795. 

  795.     {"mng_getchunk_clip",          1, 0, 0},
    796. 

  796.     {"mng_getchunk_clon",          1, 0, 0},
    797. 

  797. #ifndef MNG_NO_DELTA_PNG
    798. 

  798. #ifndef MNG_SKIPCHUNK_dBYK
    799. 

  799.     {"mng_getchunk_dbyk",          1, 0, 0},
    800. 

  800. #endif
    801. 

  801. #endif
    802. 

  802.     {"mng_getchunk_defi",          1, 0, 0},
    803. 

  803. #ifndef MNG_NO_DELTA_PNG
    804. 

  804.     {"mng_getchunk_dhdr",          1, 0, 0},
    805. 

  805. #endif
    806. 

  806.     {"mng_getchunk_disc",          1, 0, 0},
    807. 

  807. #ifndef MNG_NO_DELTA_PNG
    808. 

  808.     {"mng_getchunk_drop",          1, 0, 0},
    809. 

  809. #endif
    810. 

  810.     {"mng_getchunk_endl",          1, 0, 0},
    811. 

  811. #ifdef MNG_INCLUDE_MPNG_PROPOSAL
    812. 

  812.     {"mng_getchunk_mpng",          1, 0, 10},
    813. 

  813.     {"mng_getchunk_mpng_frame",    1, 0, 10},
    814. 

  814. #endif
    815. 

  815. #ifndef MNG_SKIPCHUNK_evNT
    816. 

  816.     {"mng_getchunk_evnt",          1, 0, 5},
    817. 

  817.     {"mng_getchunk_evnt_entry",    1, 0, 5},
    818. 

  818. #endif
    819. 

  819. #ifndef MNG_SKIPCHUNK_eXPI
    820. 

  820.     {"mng_getchunk_expi",          1, 0, 0},
    821. 

  821. #endif
    822. 

  822. #ifndef MNG_SKIPCHUNK_fPRI
    823. 

  823.     {"mng_getchunk_fpri",          1, 0, 0},
    824. 

  824. #endif
    825. 

  825.     {"mng_getchunk_fram",          1, 0, 0},
    826. 

  826.     {"mng_getchunk_gama",          1, 0, 0},
    827. 

  827. #ifndef MNG_SKIPCHUNK_hIST
    828. 

  828.     {"mng_getchunk_hist",          1, 0, 0},
    829. 

  829. #endif
    830. 

  830. #ifndef MNG_SKIPCHUNK_iCCP
    831. 

  831.     {"mng_getchunk_iccp",          1, 0, 0},
    832. 

  832. #endif
    833. 

  833.     {"mng_getchunk_idat",          1, 0, 0},
    834. 

  834.     {"mng_getchunk_iend",          1, 0, 0},
    835. 

  835.     {"mng_getchunk_ihdr",          1, 0, 0},
    836. 

  836. #ifndef MNG_NO_DELTA_PNG
    837. 

  837. #ifdef MNG_INCLUDE_JNG
    838. 

  838.     {"mng_getchunk_ijng",          1, 0, 0},
    839. 

  839. #endif
    840. 

  840.     {"mng_getchunk_ipng",          1, 0, 0},
    841. 

  841. #endif
    842. 

  842. #ifndef MNG_SKIPCHUNK_iTXt
    843. 

  843.     {"mng_getchunk_itxt",          1, 0, 0},
    844. 

  844. #endif
    845. 

  845. #ifdef MNG_INCLUDE_JNG
    846. 

  846.     {"mng_getchunk_jdaa",          1, 0, 0},
    847. 

  847.     {"mng_getchunk_jdat",          1, 0, 0},
    848. 

  848.     {"mng_getchunk_jhdr",          1, 0, 0},
    849. 

  849.     {"mng_getchunk_jsep",          1, 0, 0},
    850. 

  850. #endif
    851. 

  851.     {"mng_getchunk_loop",          1, 0, 0},
    852. 

  852. #ifndef MNG_SKIPCHUNK_MAGN
    853. 

  853.     {"mng_getchunk_magn",          1, 0, 0},
    854. 

  854. #endif
    855. 

  855.     {"mng_getchunk_mend",          1, 0, 0},
    856. 

  856.     {"mng_getchunk_mhdr",          1, 0, 0},
    857. 

  857.     {"mng_getchunk_move",          1, 0, 0},
    858. 

  858. #ifndef MNG_SKIPCHUNK_nEED
    859. 

  859.     {"mng_getchunk_need",          1, 0, 0},
    860. 

  860. #endif
    861. 

  861. #ifndef MNG_SKIPCHUNK_ORDR
    862. 

  862. #ifndef MNG_NO_DELTA_PNG
    863. 

  863.     {"mng_getchunk_ordr",          1, 0, 0},
    864. 

  864.     {"mng_getchunk_ordr_entry",    1, 0, 0},
    865. 

  865. #endif
    866. 

  866. #endif
    867. 

  867. #ifndef MNG_SKIPCHUNK_PAST
    868. 

  868.     {"mng_getchunk_past",          1, 0, 0},
    869. 

  869.     {"mng_getchunk_past_src",      1, 0, 0},
    870. 

  870. #endif
    871. 

  871. #ifndef MNG_SKIPCHUNK_pHYg
    872. 

  872.     {"mng_getchunk_phyg",          1, 0, 0},
    873. 

  873. #endif
    874. 

  874. #ifndef MNG_SKIPCHUNK_pHYs
    875. 

  875.     {"mng_getchunk_phys",          1, 0, 0},
    876. 

  876. #endif
    877. 

  877. #ifndef MNG_NO_DELTA_PNG
    878. 

  878.     {"mng_getchunk_plte",          1, 0, 0},
    879. 

  879.     {"mng_getchunk_pplt",          1, 0, 0},
    880. 

  880.     {"mng_getchunk_pplt_entry",    1, 0, 0},
    881. 

  881.     {"mng_getchunk_prom",          1, 0, 0},
    882. 

  882. #endif
    883. 

  883. #ifndef MNG_SKIPCHUNK_SAVE
    884. 

  884.     {"mng_getchunk_save",          1, 0, 0},
    885. 

  885.     {"mng_getchunk_save_entry",    1, 0, 0},
    886. 

  886. #endif
    887. 

  887. #ifndef MNG_SKIPCHUNK_sBIT
    888. 

  888.     {"mng_getchunk_sbit",          1, 0, 0},
    889. 

  889. #endif
    890. 

  890. #ifndef MNG_SKIPCHUNK_SEEK
    891. 

  891.     {"mng_getchunk_seek",          1, 0, 0},
    892. 

  892. #endif
    893. 

  893.     {"mng_getchunk_show",          1, 0, 0},
    894. 

  894. #ifndef MNG_SKIPCHUNK_sPLT
    895. 

  895.     {"mng_getchunk_splt",          1, 0, 0},
    896. 

  896. #endif
    897. 

  897. #ifndef MNG_SKIPCHUNK_sRGB
    898. 

  898.     {"mng_getchunk_srgb",          1, 0, 0},
    899. 

  899. #endif
    900. 

  900.     {"mng_getchunk_term",          1, 0, 0},
    901. 

  901. #ifndef MNG_SKIPCHUNK_tEXt
    902. 

  902.     {"mng_getchunk_text",          1, 0, 0},
    903. 

  903. #endif
    904. 

  904. #ifndef MNG_SKIPCHUNK_tIME
    905. 

  905.     {"mng_getchunk_time",          1, 0, 0},
    906. 

  906. #endif
    907. 

  907.     {"mng_getchunk_trns",          1, 0, 0},
    908. 

  908.     {"mng_getchunk_unkown",        1, 0, 0},
    909. 

  909. #ifndef MNG_SKIPCHUNK_zTXt
    910. 

  910.     {"mng_getchunk_ztxt",          1, 0, 0},
    911. 

  911. #endif
    912. 

  912.     {"mng_getimgdata_chunk",       0, 0, 0},
    913. 

  913.     {"mng_getimgdata_chunkseq",    0, 0, 0},
    914. 

  914.     {"mng_getimgdata_seq",         0, 0, 0},
    915. 

  915.     {"mng_getlasterror",           1, 0, 0},
    916. 

  916.     {"mng_initialize",             1, 0, 0},
    917. 

  917.     {"mng_iterate_chunks",         1, 0, 0},
    918. 

  918.     {"mng_putchunk_back",          1, 0, 0},
    919. 

  919. #ifndef MNG_SKIPCHUNK_BASI
    920. 

  920.     {"mng_putchunk_basi",          1, 0, 0},
    921. 

  921. #endif
    922. 

  922. #ifndef MNG_SKIPCHUNK_bKGD
    923. 

  923.     {"mng_putchunk_bkgd",          1, 0, 0},
    924. 

  924. #endif
    925. 

  925. #ifndef MNG_SKIPCHUNK_cHRM
    926. 

  926.     {"mng_putchunk_chrm",          1, 0, 0},
    927. 

  927. #endif
    928. 

  928.     {"mng_putchunk_clip",          1, 0, 0},
    929. 

  929.     {"mng_putchunk_clon",          1, 0, 0},
    930. 

  930. #ifndef MNG_NO_DELTA_PNG
    931. 

  931. #ifndef MNG_SKIPCHUNK_DBYK
    932. 

  932.     {"mng_putchunk_dbyk",          1, 0, 0},
    933. 

  933. #endif
    934. 

  934. #endif
    935. 

  935.     {"mng_putchunk_defi",          1, 0, 0},
    936. 

  936. #ifndef MNG_NO_DELTA_PNG
    937. 

  937.     {"mng_putchunk_dhdr",          1, 0, 0},
    938. 

  938. #endif
    939. 

  939.     {"mng_putchunk_disc",          1, 0, 0},
    940. 

  940. #ifndef MNG_NO_DELTA_PNG
    941. 

  941.     {"mng_putchunk_drop",          1, 0, 0},
    942. 

  942. #endif
    943. 

  943.     {"mng_putchunk_endl",          1, 0, 0},
    944. 

  944. #ifdef MNG_INCLUDE_MPNG_PROPOSAL
    945. 

  945.     {"mng_putchunk_mpng",          1, 0, 10},
    946. 

  946.     {"mng_putchunk_mpng_frame",    1, 0, 10},
    947. 

  947. #endif
    948. 

  948. #ifndef MNG_SKIPCHUNK_evNT
    949. 

  949.     {"mng_putchunk_evnt",          1, 0, 5},
    950. 

  950.     {"mng_putchunk_evnt_entry",    1, 0, 5},
    951. 

  951. #endif
    952. 

  952. #ifndef MNG_SKIPCHUNK_eXPI
    953. 

  953.     {"mng_putchunk_expi",          1, 0, 0},
    954. 

  954. #endif
    955. 

  955. #ifndef MNG_SKIPCHUNK_fPRI
    956. 

  956.     {"mng_putchunk_fpri",          1, 0, 0},
    957. 

  957. #endif
    958. 

  958. #ifndef MNG_SKIPCHUNK_FRAM
    959. 

  959.     {"mng_putchunk_fram",          1, 0, 0},
    960. 

  960. #endif
    961. 

  961.     {"mng_putchunk_gama",          1, 0, 0},
    962. 

  962. #ifndef MNG_SKIPCHUNK_hIST
    963. 

  963.     {"mng_putchunk_hist",          1, 0, 0},
    964. 

  964. #endif
    965. 

  965. #ifndef MNG_SKIPCHUNK_iCCP
    966. 

  966.     {"mng_putchunk_iccp",          1, 0, 0},
    967. 

  967. #endif
    968. 

  968.     {"mng_putchunk_idat",          1, 0, 0},
    969. 

  969.     {"mng_putchunk_iend",          1, 0, 0},
    970. 

  970.     {"mng_putchunk_ihdr",          1, 0, 0},
    971. 

  971. #ifndef MNG_NO_DELTA_PNG
    972. 

  972. #ifdef MNG_INCLUDE_JNG
    973. 

  973.     {"mng_putchunk_ijng",          1, 0, 0},
    974. 

  974. #endif
    975. 

  975.     {"mng_putchunk_ipng",          1, 0, 0},
    976. 

  976. #endif
    977. 

  977. #ifndef MNG_SKIPCHUNK_iTXt
    978. 

  978.     {"mng_putchunk_itxt",          1, 0, 0},
    979. 

  979. #endif
    980. 

  980. #ifdef MNG_INCLUDE_JNG
    981. 

  981.     {"mng_putchunk_jdaa",          1, 0, 0},
    982. 

  982.     {"mng_putchunk_jdat",          1, 0, 0},
    983. 

  983.     {"mng_putchunk_jhdr",          1, 0, 0},
    984. 

  984.     {"mng_putchunk_jsep",          1, 0, 0},
    985. 

  985. #endif
    986. 

  986.     {"mng_putchunk_loop",          1, 0, 0},
    987. 

  987. #ifndef MNG_SKIPCHUNK_MAGN
    988. 

  988.     {"mng_putchunk_magn",          1, 0, 0},
    989. 

  989. #endif
    990. 

  990.     {"mng_putchunk_mend",          1, 0, 0},
    991. 

  991.     {"mng_putchunk_mhdr",          1, 0, 0},
    992. 

  992.     {"mng_putchunk_move",          1, 0, 0},
    993. 

  993. #ifndef MNG_SKIPCHUNK_nEED
    994. 

  994.     {"mng_putchunk_need",          1, 0, 0},
    995. 

  995. #endif
    996. 

  996. #ifndef MNG_NO_DELTA_PNG
    997. 

  997. #ifndef MNG_SKIPCHUNK_ORDR
    998. 

  998.     {"mng_putchunk_ordr",          1, 0, 0},
    999. 

  999.     {"mng_putchunk_ordr_entry",    1, 0, 0},
    1000. 

  1000. #endif
    1001. 

  1001. #endif
    1002. 

  1002. #ifndef MNG_SKIPCHUNK_PAST
    1003. 

  1003.     {"mng_putchunk_past",          1, 0, 0},
    1004. 

  1004.     {"mng_putchunk_past_src",      1, 0, 0},
    1005. 

  1005. #endif
    1006. 

  1006. #ifndef MNG_SKIPCHUNK_pHYg
    1007. 

  1007.     {"mng_putchunk_phyg",          1, 0, 0},
    1008. 

  1008. #endif
    1009. 

  1009. #ifndef MNG_SKIPCHUNK_pHYs
    1010. 

  1010.     {"mng_putchunk_phys",          1, 0, 0},
    1011. 

  1011. #endif
    1012. 

  1012. #ifndef MNG_NO_DELTA_PNG
    1013. 

  1013.     {"mng_putchunk_plte",          1, 0, 0},
    1014. 

  1014.     {"mng_putchunk_pplt",          1, 0, 0},
    1015. 

  1015.     {"mng_putchunk_pplt_entry",    1, 0, 0},
    1016. 

  1016.     {"mng_putchunk_prom",          1, 0, 0},
    1017. 

  1017. #endif
    1018. 

  1018. #ifndef MNG_SKIPCHUNK_SAVE
    1019. 

  1019.     {"mng_putchunk_save",          1, 0, 0},
    1020. 

  1020.     {"mng_putchunk_save_entry",    1, 0, 0},
    1021. 

  1021. #endif
    1022. 

  1022. #ifndef MNG_SKIPCHUNK_sBIT
    1023. 

  1023.     {"mng_putchunk_sbit",          1, 0, 0},
    1024. 

  1024. #endif
    1025. 

  1025. #ifndef MNG_SKIPCHUNK_SEEK
    1026. 

  1026.     {"mng_putchunk_seek",          1, 0, 0},
    1027. 

  1027. #endif
    1028. 

  1028.     {"mng_putchunk_show",          1, 0, 0},
    1029. 

  1029. #ifndef MNG_SKIPCHUNK_sPLT
    1030. 

  1030.     {"mng_putchunk_splt",          1, 0, 0},
    1031. 

  1031. #endif
    1032. 

  1032. #ifndef MNG_SKIPCHUNK_sRGB
    1033. 

  1033.     {"mng_putchunk_srgb",          1, 0, 0},
    1034. 

  1034. #endif
    1035. 

  1035.     {"mng_putchunk_term",          1, 0, 0},
    1036. 

  1036. #ifndef MNG_SKIPCHUNK_tEXt
    1037. 

  1037.     {"mng_putchunk_text",          1, 0, 0},
    1038. 

  1038. #endif
    1039. 

  1039. #ifndef MNG_SKIPCHUNK_tIME
    1040. 

  1040.     {"mng_putchunk_time",          1, 0, 0},
    1041. 

  1041. #endif
    1042. 

  1042.     {"mng_putchunk_trns",          1, 0, 0},
    1043. 

  1043.     {"mng_putchunk_unkown",        1, 0, 0},
    1044. 

  1044. #ifndef MNG_SKIPCHUNK_zTXt
    1045. 

  1045.     {"mng_putchunk_ztxt",          1, 0, 0},
    1046. 

  1046. #endif
    1047. 

  1047.     {"mng_putimgdata_ihdr",        0, 0, 0},
    1048. 

  1048.     {"mng_putimgdata_jhdr",        0, 0, 0},
    1049. 

  1049.     {"mng_reset",                  1, 0, 0},
    1050. 

  1050.     {"mng_read",                   1, 0, 0},
    1051. 

  1051.     {"mng_read_pushchunk",         1, 0, 8},
    1052. 

  1052.     {"mng_read_pushdata",          1, 0, 8},
    1053. 

  1053.     {"mng_read_pushsig",           1, 0, 8},
    1054. 

  1054.     {"mng_read_resume",            1, 0, 0},
    1055. 

  1055.     {"mng_readdisplay",            1, 0, 0},
    1056. 

  1056.     {"mng_set_bgcolor",            1, 0, 0},
    1057. 

  1057.     {"mng_set_bkgdstyle",          1, 0, 0},
    1058. 

  1058.     {"mng_set_cacheplayback",      1, 0, 2},
    1059. 

  1059.     {"mng_set_canvasstyle",        1, 0, 0},
    1060. 

  1060.     {"mng_set_dfltimggamma",       1, 0, 0},
    1061. 

  1061. #ifndef MNG_NO_DFLT_INFO
    1062. 

  1062.     {"mng_set_dfltimggammaint",    1, 0, 0},
    1063. 

  1063. #endif
    1064. 

  1064.     {"mng_set_displaygamma",       1, 0, 0},
    1065. 

  1065.     {"mng_set_displaygammaint",    1, 0, 0},
    1066. 

  1066.     {"mng_set_doprogressive",      1, 0, 2},
    1067. 

  1067. #ifdef MNG_ACCESS_JPEG
    1068. 

  1068.     {"mng_set_jpeg_dctmethod",     1, 0, 0},
    1069. 

  1069.     {"mng_set_jpeg_maxjdat",       1, 0, 0},
    1070. 

  1070.     {"mng_set_jpeg_optimized",     1, 0, 0},
    1071. 

  1071.     {"mng_set_jpeg_progressive",   1, 0, 0},
    1072. 

  1072.     {"mng_set_jpeg_quality",       1, 0, 0},
    1073. 

  1073.     {"mng_set_jpeg_smoothing",     1, 0, 0},
    1074. 

  1074. #endif
    1075. 

  1075. #ifndef MNG_SKIP_MAXCANVAS
    1076. 

  1076.     {"mng_set_maxcanvasheight",    1, 0, 0},
    1077. 

  1077.     {"mng_set_maxcanvassize",      1, 0, 0},
    1078. 

  1078.     {"mng_set_maxcanvaswidth",     1, 0, 0},
    1079. 

  1079. #endif
    1080. 

  1080.     {"mng_set_outputprofile",      1, 0, 0},
    1081. 

  1081.     {"mng_set_outputprofile2",     1, 0, 0},
    1082. 

  1082.     {"mng_set_outputsrgb",         1, 0, 1},
    1083. 

  1083.     {"mng_set_sectionbreaks",      1, 0, 0},
    1084. 

  1084.     {"mng_set_speed",              1, 0, 0},
    1085. 

  1085.     {"mng_set_srgb",               1, 0, 0},
    1086. 

  1086.     {"mng_set_srgbimplicit",       1, 0, 1},
    1087. 

  1087.     {"mng_set_srgbprofile",        1, 0, 0},
    1088. 

  1088.     {"mng_set_srgbprofile2",       1, 0, 0},
    1089. 

  1089.     {"mng_set_storechunks",        1, 0, 0},
    1090. 

  1090.     {"mng_set_suspensionmode",     1, 0, 0},
    1091. 

  1091.     {"mng_set_usebkgd",            1, 0, 0},
    1092. 

  1092.     {"mng_set_userdata",           1, 0, 0},
    1093. 

  1093. #if defined(MNG_FULL_CMS) || defined(MNG_GAMMA_ONLY) || defined(MNG_APP_CMS)
    1094. 

  1094.     {"mng_set_viewgamma",          1, 0, 0},
    1095. 

  1095.     {"mng_set_viewgammaint",       1, 0, 0},
    1096. 

  1096. #endif
    1097. 

  1097. #ifdef MNG_ACCESS_ZLIB
    1098. 

  1098.     {"mng_set_zlib_level",         1, 0, 0},
    1099. 

  1099.     {"mng_set_zlib_maxidat",       1, 0, 0},
    1100. 

  1100.     {"mng_set_zlib_memlevel",      1, 0, 0},
    1101. 

  1101.     {"mng_set_zlib_method",        1, 0, 0},
    1102. 

  1102.     {"mng_set_zlib_strategy",      1, 0, 0},
    1103. 

  1103.     {"mng_set_zlib_windowbits",    1, 0, 0},
    1104. 

  1104. #endif
    1105. 

  1105. #ifndef MNG_NO_OPEN_CLOSE_STREAM
    1106. 

  1106.     {"mng_setcb_closestream",      1, 0, 0},
    1107. 

  1107. #endif
    1108. 

  1108.     {"mng_setcb_errorproc",        1, 0, 0},
    1109. 

  1109.     {"mng_setcb_getalphaline",     1, 0, 0},
    1110. 

  1110.     {"mng_setcb_getbkgdline",      1, 0, 0},
    1111. 

  1111.     {"mng_setcb_getcanvasline",    1, 0, 0},
    1112. 

  1112.     {"mng_setcb_gettickcount",     1, 0, 0},
    1113. 

  1113.     {"mng_setcb_memalloc",         1, 0, 0},
    1114. 

  1114.     {"mng_setcb_memfree",          1, 0, 0},
    1115. 

  1115. #ifndef MNG_NO_OPEN_CLOSE_STREAM
    1116. 

  1116.     {"mng_setcb_openstream",       1, 0, 0},
    1117. 

  1117. #endif
    1118. 

  1118.     {"mng_setcb_processarow",      1, 0, 0},
    1119. 

  1119.     {"mng_setcb_processchroma",    1, 0, 0},
    1120. 

  1120.     {"mng_setcb_processgamma",     1, 0, 0},
    1121. 

  1121.     {"mng_setcb_processheader",    1, 0, 0},
    1122. 

  1122.     {"mng_setcb_processiccp",      1, 0, 0},
    1123. 

  1123.     {"mng_setcb_processmend",      1, 0, 1},
    1124. 

  1124.     {"mng_setcb_processneed",      1, 0, 0},
    1125. 

  1125.     {"mng_setcb_processsave",      1, 0, 0},
    1126. 

  1126.     {"mng_setcb_processseek",      1, 0, 0},
    1127. 

  1127.     {"mng_setcb_processsrgb",      1, 0, 0},
    1128. 

  1128.     {"mng_setcb_processterm",      1, 0, 2},
    1129. 

  1129.     {"mng_setcb_processtext",      1, 0, 0},
    1130. 

  1130.     {"mng_setcb_processunknown",   1, 0, 0},
    1131. 

  1131.     {"mng_setcb_readdata",         1, 0, 0},
    1132. 

  1132.     {"mng_setcb_refresh",          1, 0, 0},
    1133. 

  1133.     {"mng_setcb_releasedata",      1, 0, 8},
    1134. 

  1134.     {"mng_setcb_settimer",         1, 0, 0},
    1135. 

  1135.     {"mng_setcb_traceproc",        1, 0, 0},
    1136. 

  1136.     {"mng_setcb_writedata",        1, 0, 0},
    1137. 

  1137.     {"mng_status_creating",        1, 0, 0},
    1138. 

  1138.     {"mng_status_displaying",      1, 0, 0},
    1139. 

  1139.     {"mng_status_dynamic",         1, 0, 5},
    1140. 

  1140.     {"mng_status_error",           1, 0, 0},
    1141. 

  1141.     {"mng_status_reading",         1, 0, 0},
    1142. 

  1142.     {"mng_status_running",         1, 0, 0},
    1143. 

  1143.     {"mng_status_runningevent",    1, 0, 5},
    1144. 

  1144.     {"mng_status_suspendbreak",    1, 0, 0},
    1145. 

  1145.     {"mng_status_timerbreak",      1, 0, 0},
    1146. 

  1146.     {"mng_status_writing",         1, 0, 0},
    1147. 

  1147.     {"mng_supports_func",          1, 0, 5},
    1148. 

  1148.     {"mng_trapevent",              1, 0, 5},
    1149. 

  1149.     {"mng_updatemngheader",        1, 0, 0},
    1150. 

  1150.     {"mng_updatemngsimplicity",    1, 0, 0},
    1151. 

  1151.     {"mng_version_beta",           1, 0, 5},
    1152. 

  1152.     {"mng_version_dll",            1, 0, 0},
    1153. 

  1153.     {"mng_version_major",          1, 0, 0},
    1154. 

  1154.     {"mng_version_minor",          1, 0, 0},
    1155. 

  1155.     {"mng_version_release",        1, 0, 0},
    1156. 

  1156.     {"mng_version_so",             1, 0, 0},
    1157. 

  1157.     {"mng_version_text",           1, 0, 0},
    1158. 

  1158.     {"mng_write",                  1, 0, 0},
    1159. 

  1159.   };
    1160. 

  1160. 

  1161. mng_bool MNG_DECL mng_supports_func (mng_pchar  zFunction,
    1162. 

  1162.                                      mng_uint8* iMajor,
    1163. 

  1163.                                      mng_uint8* iMinor,
    1164. 

  1164.                                      mng_uint8* iRelease)
    1165. 

  1165. {
    1166. 

  1166.   mng_int32       iTop, iLower, iUpper, iMiddle;
    1167. 

  1167.   mng_func_entryp pEntry;          /* pointer to found entry */
    1168. 

  1168.                                    /* determine max index of table */
    1169. 

  1169.   iTop = (sizeof (func_table) / sizeof (func_table [0])) - 1;
    1170. 

  1170. 

  1171.   iLower  = 0;                     /* initialize binary search */
    1172. 

  1172.   iMiddle = iTop >> 1;             /* start in the middle */
    1173. 

  1173.   iUpper  = iTop;
    1174. 

  1174.   pEntry  = 0;                     /* no goods yet! */
    1175. 

  1175. 

  1176.   do                               /* the binary search itself */
    1177. 

  1177.     {
    1178. 

  1178.       mng_int32 iRslt = strcmp(func_table [iMiddle].zFunction, zFunction);
    1179. 

  1179.       if (iRslt < 0)
    1180. 

  1180.         iLower = iMiddle + 1;
    1181. 

  1181.       else if (iRslt > 0)
    1182. 

  1182.         iUpper = iMiddle - 1;
    1183. 

  1183.       else
    1184. 

  1184.       {
    1185. 

  1185.         pEntry = &func_table [iMiddle];
    1186. 

  1186.         break;
    1187. 

  1187.       };
    1188. 

  1188. 

  1189.       iMiddle = (iLower + iUpper) >> 1;
    1190. 

  1190.     }
    1191. 

  1191.   while (iLower <= iUpper);
    1192. 

  1192. 

  1193.   if (pEntry)                      /* found it ? */
    1194. 

  1194.   {
    1195. 

  1195.     *iMajor   = pEntry->iMajor;
    1196. 

  1196.     *iMinor   = pEntry->iMinor;
    1197. 

  1197.     *iRelease = pEntry->iRelease;
    1198. 

  1198.     return MNG_TRUE;
    1199. 

  1199.   }
    1200. 

  1200.   else
    1201. 

  1201.   {
    1202. 

  1202.     *iMajor   = 0;
    1203. 

  1203.     *iMinor   = 0;
    1204. 

  1204.     *iRelease = 0;
    1205. 

  1205.     return MNG_FALSE;…
    1206.