PageRenderTime 59ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 2ms

/lib/cximage-6.0/mng/libmng_pixels.c

http://github.com/xbmc/xbmc
C | 13878 lines | 11466 code | 1525 blank | 887 comment | 1488 complexity | bb712b345ae5b5ba9c95d4b8afc68903 MD5 | raw file
Possible License(s): GPL-3.0, CC-BY-SA-3.0, LGPL-2.0, 0BSD, Unlicense, GPL-2.0, AGPL-1.0, BSD-3-Clause, LGPL-2.1, LGPL-3.0 
    

  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_pixels.c           copyright (c) 2000-2005 G.Juyn   * */
    8. 

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

  9. /* *                                                                        * */
    10. 

  10. /* * purpose   : Pixel-row management routines (implementation)             * */
    11. 

  11. /* *                                                                        * */
    12. 

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

  13. /* *                                                                        * */
    14. 

  14. /* * comment   : implementation of the pixel-row management routines        * */
    15. 

  15. /* *                                                                        * */
    16. 

  16. /* *             the dual alpha-composing for RGBA/BGRA/etc output-canvas'  * */
    17. 

  17. /* *             is based on the Note on Compositing chapter of the         * */
    18. 

  18. /* *             DOH-3 draft, noted to me by Adam M. Costello               * */
    19. 

  19. /* *                                                                        * */
    20. 

  20. /* * changes   : 0.5.1 - 05/08/2000 - G.Juyn                                * */
    21. 

  21. /* *             - changed strict-ANSI stuff                                * */
    22. 

  22. /* *             0.5.1 - 05/11/2000 - G.Juyn                                * */
    23. 

  23. /* *             - added callback error-reporting support                   * */
    24. 

  24. /* *             0.5.1 - 05/12/2000 - G.Juyn                                * */
    25. 

  25. /* *             - changed trace to macro for callback error-reporting      * */
    26. 

  26. /* *                                                                        * */
    27. 

  27. /* *             0.5.2 - 05/22/2000 - G.Juyn                                * */
    28. 

  28. /* *             - added JNG support                                        * */
    29. 

  29. /* *             0.5.2 - 05/30/2000 - G.Juyn                                * */
    30. 

  30. /* *             - fixed minor bugs 16-bit pixel-handling                   * */
    31. 

  31. /* *             - added delta-image row-processing routines                * */
    32. 

  32. /* *             0.5.2 - 06/02/2000 - G.Juyn                                * */
    33. 

  33. /* *             - fixed endian support (hopefully)                         * */
    34. 

  34. /* *             0.5.2 - 06/03/2000 - G.Juyn                                * */
    35. 

  35. /* *             - fixed makeup for Linux gcc compile                       * */
    36. 

  36. /* *             0.5.2 - 06/05/2000 - G.Juyn                                * */
    37. 

  37. /* *             - implemented app bkgd restore routines                    * */
    38. 

  38. /* *             - implemented RGBA8, ARGB8, BGRA8 & ABGR8 display routines * */
    39. 

  39. /* *             - added support for RGB8_A8 canvasstyle                    * */
    40. 

  40. /* *             0.5.2 - 06/09/2000 - G.Juyn                                * */
    41. 

  41. /* *             - fixed alpha-handling for alpha canvasstyles              * */
    42. 

  42. /* *                                                                        * */
    43. 

  43. /* *             0.5.3 - 06/16/2000 - G.Juyn                                * */
    44. 

  44. /* *             - changed progressive-display processing                   * */
    45. 

  45. /* *             0.5.3 - 06/17/2000 - G.Juyn                                * */
    46. 

  46. /* *             - changed to support delta-images                          * */
    47. 

  47. /* *             - optimized some store_xxx routines                        * */
    48. 

  48. /* *             0.5.3 - 06/20/2000 - G.Juyn                                * */
    49. 

  49. /* *             - fixed nasty bug with embedded PNG after delta-image      * */
    50. 

  50. /* *             0.5.3 - 06/24/2000 - G.Juyn                                * */
    51. 

  51. /* *             - fixed problem with 16-bit GA format                      * */
    52. 

  52. /* *             0.5.3 - 06/25/2000 - G.Juyn                                * */
    53. 

  53. /* *             - fixed problem with cheap transparency for 4-bit gray     * */
    54. 

  54. /* *             - fixed display_xxxx routines for interlaced images        * */
    55. 

  55. /* *             0.5.3 - 06/28/2000 - G.Juyn                                * */
    56. 

  56. /* *             - fixed compiler-warning for non-initialized iB variable   * */
    57. 

  57. /* *                                                                        * */
    58. 

  58. /* *             0.9.1 - 07/05/2000 - G.Juyn                                * */
    59. 

  59. /* *             - fixed mandatory BACK color to be opaque                  * */
    60. 

  60. /* *                                                                        * */
    61. 

  61. /* *             0.9.2 - 07/31/2000 - G.Juyn                                * */
    62. 

  62. /* *             - B110547 - fixed bug in interlace code                    * */
    63. 

  63. /* *             0.9.2 - 08/05/2000 - G.Juyn                                * */
    64. 

  64. /* *             - changed file-prefixes                                    * */
    65. 

  65. /* *                                                                        * */
    66. 

  66. /* *             0.9.3 - 08/20/2000 - G.Juyn                                * */
    67. 

  67. /* *             - fixed app-supplied background restore                    * */
    68. 

  68. /* *             0.9.3 - 08/26/2000 - G.Juyn                                * */
    69. 

  69. /* *             - added MAGN chunk                                         * */
    70. 

  70. /* *             0.9.3 - 09/07/2000 - G.Juyn                                * */
    71. 

  71. /* *             - added support for new filter_types                       * */
    72. 

  72. /* *             0.9.3 - 09/30/2000 - G.Juyn                                * */
    73. 

  73. /* *             - fixed MAGN rounding errors (thanks Matthias!)            * */
    74. 

  74. /* *             0.9.3 - 10/10/2000 - G.Juyn                                * */
    75. 

  75. /* *             - fixed alpha-blending for RGBA canvasstyle                * */
    76. 

  76. /* *             0.9.3 - 10/11/2000 - G.Juyn                                * */
    77. 

  77. /* *             - fixed alpha-blending for other alpha-canvasstyles        * */
    78. 

  78. /* *             0.9.3 - 10/16/2000 - G.Juyn                                * */
    79. 

  79. /* *             - added optional support for bKGD for PNG images           * */
    80. 

  80. /* *             - added support for JDAA                                   * */
    81. 

  81. /* *             0.9.3 - 10/17/2000 - G.Juyn                                * */
    82. 

  82. /* *             - fixed support for bKGD                                   * */
    83. 

  83. /* *             0.9.3 - 10/19/2000 - G.Juyn                                * */
    84. 

  84. /* *             - implemented delayed delta-processing                     * */
    85. 

  85. /* *             0.9.3 - 10/28/2000 - G.Juyn                                * */
    86. 

  86. /* *             - fixed tRNS processing for gray-image < 8-bits            * */
    87. 

  87. /* *                                                                        * */
    88. 

  88. /* *             0.9.4 - 12/16/2000 - G.Juyn                                * */
    89. 

  89. /* *             - fixed mixup of data- & function-pointers (thanks Dimitri)* */
    90. 

  90. /* *             0.9.4 -  1/18/2001 - G.Juyn                                * */
    91. 

  91. /* *             - removed "old" MAGN methods 3 & 4                         * */
    92. 

  92. /* *             - added "new" MAGN methods 3, 4 & 5                        * */
    93. 

  93. /* *             - removed test filter-methods 1 & 65                       * */
    94. 

  94. /* *                                                                        * */
    95. 

  95. /* *             1.0.1 - 04/21/2001 - G.Juyn (code by G.Kelly)              * */
    96. 

  96. /* *             - added BGRA8 canvas with premultiplied alpha              * */
    97. 

  97. /* *             1.0.1 - 04/25/2001 - G.Juyn                                * */
    98. 

  98. /* *             - moved mng_clear_cms to libmng_cms                        * */
    99. 

  99. /* *                                                                        * */
    100. 

  100. /* *             1.0.2 - 06/25/2001 - G.Juyn                                * */
    101. 

  101. /* *             - added option to turn off progressive refresh             * */
    102. 

  102. /* *                                                                        * */
    103. 

  103. /* *             1.0.4 - 11/04/2001 - G.Juyn                                * */
    104. 

  104. /* *             - fixed possible compile-problem in cleanup_rowproc        * */
    105. 

  105. /* *             1.0.4 - 06/22/2002 - G.Juyn                                * */
    106. 

  106. /* *             - B558212 - off by one error                               * */
    107. 

  107. /* *             - MNG subimage alpha composite wrong for rgba8 images      * */
    108. 

  108. /* *                                                                        * */
    109. 

  109. /* *             1.0.5 - 08/07/2002 - G.Juyn                                * */
    110. 

  110. /* *             - added test-option for PNG filter method 193 (=no filter) * */
    111. 

  111. /* *             1.0.5 - 08/15/2002 - G.Juyn                                * */
    112. 

  112. /* *             - completed PROM support                                   * */
    113. 

  113. /* *             - completed delta-image support                            * */
    114. 

  114. /* *             1.0.5 - 08/16/2002 - G.Juyn                                * */
    115. 

  115. /* *             - completed MAGN support (16-bit functions)                * */
    116. 

  116. /* *             1.0.5 - 08/19/2002 - G.Juyn                                * */
    117. 

  117. /* *             - B597134 - libmng pollutes the linker namespace           * */
    118. 

  118. /* *             1.0.5 - 09/19/2002 - G.Juyn                                * */
    119. 

  119. /* *             - optimized restore-background for bKGD cases              * */
    120. 

  120. /* *             1.0.5 - 09/20/2002 - G.Juyn                                * */
    121. 

  121. /* *             - finished support for BACK image & tiling                 * */
    122. 

  122. /* *             1.0.5 - 09/22/2002 - G.Juyn                                * */
    123. 

  123. /* *             - added bgrx8 canvas (filler byte)                         * */
    124. 

  124. /* *             1.0.5 - 09/23/2002 - G.Juyn                                * */
    125. 

  125. /* *             - added compose over/under routines for PAST processing    * */
    126. 

  126. /* *             - added flip & tile routines for PAST processing           * */
    127. 

  127. /* *                                                                        * */
    128. 

  128. /* *             1.0.6 - 03/09/2003 - G.Juyn                                * */
    129. 

  129. /* *             - hiding 12-bit JPEG stuff                                 * */
    130. 

  130. /* *             1.0.6 - 05/11/2003 - Glenn RP                              * */
    131. 

  131. /* *             - added size-optimization COMPOSE routine usage            * */
    132. 

  132. /* *             1.0.6 - 05/11/2003 - G. Juyn                               * */
    133. 

  133. /* *             - added conditionals around canvas update routines         * */
    134. 

  134. /* *             1.0.6 - 05/25/2003 - Glenn RP                              * */
    135. 

  135. /* *             - added size-optimization DIV255B8 routine usage           * */
    136. 

  136. /* *             1.0.6 - 06/09/2003 - G. R-P                                * */
    137. 

  137. /* *             - added conditionals around 8-bit magn routines            * */
    138. 

  138. /* *             1.0.6 - 07/07/2003 - G. R-P                                * */
    139. 

  139. /* *             - removed conditionals around 8-bit magn routines          * */
    140. 

  140. /* *             - added MNG_NO_16BIT_SUPPORT and MNG_NO_DELTA_PNG          * */
    141. 

  141. /* *               conditionals                                             * */
    142. 

  142. /* *             - reversed many loops to use decrementing counter          * */
    143. 

  143. /* *             - combined init functions                                  * */
    144. 

  144. /* *             - converted some switches to array references              * */
    145. 

  145. /* *             1.0.6 - 07/29/2003 - G.Juyn                                * */
    146. 

  146. /* *             - fixed duplicate for-loop                                 * */
    147. 

  147. /* *             1.0.6 - 07/29/2003 - G.R-P                                 * */
    148. 

  148. /* *             - added SKIPCHUNK conditionals around PAST chunk support   * */
    149. 

  149. /* *             - fixed "FOOTPRINT_COMPOSEIV" typo (now "FOOTPRINT_DIV")   * */
    150. 

  150. /* *             1.0.6 - 08/17/2003 - G.R-P                                 * */
    151. 

  151. /* *             - added more conditionals around "promote" functions       * */
    152. 

  152. /* *                                                                        * */
    153. 

  153. /* *             1.0.7 - 11/27/2003 - R.A                                   * */
    154. 

  154. /* *             - added CANVAS_RGB565 and CANVAS_BGR565                    * */
    155. 

  155. /* *             1.0.7 - 12/06/2003 - R.A                                   * */
    156. 

  156. /* *             - added CANVAS_RGBA565 and CANVAS_BGRA565                  * */
    157. 

  157. /* *             1.0.7 - 01/25/2004 - J.S                                   * */
    158. 

  158. /* *             - added premultiplied alpha canvas' for RGBA, ARGB, ABGR   * */
    159. 

  159. /* *             1.0.7 - 03/08/2004 - G.R-P                                 * */
    160. 

  160. /* *             - added more conditionals around 16-bit-supporting code    * */
    161. 

  161. /* *             1.0.7 - 03/09/2004 - G.Juyn                                * */
    162. 

  162. /* *             - fixed bug in promote_g8_g8 with 16bit support off        * */
    163. 

  163. /* *             1.0.7 - 03/09/2004 - G.R-P                                 * */
    164. 

  164. /* *             - more optimizations with 16bit support off                * */
    165. 

  165. /* *             1.0.7 - 03/10/2004 - G.Juyn                                * */
    166. 

  166. /* *             - fixed some warnings for 16bit optimizations              * */
    167. 

  167. /* *             1.0.7 - 03/21/2004 - G.Juyn                                * */
    168. 

  168. /* *             - fixed some 64-bit platform compiler warnings             * */
    169. 

  169. /* *                                                                        * */
    170. 

  170. /* *             1.0.8 - 06/20/2004 - G.Juyn                                * */
    171. 

  171. /* *             - some speed optimizations (thanks to John Stiles)         * */
    172. 

  172. /* *             1.0.8 - 08/01/2004 - G.Juyn                                * */
    173. 

  173. /* *             - added support for 3+byte pixelsize for JPEG's            * */
    174. 

  174. /* *                                                                        * */
    175. 

  175. /* *             1.0.9 - 10/10/2004 - G.R-P.                                * */
    176. 

  176. /* *             - added MNG_NO_1_2_4BIT_SUPPORT                            * */
    177. 

  177. /* *             1.0.9 - 10/14/2004 - G.Juyn                                * */
    178. 

  178. /* *             - added bgr565_a8 canvas-style (thanks to J. Elvander)     * */
    179. 

  179. /* *             1.0.9 - 12/05/2004 - G.Juyn                                * */
    180. 

  180. /* *             - added LITTLEENDIAN/BIGENDIAN fixtures (thanks J.Stiles)  * */
    181. 

  181. /* *             - fixed MNG_NO_1_2_4BIT_SUPPORT for TBBN1G04.PNG           * */
    182. 

  182. /* *             1.0.9 - 12/31/2004 - G.R-P.                                * */
    183. 

  183. /* *             - fixed warnings about C++ style (//) comments             * */
    184. 

  184. /* *                                                                        * */
    185. 

  185. /* *             1.0.10 - 07/06/2005 - G.R-P.                               * */
    186. 

  186. /* *             - added MORE MNG_NO_1_2_4BIT_SUPPORT                       * */
    187. 

  187. /* *             1.0.10 - 10/06/2005 - G.R-P.                               * */
    188. 

  188. /* *             - alloc more memory for MNG_NO_1_2_4BIT_SUPPORT            * */
    189. 

  189. /* *             1.0.10 - 12/07/2005 - G.R-P.                               * */
    190. 

  190. /* *             - optimized footprint of 16bit support                     * */
    191. 

  191. /* *             1.0.10 - 03/07/2006 - (thanks to W. Manthey)               * */
    192. 

  192. /* *             - added CANVAS_RGB555 and CANVAS_BGR555                    * */
    193. 

  193. /* *                                                                        * */
    194. 

  194. /* ************************************************************************** */
    195. 

  195. 

  196. #include "libmng.h"
    197. 

  197. #include "libmng_data.h"
    198. 

  198. #include "libmng_error.h"
    199. 

  199. #include "libmng_trace.h"
    200. 

  200. #ifdef __BORLANDC__
    201. 

  201. #pragma hdrstop
    202. 

  202. #endif
    203. 

  203. #include "libmng_objects.h"
    204. 

  204. #include "libmng_object_prc.h"
    205. 

  205. #include "libmng_memory.h"
    206. 

  206. #include "libmng_cms.h"
    207. 

  207. #include "libmng_filter.h"
    208. 

  208. #include "libmng_pixels.h"
    209. 

  209. 

  210. #if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
    211. 

  211. #pragma option -A                      /* force ANSI-C */
    212. 

  212. #endif
    213. 

  213. 

  214. /* ************************************************************************** */
    215. 

  215. 

  216. #ifdef MNG_INCLUDE_DISPLAY_PROCS
    217. 

  217. 

  218. /* TODO: magnification & canvas-positioning/-clipping */
    219. 

  219. 

  220. /* TODO: major optimization of pixel-loops by using assembler (?) */
    221. 

  221. 

  222. /* ************************************************************************** */
    223. 

  223. /* *                                                                        * */
    224. 

  224. /* * Interlace tables                                                       * */
    225. 

  225. /* *                                                                        * */
    226. 

  226. /* ************************************************************************** */
    227. 

  227. 

  228. MNG_LOCAL mng_uint32 const interlace_row      [7] = { 0, 0, 4, 0, 2, 0, 1 };
    229. 

  229. MNG_LOCAL mng_uint32 const interlace_rowskip  [7] = { 8, 8, 8, 4, 4, 2, 2 };
    230. 

  230. MNG_LOCAL mng_uint32 const interlace_col      [7] = { 0, 4, 0, 2, 0, 1, 0 };
    231. 

  231. MNG_LOCAL mng_uint32 const interlace_colskip  [7] = { 8, 8, 4, 4, 2, 2, 1 };
    232. 

  232. MNG_LOCAL mng_uint32 const interlace_roundoff [7] = { 7, 7, 3, 3, 1, 1, 0 };
    233. 

  233. MNG_LOCAL mng_uint32 const interlace_divider  [7] = { 3, 3, 2, 2, 1, 1, 0 };
    234. 

  234. 

  235. /* ************************************************************************** */
    236. 

  236. /* *                                                                        * */
    237. 

  237. /* * Alpha composing macros                                                 * */
    238. 

  238. /* * the code below is slightly modified from the libpng package            * */
    239. 

  239. /* * the original was last optimized by Greg Roelofs & Mark Adler           * */
    240. 

  240. /* *                                                                        * */
    241. 

  241. /* ************************************************************************** */
    242. 

  242. 

  243. #define MNG_COMPOSE8(RET,FG,ALPHA,BG) {                                    \
    244. 

  244.        mng_uint16 iH = (mng_uint16)((mng_uint16)(FG) * (mng_uint16)(ALPHA) \
    245. 

  245.                         + (mng_uint16)(BG)*(mng_uint16)(255 -              \
    246. 

  246.                           (mng_uint16)(ALPHA)) + (mng_uint16)128);         \
    247. 

  247.        (RET) = (mng_uint8)((iH + (iH >> 8)) >> 8); }
    248. 

  248. 

  249. #define MNG_COMPOSE16(RET,FG,ALPHA,BG) {                                   \
    250. 

  250.        mng_uint32 iH = (mng_uint32)((mng_uint32)(FG) * (mng_uint32)(ALPHA) \
    251. 

  251.                         + (mng_uint32)(BG)*(mng_uint32)(65535L -           \
    252. 

  252.                           (mng_uint32)(ALPHA)) + (mng_uint32)32768L);      \
    253. 

  253.        (RET) = (mng_uint16)((iH + (iH >> 16)) >> 16); }
    254. 

  254. 

  255. /* ************************************************************************** */
    256. 

  256. /* *                                                                        * */
    257. 

  257. /* * Alpha blending macros                                                  * */
    258. 

  258. /* * this code is based on Adam Costello's "Note on Compositing" from the   * */
    259. 

  259. /* * mng-list which gives the following formula:                            * */
    260. 

  260. /* *                                                                        * */
    261. 

  261. /* * top pixel       = (Rt, Gt, Bt, At)                                     * */
    262. 

  262. /* * bottom pixel    = (Rb, Gb, Bb, Ab)                                     * */
    263. 

  263. /* * composite pixel = (Rc, Gc, Bc, Ac)                                     * */
    264. 

  264. /* *                                                                        * */
    265. 

  265. /* * all values in the range 0..1                                           * */
    266. 

  266. /* *                                                                        * */
    267. 

  267. /* * Ac = 1 - (1 - At)(1 - Ab)                                              * */
    268. 

  268. /* * s = At / Ac                                                            * */
    269. 

  269. /* * t = (1 - At) Ab / Ac                                                   * */
    270. 

  270. /* * Rc = s Rt + t Rb                                                       * */
    271. 

  271. /* * Gc = s Gt + t Gb                                                       * */
    272. 

  272. /* * Bc = s Bt + t Bb                                                       * */
    273. 

  273. /* *                                                                        * */
    274. 

  274. /* * (I just hope I coded it correctly in integer arithmetic...)            * */
    275. 

  275. /* *                                                                        * */
    276. 

  276. /* ************************************************************************** */
    277. 

  277. 

  278. #define MNG_BLEND8(RT, GT, BT, AT, RB, GB, BB, AB, RC, GC, BC, AC) {         \
    279. 

  279.        mng_uint32 S, T;                                                      \
    280. 

  280.        (AC) = (mng_uint8)((mng_uint32)255 -                                  \
    281. 

  281.                           ((((mng_uint32)255 - (mng_uint32)(AT)) *           \
    282. 

  282.                             ((mng_uint32)255 - (mng_uint32)(AB))   ) >> 8)); \
    283. 

  283.        S    = (mng_uint32)(((mng_uint32)(AT) << 8) /                         \
    284. 

  284.                            (mng_uint32)(AC));                                \
    285. 

  285.        T    = (mng_uint32)(((mng_uint32)255 - (mng_uint32)(AT)) *            \
    286. 

  286.                             (mng_uint32)(AB) / (mng_uint32)(AC));            \
    287. 

  287.        (RC) = (mng_uint8)((S * (mng_uint32)(RT) +                            \
    288. 

  288.                            T * (mng_uint32)(RB) + (mng_uint32)127) >> 8);    \
    289. 

  289.        (GC) = (mng_uint8)((S * (mng_uint32)(GT) +                            \
    290. 

  290.                            T * (mng_uint32)(GB) + (mng_uint32)127) >> 8);    \
    291. 

  291.        (BC) = (mng_uint8)((S * (mng_uint32)(BT) +                            \
    292. 

  292.                            T * (mng_uint32)(BB) + (mng_uint32)127) >> 8); }
    293. 

  293. 

  294. #define MNG_BLEND16(RT, GT, BT, AT, RB, GB, BB, AB, RC, GC, BC, AC) {            \
    295. 

  295.        mng_uint32 S, T;                                                          \
    296. 

  296.        (AC) = (mng_uint16)((mng_uint32)65535 -                                   \
    297. 

  297.                            ((((mng_uint32)65535 - (mng_uint32)(AT)) *            \
    298. 

  298.                              ((mng_uint32)65535 - (mng_uint32)(AB))   ) >> 16)); \
    299. 

  299.        S    = (mng_uint32)(((mng_uint32)(AT) << 16) /                            \
    300. 

  300.                             (mng_uint32)(AC));                                   \
    301. 

  301.        T    = (mng_uint32)(((mng_uint32)65535 - (mng_uint32)(AT)) *              \
    302. 

  302.                             (mng_uint32)(AB) / (mng_uint32)(AC));                \
    303. 

  303.        (RC) = (mng_uint16)((S * (mng_uint32)(RT) +                               \
    304. 

  304.                             T * (mng_uint32)(RB) + (mng_uint32)32767) >> 16);    \
    305. 

  305.        (GC) = (mng_uint16)((S * (mng_uint32)(GT) +                               \
    306. 

  306.                             T * (mng_uint32)(GB) + (mng_uint32)32767) >> 16);    \
    307. 

  307.        (BC) = (mng_uint16)((S * (mng_uint32)(BT) +                               \
    308. 

  308.                             T * (mng_uint32)(BB) + (mng_uint32)32767) >> 16); }
    309. 

  309. 

  310. /* ************************************************************************** */
    311. 

  311. 

  312. /* note a good optimizing compiler will optimize this */
    313. 

  313. #define DIV255B8(x) (mng_uint8)(((x) + 127) / 255)
    314. 

  314. #define DIV255B16(x) (mng_uint16)(((x) + 32767) / 65535)
    315. 

  315. 

  316. /* ************************************************************************** */
    317. 

  317. /* *                                                                        * */
    318. 

  318. /* * Progressive display check - checks to see if progressive display is    * */
    319. 

  319. /* * in order & indicates so                                                * */
    320. 

  320. /* *                                                                        * */
    321. 

  321. /* * The routine is called after a call to one of the display_xxx routines  * */
    322. 

  322. /* * if appropriate                                                         * */
    323. 

  323. /* *                                                                        * */
    324. 

  324. /* * The refresh is warrented in the read_chunk routine (mng_read.c)        * */
    325. 

  325. /* * and only during read&display processing, since there's not much point  * */
    326. 

  326. /* * doing it from memory!                                                  * */
    327. 

  327. /* *                                                                        * */
    328. 

  328. /* ************************************************************************** */
    329. 

  329. 

  330. mng_retcode mng_display_progressive_check (mng_datap pData)
    331. 

  331. {
    332. 

  332.   if ((pData->bDoProgressive) &&       /* need progressive display? */
    333. 

  333.       ((pData->eImagetype != mng_it_mng) || (pData->iDataheight > 300)) &&
    334. 

  334.       (pData->iDestb - pData->iDestt > 50) && (!pData->pCurraniobj))
    335. 

  335.   {
    336. 

  336.     mng_int32 iC = pData->iRow + pData->iDestt - pData->iSourcet;
    337. 

  337. 

  338.     if (iC % 20 == 0)                  /* every 20th line */
    339. 

  339.       pData->bNeedrefresh = MNG_TRUE;
    340. 

  340. 

  341.   }
    342. 

  342. 

  343.   return MNG_NOERROR;
    344. 

  344. }
    345. 

  345. 

  346. /* ************************************************************************** */
    347. 

  347. /* *                                                                        * */
    348. 

  348. /* * Display routines - convert rowdata (which is already color-corrected)  * */
    349. 

  349. /* * to the output canvas, respecting the opacity information               * */
    350. 

  350. /* *                                                                        * */
    351. 

  351. /* ************************************************************************** */
    352. 

  352. 

  353. MNG_LOCAL void check_update_region (mng_datap pData)
    354. 

  354. {                                      /* determine actual canvas row */
    355. 

  355.   mng_int32 iRow = pData->iRow + pData->iDestt - pData->iSourcet;
    356. 

  356.                                        /* check for change in update-region */
    357. 

  357.   if ((pData->iDestl < (mng_int32)pData->iUpdateleft) || (pData->iUpdateright == 0))
    358. 

  358.     pData->iUpdateleft   = pData->iDestl;
    359. 

  359. 

  360.   if (pData->iDestr > (mng_int32)pData->iUpdateright)
    361. 

  361.     pData->iUpdateright  = pData->iDestr;
    362. 

  362. 

  363.   if ((iRow < (mng_int32)pData->iUpdatetop) || (pData->iUpdatebottom == 0))
    364. 

  364.     pData->iUpdatetop    = iRow;
    365. 

  365. 

  366.   if (iRow+1 > (mng_int32)pData->iUpdatebottom)
    367. 

  367.     pData->iUpdatebottom = iRow+1;
    368. 

  368. 

  369.   return;
    370. 

  370. }
    371. 

  371. 

  372. /* ************************************************************************** */
    373. 

  373. 

  374. #ifndef MNG_SKIPCANVAS_RGB8
    375. 

  375. #ifndef MNG_NO_16BIT_SUPPORT
    376. 

  376. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    377. 

  377. mng_retcode mng_display_rgb8 (mng_datap pData)
    378. 

  378. {
    379. 

  379.   mng_uint8p pScanline;
    380. 

  380.   mng_uint8p pDataline;
    381. 

  381.   mng_int32  iX;
    382. 

  382.   mng_uint16 iA16;
    383. 

  383.   mng_uint16 iFGr16, iFGg16, iFGb16;
    384. 

  384.   mng_uint16 iBGr16, iBGg16, iBGb16;
    385. 

  385.   mng_uint8  iA8;
    386. 

  386. 

  387. #ifdef MNG_SUPPORT_TRACE
    388. 

  388.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_START);
    389. 

  389. #endif
    390. 

  390.                                        /* viewable row ? */
    391. 

  391.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    392. 

  392.   {                                    /* address destination row */
    393. 

  393.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    394. 

  394.                                                    pData->iRow + pData->iDestt -
    395. 

  395.                                                    pData->iSourcet);
    396. 

  396.                                        /* adjust destination row starting-point */
    397. 

  397.     pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
    398. 

  398.     pDataline = pData->pRGBArow;       /* address source row */
    399. 

  399. 

  400.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    401. 

  401.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    402. 

  402.     else
    403. 

  403.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    404. 

  404. 

  405.     if (pData->bIsOpaque)              /* forget about transparency ? */
    406. 

  406.     {
    407. 

  407.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    408. 

  408.       {
    409. 

  409.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    410. 

  410.              iX += pData->iColinc)
    411. 

  411.         {                              /* scale down by dropping the LSB */
    412. 

  412.           *pScanline     = *pDataline;
    413. 

  413.           *(pScanline+1) = *(pDataline+2);
    414. 

  414.           *(pScanline+2) = *(pDataline+4);
    415. 

  415. 

  416.           pScanline += (pData->iColinc * 3);
    417. 

  417.           pDataline += 8;
    418. 

  418.         }
    419. 

  419.       }
    420. 

  420.       else
    421. 

  421.       {
    422. 

  422.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    423. 

  423.              iX += pData->iColinc)
    424. 

  424.         {                              /* copy the values */
    425. 

  425.           *pScanline     = *pDataline;
    426. 

  426.           *(pScanline+1) = *(pDataline+1);
    427. 

  427.           *(pScanline+2) = *(pDataline+2);
    428. 

  428. 

  429.           pScanline += (pData->iColinc * 3);
    430. 

  430.           pDataline += 4;
    431. 

  431.         }
    432. 

  432.       }
    433. 

  433.     }
    434. 

  434.     else
    435. 

  435.     {
    436. 

  436.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    437. 

  437.       {
    438. 

  438.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    439. 

  439.              iX += pData->iColinc)
    440. 

  440.         {
    441. 

  441.           iA16 = mng_get_uint16 (pDataline+6);
    442. 

  442. 

  443.           if (iA16)                    /* any opacity at all ? */
    444. 

  444.           {
    445. 

  445.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    446. 

  446.             {                          /* scale down by dropping the LSB */
    447. 

  447.               *pScanline     = *pDataline;
    448. 

  448.               *(pScanline+1) = *(pDataline+2);
    449. 

  449.               *(pScanline+2) = *(pDataline+4);
    450. 

  450.             }
    451. 

  451.             else
    452. 

  452.             {                          /* get the proper values */
    453. 

  453.               iFGr16 = mng_get_uint16 (pDataline  );
    454. 

  454.               iFGg16 = mng_get_uint16 (pDataline+2);
    455. 

  455.               iFGb16 = mng_get_uint16 (pDataline+4);
    456. 

  456.                                        /* scale background up */
    457. 

  457.               iBGr16 = (mng_uint16)(*pScanline    );
    458. 

  458.               iBGg16 = (mng_uint16)(*(pScanline+1));
    459. 

  459.               iBGb16 = (mng_uint16)(*(pScanline+2));
    460. 

  460.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    461. 

  461.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    462. 

  462.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    463. 

  463.                                        /* now compose */
    464. 

  464.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    465. 

  465.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    466. 

  466.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    467. 

  467.                                        /* and return the composed values */
    468. 

  468.               *pScanline     = (mng_uint8)(iFGr16 >> 8);
    469. 

  469.               *(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
    470. 

  470.               *(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
    471. 

  471.             }
    472. 

  472.           }
    473. 

  473. 

  474.           pScanline += (pData->iColinc * 3);
    475. 

  475.           pDataline += 8;
    476. 

  476.         }
    477. 

  477.       }
    478. 

  478.       else
    479. 

  479.       {
    480. 

  480.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    481. 

  481.              iX += pData->iColinc)
    482. 

  482.         {
    483. 

  483.           iA8 = *(pDataline+3);        /* get alpha value */
    484. 

  484. 

  485.           if (iA8)                     /* any opacity at all ? */
    486. 

  486.           {
    487. 

  487.             if (iA8 == 0xFF)           /* fully opaque ? */
    488. 

  488.             {                          /* then simply copy the values */
    489. 

  489.               *pScanline     = *pDataline;
    490. 

  490.               *(pScanline+1) = *(pDataline+1);
    491. 

  491.               *(pScanline+2) = *(pDataline+2);
    492. 

  492.             }
    493. 

  493.             else
    494. 

  494.             {                          /* do alpha composing */
    495. 

  495.               MNG_COMPOSE8 (*pScanline,     *pDataline,     iA8, *pScanline    );
    496. 

  496.               MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
    497. 

  497.               MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iA8, *(pScanline+2));
    498. 

  498.             }
    499. 

  499.           }
    500. 

  500. 

  501.           pScanline += (pData->iColinc * 3);
    502. 

  502.           pDataline += 4;
    503. 

  503.         }
    504. 

  504.       }
    505. 

  505.     }
    506. 

  506.   }
    507. 

  507. 

  508.   check_update_region (pData);
    509. 

  509. 

  510. #ifdef MNG_SUPPORT_TRACE
    511. 

  511.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_END);
    512. 

  512. #endif
    513. 

  513. 

  514.   return MNG_NOERROR;
    515. 

  515. }
    516. 

  516. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    517. 

  517. mng_retcode mng_display_rgb8 (mng_datap pData)
    518. 

  518. {
    519. 

  519.   mng_uint8p pScanline;
    520. 

  520.   mng_uint8p pDataline;
    521. 

  521.   mng_int32  iX;
    522. 

  522.   mng_uint16 iA16;
    523. 

  523.   mng_uint16 iFGg16;
    524. 

  524.   mng_uint16 iBGg16;
    525. 

  525.   mng_uint8  iA8;
    526. 

  526.   mng_uint8  iBps;
    527. 

  527. 

  528. #ifdef MNG_SUPPORT_TRACE
    529. 

  529.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_START);
    530. 

  530. #endif
    531. 

  531. 

  532.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    533. 

  533.                                        /* viewable row ? */
    534. 

  534.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    535. 

  535.   {                                    /* address destination row */
    536. 

  536.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    537. 

  537.                                                    pData->iRow + pData->iDestt -
    538. 

  538.                                                    pData->iSourcet);
    539. 

  539.                                        /* adjust destination row starting-point */
    540. 

  540.     pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
    541. 

  541.     pDataline = pData->pRGBArow;       /* address source row */
    542. 

  542. 

  543.     /* adjust source row starting-point */
    544. 

  544.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    545. 

  545. 

  546.     if (pData->bIsOpaque)              /* forget about transparency ? */
    547. 

  547.     {
    548. 

  548.       {
    549. 

  549.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    550. 

  550.              iX += pData->iColinc)
    551. 

  551.         {                              /* scale down by dropping the LSB */
    552. 

  552.           *pScanline     = *pDataline;
    553. 

  553.           *(pScanline+1) = *(pDataline+iBps);
    554. 

  554.           *(pScanline+2) = *(pDataline+2*iBps);
    555. 

  555. 

  556.           pScanline += (pData->iColinc * 3);
    557. 

  557.           pDataline += 4*iBps;
    558. 

  558.         }
    559. 

  559.       }
    560. 

  560.     }
    561. 

  561.     else
    562. 

  562.     {
    563. 

  563.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    564. 

  564.       {
    565. 

  565.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    566. 

  566.              iX += pData->iColinc)
    567. 

  567.         {
    568. 

  568.           iA16 = mng_get_uint16 (pDataline+6);
    569. 

  569. 

  570.           if (iA16)                    /* any opacity at all ? */
    571. 

  571.           {
    572. 

  572.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    573. 

  573.             {                          /* scale down by dropping the LSB */
    574. 

  574.               *pScanline     = *pDataline;
    575. 

  575.               *(pScanline+1) = *(pDataline+2);
    576. 

  576.               *(pScanline+2) = *(pDataline+4);
    577. 

  577.             }
    578. 

  578.             else
    579. 

  579.             {                          /* get the proper values */
    580. 

  580.               int i;
    581. 

  581.               for (i=2; i >= 0; i--)
    582. 

  582.               {
    583. 

  583.                 iFGg16 = mng_get_uint16 (pDataline+i+i);
    584. 

  584.                                          /* scale background up */
    585. 

  585.                 iBGg16 = (mng_uint16)(*(pScanline+i));
    586. 

  586.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    587. 

  587.                                          /* now compose */
    588. 

  588.                 MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    589. 

  589.                                          /* and return the composed values */
    590. 

  590.                 *(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
    591. 

  591.               }
    592. 

  592.             }
    593. 

  593.           }
    594. 

  594. 

  595.           pScanline += (pData->iColinc * 3);
    596. 

  596.           pDataline += 8;
    597. 

  597.         }
    598. 

  598.       }
    599. 

  599.       else
    600. 

  600.       {
    601. 

  601.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    602. 

  602.              iX += pData->iColinc)
    603. 

  603.         {
    604. 

  604.           iA8 = *(pDataline+3);        /* get alpha value */
    605. 

  605. 

  606.           if (iA8)                     /* any opacity at all ? */
    607. 

  607.           {
    608. 

  608.             if (iA8 == 0xFF)           /* fully opaque ? */
    609. 

  609.             {                          /* then simply copy the values */
    610. 

  610.               *pScanline     = *pDataline;
    611. 

  611.               *(pScanline+1) = *(pDataline+1);
    612. 

  612.               *(pScanline+2) = *(pDataline+2);
    613. 

  613.             }
    614. 

  614.             else
    615. 

  615.             {                          /* do alpha composing */
    616. 

  616.               int i;
    617. 

  617.               for (i=2; i >= 0; i--)
    618. 

  618.               {
    619. 

  619.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iA8, *(pScanline+i));
    620. 

  620.               }
    621. 

  621.             }
    622. 

  622.           }
    623. 

  623. 

  624.           pScanline += (pData->iColinc * 3);
    625. 

  625.           pDataline += 4;
    626. 

  626.         }
    627. 

  627.       }
    628. 

  628.     }
    629. 

  629.   }
    630. 

  630. 

  631.   check_update_region (pData);
    632. 

  632. 

  633. #ifdef MNG_SUPPORT_TRACE
    634. 

  634.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_END);
    635. 

  635. #endif
    636. 

  636. 

  637.   return MNG_NOERROR;
    638. 

  638. }
    639. 

  639. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    640. 

  640. #else /* MNG_NO_16BIT_SUPPORT */
    641. 

  641. mng_retcode mng_display_rgb8 (mng_datap pData)
    642. 

  642. {
    643. 

  643.   mng_uint8p pScanline;
    644. 

  644.   mng_uint8p pDataline;
    645. 

  645.   mng_int32  iX;
    646. 

  646.   mng_uint8  iA8;
    647. 

  647. 

  648. #ifdef MNG_SUPPORT_TRACE
    649. 

  649.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_START);
    650. 

  650. #endif
    651. 

  651.                                        /* viewable row ? */
    652. 

  652.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    653. 

  653.   {                                    /* address destination row */
    654. 

  654.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    655. 

  655.                                                    pData->iRow + pData->iDestt -
    656. 

  656.                                                    pData->iSourcet);
    657. 

  657.                                        /* adjust destination row starting-point */
    658. 

  658.     pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
    659. 

  659.     pDataline = pData->pRGBArow;       /* address source row */
    660. 

  660. 

  661.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    662. 

  662. 

  663.     if (pData->bIsOpaque)              /* forget about transparency ? */
    664. 

  664.     {
    665. 

  665.       {
    666. 

  666.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    667. 

  667.              iX += pData->iColinc)
    668. 

  668.         {                              /* copy the values */
    669. 

  669.           *pScanline     = *pDataline;
    670. 

  670.           *(pScanline+1) = *(pDataline+1);
    671. 

  671.           *(pScanline+2) = *(pDataline+2);
    672. 

  672. 

  673.           pScanline += (pData->iColinc * 3);
    674. 

  674.           pDataline += 4;
    675. 

  675.         }
    676. 

  676.       }
    677. 

  677.     }
    678. 

  678.     else
    679. 

  679.     {
    680. 

  680.       {
    681. 

  681.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    682. 

  682.              iX += pData->iColinc)
    683. 

  683.         {
    684. 

  684.           iA8 = *(pDataline+3);        /* get alpha value */
    685. 

  685. 

  686.           if (iA8)                     /* any opacity at all ? */
    687. 

  687.           {
    688. 

  688.             if (iA8 == 0xFF)           /* fully opaque ? */
    689. 

  689.             {                          /* then simply copy the values */
    690. 

  690.               *pScanline     = *pDataline;
    691. 

  691.               *(pScanline+1) = *(pDataline+1);
    692. 

  692.               *(pScanline+2) = *(pDataline+2);
    693. 

  693.             }
    694. 

  694.             else
    695. 

  695.             {                          /* do alpha composing */
    696. 

  696. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    697. 

  697.               int i;
    698. 

  698.               for (i=2; i >= 0; i--)
    699. 

  699.               {
    700. 

  700.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iA8, *(pScanline+i));
    701. 

  701.               }
    702. 

  702. #else
    703. 

  703.               MNG_COMPOSE8 (*pScanline,     *pDataline,     iA8, *pScanline    );
    704. 

  704.               MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
    705. 

  705.               MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iA8, *(pScanline+2));
    706. 

  706. #endif
    707. 

  707.             }
    708. 

  708.           }
    709. 

  709. 

  710.           pScanline += (pData->iColinc * 3);
    711. 

  711.           pDataline += 4;
    712. 

  712.         }
    713. 

  713.       }
    714. 

  714.     }
    715. 

  715.   }
    716. 

  716. 

  717.   check_update_region (pData);
    718. 

  718. 

  719. #ifdef MNG_SUPPORT_TRACE
    720. 

  720.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8, MNG_LC_END);
    721. 

  721. #endif
    722. 

  722. 

  723.   return MNG_NOERROR;
    724. 

  724. }
    725. 

  725. #endif /* MNG_NO_16BIT_SUPPORT */
    726. 

  726. #endif /* MNG_SKIPCANVAS_RGB8 */
    727. 

  727. 

  728. /* ************************************************************************** */
    729. 

  729. 

  730. #ifndef MNG_SKIPCANVAS_RGBA8
    731. 

  731. #ifndef MNG_NO_16BIT_SUPPORT
    732. 

  732. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    733. 

  733. mng_retcode mng_display_rgba8 (mng_datap pData)
    734. 

  734. {
    735. 

  735.   mng_uint8p pScanline;
    736. 

  736.   mng_uint8p pDataline;
    737. 

  737.   mng_int32  iX;
    738. 

  738.   mng_uint8  iFGa8, iBGa8, iCa8;
    739. 

  739.   mng_uint16 iFGa16, iBGa16, iCa16;
    740. 

  740.   mng_uint16 iFGr16, iFGg16, iFGb16;
    741. 

  741.   mng_uint16 iBGr16, iBGg16, iBGb16;
    742. 

  742.   mng_uint16 iCr16, iCg16, iCb16;
    743. 

  743.   mng_uint8  iCr8, iCg8, iCb8;
    744. 

  744. 

  745. #ifdef MNG_SUPPORT_TRACE
    746. 

  746.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
    747. 

  747. #endif
    748. 

  748.                                        /* viewable row ? */
    749. 

  749.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    750. 

  750.   {                                    /* address destination row */
    751. 

  751.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    752. 

  752.                                                    pData->iRow + pData->iDestt -
    753. 

  753.                                                    pData->iSourcet);
    754. 

  754.                                        /* adjust destination row starting-point */
    755. 

  755.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    756. 

  756.     pDataline = pData->pRGBArow;       /* address source row */
    757. 

  757. 

  758.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    759. 

  759.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    760. 

  760.     else
    761. 

  761.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    762. 

  762. 

  763.     if (pData->bIsOpaque)              /* forget about transparency ? */
    764. 

  764.     {
    765. 

  765.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    766. 

  766.       {
    767. 

  767.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    768. 

  768.              iX += pData->iColinc)
    769. 

  769.         {                              /* scale down by dropping the LSB */
    770. 

  770.           *pScanline     = *pDataline;
    771. 

  771.           *(pScanline+1) = *(pDataline+2);
    772. 

  772.           *(pScanline+2) = *(pDataline+4);
    773. 

  773.           *(pScanline+3) = *(pDataline+6);
    774. 

  774. 

  775.           pScanline += (pData->iColinc << 2);
    776. 

  776.           pDataline += 8;
    777. 

  777.         }
    778. 

  778.       }
    779. 

  779.       else
    780. 

  780.       {
    781. 

  781.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    782. 

  782.              iX += pData->iColinc)
    783. 

  783.         {                              /* copy the values */
    784. 

  784.           *pScanline     = *pDataline;
    785. 

  785.           *(pScanline+1) = *(pDataline+1);
    786. 

  786.           *(pScanline+2) = *(pDataline+2);
    787. 

  787.           *(pScanline+3) = *(pDataline+3);
    788. 

  788. 

  789.           pScanline += (pData->iColinc << 2);
    790. 

  790.           pDataline += 4;
    791. 

  791.         }
    792. 

  792.       }
    793. 

  793.     }
    794. 

  794.     else
    795. 

  795.     {
    796. 

  796.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    797. 

  797.       {
    798. 

  798.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    799. 

  799.              iX += pData->iColinc)
    800. 

  800.         {                              /* get alpha values */
    801. 

  801.           iFGa16 = mng_get_uint16 (pDataline+6);
    802. 

  802.           iBGa16 = (mng_uint16)(*(pScanline+3));
    803. 

  803.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    804. 

  804. 

  805.           if (iFGa16)                  /* any opacity at all ? */
    806. 

  806.           {                            /* fully opaque or background fully transparent ? */
    807. 

  807.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    808. 

  808.             {                          /* plain copy it */
    809. 

  809.               *pScanline     = *pDataline;
    810. 

  810.               *(pScanline+1) = *(pDataline+2);
    811. 

  811.               *(pScanline+2) = *(pDataline+4);
    812. 

  812.               *(pScanline+3) = *(pDataline+6);
    813. 

  813.             }
    814. 

  814.             else
    815. 

  815.             {
    816. 

  816.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    817. 

  817.               {                        /* get the proper values */
    818. 

  818.                 iFGr16 = mng_get_uint16 (pDataline  );
    819. 

  819.                 iFGg16 = mng_get_uint16 (pDataline+2);
    820. 

  820.                 iFGb16 = mng_get_uint16 (pDataline+4);
    821. 

  821.                                        /* scale background up */
    822. 

  822.                 iBGr16 = (mng_uint16)(*pScanline    );
    823. 

  823.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    824. 

  824.                 iBGb16 = (mng_uint16)(*(pScanline+2));
    825. 

  825.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    826. 

  826.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    827. 

  827.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    828. 

  828.                                        /* now compose */
    829. 

  829.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    830. 

  830.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    831. 

  831.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    832. 

  832.                                        /* and return the composed values */
    833. 

  833.                 *pScanline     = (mng_uint8)(iFGr16 >> 8);
    834. 

  834.                 *(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
    835. 

  835.                 *(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
    836. 

  836.                                        /* alpha remains fully opaque !!! */
    837. 

  837.               }
    838. 

  838.               else
    839. 

  839.               {                        /* scale background up */
    840. 

  840.                 iBGr16 = (mng_uint16)(*pScanline    );
    841. 

  841.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    842. 

  842.                 iBGb16 = (mng_uint16)(*(pScanline+2));
    843. 

  843.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    844. 

  844.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    845. 

  845.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    846. 

  846.                                        /* let's blend */
    847. 

  847.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    848. 

  848.                              mng_get_uint16 (pDataline+2),
    849. 

  849.                              mng_get_uint16 (pDataline+4), iFGa16,
    850. 

  850.                              iBGr16, iBGg16, iBGb16, iBGa16,
    851. 

  851.                              iCr16,  iCg16,  iCb16,  iCa16);
    852. 

  852.                                        /* and return the composed values */
    853. 

  853.                 *pScanline     = (mng_uint8)(iCr16 >> 8);
    854. 

  854.                 *(pScanline+1) = (mng_uint8)(iCg16 >> 8);
    855. 

  855.                 *(pScanline+2) = (mng_uint8)(iCb16 >> 8);
    856. 

  856.                 *(pScanline+3) = (mng_uint8)(iCa16 >> 8);
    857. 

  857.               }
    858. 

  858.             }
    859. 

  859.           }
    860. 

  860. 

  861.           pScanline += (pData->iColinc << 2);
    862. 

  862.           pDataline += 8;
    863. 

  863.         }
    864. 

  864.       }
    865. 

  865.       else
    866. 

  866.       {
    867. 

  867.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    868. 

  868.              iX += pData->iColinc)
    869. 

  869.         {
    870. 

  870.           iFGa8 = *(pDataline+3);      /* get alpha values */
    871. 

  871.           iBGa8 = *(pScanline+3);
    872. 

  872. 

  873.           if (iFGa8)                   /* any opacity at all ? */
    874. 

  874.           {                            /* fully opaque or background fully transparent ? */
    875. 

  875.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    876. 

  876.             {                          /* then simply copy the values */
    877. 

  877.               *pScanline     = *pDataline;
    878. 

  878.               *(pScanline+1) = *(pDataline+1);
    879. 

  879.               *(pScanline+2) = *(pDataline+2);
    880. 

  880.               *(pScanline+3) = *(pDataline+3);
    881. 

  881.             }
    882. 

  882.             else
    883. 

  883.             {
    884. 

  884.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    885. 

  885.               {                        /* do alpha composing */
    886. 

  886.                 MNG_COMPOSE8 (*pScanline,     *pDataline,     iFGa8, *pScanline    );
    887. 

  887.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
    888. 

  888.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iFGa8, *(pScanline+2));
    889. 

  889.                                        /* alpha remains fully opaque !!! */
    890. 

  890.               }
    891. 

  891.               else
    892. 

  892.               {                        /* now blend */
    893. 

  893.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    894. 

  894.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    895. 

  895.                             iCr8, iCg8, iCb8, iCa8);
    896. 

  896.                                        /* and return the composed values */
    897. 

  897.                 *pScanline     = iCr8;
    898. 

  898.                 *(pScanline+1) = iCg8;
    899. 

  899.                 *(pScanline+2) = iCb8;
    900. 

  900.                 *(pScanline+3) = iCa8;
    901. 

  901.               }
    902. 

  902.             }
    903. 

  903.           }
    904. 

  904. 

  905.           pScanline += (pData->iColinc << 2);
    906. 

  906.           pDataline += 4;
    907. 

  907.         }
    908. 

  908.       }
    909. 

  909.     }
    910. 

  910.   }
    911. 

  911. 

  912.   check_update_region (pData);
    913. 

  913. 

  914. #ifdef MNG_SUPPORT_TRACE
    915. 

  915.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
    916. 

  916. #endif
    917. 

  917. 

  918.   return MNG_NOERROR;
    919. 

  919. }
    920. 

  920. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    921. 

  921. mng_retcode mng_display_rgba8 (mng_datap pData)
    922. 

  922. {
    923. 

  923.   mng_uint8p pScanline;
    924. 

  924.   mng_uint8p pDataline;
    925. 

  925.   mng_int32  iX;
    926. 

  926.   mng_uint8  iFGa8, iBGa8, iCa8;
    927. 

  927.   mng_uint16 iFGa16, iBGa16, iCa16;
    928. 

  928.   mng_uint16 iFGg16;
    929. 

  929.   mng_uint16 iBGr16, iBGg16, iBGb16;
    930. 

  930.   mng_uint16 iCr16, iCg16, iCb16;
    931. 

  931.   mng_uint8  iCr8, iCg8, iCb8;
    932. 

  932.   mng_uint8  iBps;
    933. 

  933. 

  934. #ifdef MNG_SUPPORT_TRACE
    935. 

  935.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
    936. 

  936. #endif
    937. 

  937. 

  938.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    939. 

  939.                                        /* viewable row ? */
    940. 

  940.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    941. 

  941.   {                                    /* address destination row */
    942. 

  942.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    943. 

  943.                                                    pData->iRow + pData->iDestt -
    944. 

  944.                                                    pData->iSourcet);
    945. 

  945.                                        /* adjust destination row starting-point */
    946. 

  946.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    947. 

  947.     pDataline = pData->pRGBArow;       /* address source row */
    948. 

  948. 

  949.     /* adjust source row starting-point */
    950. 

  950.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    951. 

  951. 

  952.     if (pData->bIsOpaque)              /* forget about transparency ? */
    953. 

  953.     {
    954. 

  954.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    955. 

  955.              iX += pData->iColinc)
    956. 

  956.         {                              /* scale down by dropping the LSB */
    957. 

  957.           *pScanline     = *pDataline;
    958. 

  958.           *(pScanline+1) = *(pDataline+iBps);
    959. 

  959.           *(pScanline+2) = *(pDataline+2*iBps);
    960. 

  960.           *(pScanline+3) = *(pDataline+3*iBps);
    961. 

  961. 

  962.           pScanline += (pData->iColinc << 2);
    963. 

  963.           pDataline += 4*iBps;
    964. 

  964.         }
    965. 

  965.     }
    966. 

  966.     else
    967. 

  967.     {
    968. 

  968.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    969. 

  969.       {
    970. 

  970.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    971. 

  971.              iX += pData->iColinc)
    972. 

  972.         {                              /* get alpha values */
    973. 

  973.           iFGa16 = mng_get_uint16 (pDataline+6);
    974. 

  974.           iBGa16 = (mng_uint16)(*(pScanline+3));
    975. 

  975.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    976. 

  976. 

  977.           if (iFGa16)                  /* any opacity at all ? */
    978. 

  978.           {                            /* fully opaque or background fully transparent ? */
    979. 

  979.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    980. 

  980.             {                          /* plain copy it */
    981. 

  981.               *pScanline     = *pDataline;
    982. 

  982.               *(pScanline+1) = *(pDataline+2);
    983. 

  983.               *(pScanline+2) = *(pDataline+4);
    984. 

  984.               *(pScanline+3) = *(pDataline+6);
    985. 

  985.             }
    986. 

  986.             else
    987. 

  987.             {
    988. 

  988.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    989. 

  989.               {                        /* get the proper values */
    990. 

  990.               int i;
    991. 

  991.               for (i=2; i >= 0; i--)
    992. 

  992.               {
    993. 

  993.                 iFGg16 = mng_get_uint16 (pDataline+i+i);
    994. 

  994.                                        /* scale background up */
    995. 

  995.                 iBGg16 = (mng_uint16)(*(pScanline+i));
    996. 

  996.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    997. 

  997.                                        /* now compose */
    998. 

  998.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    999. 

  999.                                        /* and return the composed values */
    1000. 

  1000.                 *(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
    1001. 

  1001.                                        /* alpha remains fully opaque !!! */
    1002. 

  1002.               }
    1003. 

  1003.               }
    1004. 

  1004.               else
    1005. 

  1005.               {                        /* scale background up */
    1006. 

  1006.                 iBGr16 = (mng_uint16)(*pScanline    );
    1007. 

  1007.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    1008. 

  1008.                 iBGb16 = (mng_uint16)(*(pScanline+2));
    1009. 

  1009.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    1010. 

  1010.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    1011. 

  1011.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    1012. 

  1012.                                        /* let's blend */
    1013. 

  1013.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    1014. 

  1014.                              mng_get_uint16 (pDataline+2),
    1015. 

  1015.                              mng_get_uint16 (pDataline+4), iFGa16,
    1016. 

  1016.                              iBGr16, iBGg16, iBGb16, iBGa16,
    1017. 

  1017.                              iCr16,  iCg16,  iCb16,  iCa16);
    1018. 

  1018.                                        /* and return the composed values */
    1019. 

  1019.                 *pScanline     = (mng_uint8)(iCr16 >> 8);
    1020. 

  1020.                 *(pScanline+1) = (mng_uint8)(iCg16 >> 8);
    1021. 

  1021.                 *(pScanline+2) = (mng_uint8)(iCb16 >> 8);
    1022. 

  1022.                 *(pScanline+3) = (mng_uint8)(iCa16 >> 8);
    1023. 

  1023.               }
    1024. 

  1024.             }
    1025. 

  1025.           }
    1026. 

  1026. 

  1027.           pScanline += (pData->iColinc << 2);
    1028. 

  1028.           pDataline += 8;
    1029. 

  1029.         }
    1030. 

  1030.       }
    1031. 

  1031.       else
    1032. 

  1032.       {
    1033. 

  1033.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1034. 

  1034.              iX += pData->iColinc)
    1035. 

  1035.         {
    1036. 

  1036.           iFGa8 = *(pDataline+3);      /* get alpha values */
    1037. 

  1037.           iBGa8 = *(pScanline+3);
    1038. 

  1038. 

  1039.           if (iFGa8)                   /* any opacity at all ? */
    1040. 

  1040.           {                            /* fully opaque or background fully transparent ? */
    1041. 

  1041.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    1042. 

  1042.             {                          /* then simply copy the values */
    1043. 

  1043.               *pScanline     = *pDataline;
    1044. 

  1044.               *(pScanline+1) = *(pDataline+1);
    1045. 

  1045.               *(pScanline+2) = *(pDataline+2);
    1046. 

  1046.               *(pScanline+3) = *(pDataline+3);
    1047. 

  1047.             }
    1048. 

  1048.             else
    1049. 

  1049.             {
    1050. 

  1050.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    1051. 

  1051.               {                        /* do alpha composing */
    1052. 

  1052.               int i;
    1053. 

  1053.               for (i=2; i >= 0; i--)
    1054. 

  1054.               {
    1055. 

  1055.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
    1056. 

  1056.               }
    1057. 

  1057.                                        /* alpha remains fully opaque !!! */
    1058. 

  1058.               }
    1059. 

  1059.               else
    1060. 

  1060.               {                        /* now blend */
    1061. 

  1061.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    1062. 

  1062.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    1063. 

  1063.                             iCr8, iCg8, iCb8, iCa8);
    1064. 

  1064.                                        /* and return the composed values */
    1065. 

  1065.                 *pScanline     = iCr8;
    1066. 

  1066.                 *(pScanline+1) = iCg8;
    1067. 

  1067.                 *(pScanline+2) = iCb8;
    1068. 

  1068.                 *(pScanline+3) = iCa8;
    1069. 

  1069.               }
    1070. 

  1070.             }
    1071. 

  1071.           }
    1072. 

  1072. 

  1073.           pScanline += (pData->iColinc << 2);
    1074. 

  1074.           pDataline += 4;
    1075. 

  1075.         }
    1076. 

  1076.       }
    1077. 

  1077.     }
    1078. 

  1078.   }
    1079. 

  1079. 

  1080.   check_update_region (pData);
    1081. 

  1081. 

  1082. #ifdef MNG_SUPPORT_TRACE
    1083. 

  1083.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
    1084. 

  1084. #endif
    1085. 

  1085. 

  1086.   return MNG_NOERROR;
    1087. 

  1087. }
    1088. 

  1088. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    1089. 

  1089. #else /* MNG_NO_16BIT_SUPPORT */
    1090. 

  1090. mng_retcode mng_display_rgba8 (mng_datap pData)
    1091. 

  1091. {
    1092. 

  1092.   mng_uint8p pScanline;
    1093. 

  1093.   mng_uint8p pDataline;
    1094. 

  1094.   mng_int32  iX;
    1095. 

  1095.   mng_uint8  iFGa8, iBGa8, iCa8;
    1096. 

  1096.   mng_uint8  iCr8, iCg8, iCb8;
    1097. 

  1097. 

  1098. #ifdef MNG_SUPPORT_TRACE
    1099. 

  1099.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_START);
    1100. 

  1100. #endif
    1101. 

  1101.                                        /* viewable row ? */
    1102. 

  1102.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    1103. 

  1103.   {                                    /* address destination row */
    1104. 

  1104.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    1105. 

  1105.                                                    pData->iRow + pData->iDestt -
    1106. 

  1106.                                                    pData->iSourcet);
    1107. 

  1107.                                        /* adjust destination row starting-point */
    1108. 

  1108.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    1109. 

  1109.     pDataline = pData->pRGBArow;       /* address source row */
    1110. 

  1110. 

  1111.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    1112. 

  1112. 

  1113.     if (pData->bIsOpaque)              /* forget about transparency ? */
    1114. 

  1114.     {
    1115. 

  1115.       {
    1116. 

  1116.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1117. 

  1117.              iX += pData->iColinc)
    1118. 

  1118.         {                              /* copy the values */
    1119. 

  1119.           *pScanline     = *pDataline;
    1120. 

  1120.           *(pScanline+1) = *(pDataline+1);
    1121. 

  1121.           *(pScanline+2) = *(pDataline+2);
    1122. 

  1122.           *(pScanline+3) = *(pDataline+3);
    1123. 

  1123. 

  1124.           pScanline += (pData->iColinc << 2);
    1125. 

  1125.           pDataline += 4;
    1126. 

  1126.         }
    1127. 

  1127.       }
    1128. 

  1128.     }
    1129. 

  1129.     else
    1130. 

  1130.     {
    1131. 

  1131.       {
    1132. 

  1132.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1133. 

  1133.              iX += pData->iColinc)
    1134. 

  1134.         {
    1135. 

  1135.           iFGa8 = *(pDataline+3);      /* get alpha values */
    1136. 

  1136.           iBGa8 = *(pScanline+3);
    1137. 

  1137. 

  1138.           if (iFGa8)                   /* any opacity at all ? */
    1139. 

  1139.           {                            /* fully opaque or background fully transparent ? */
    1140. 

  1140.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    1141. 

  1141.             {                          /* then simply copy the values */
    1142. 

  1142.               *pScanline     = *pDataline;
    1143. 

  1143.               *(pScanline+1) = *(pDataline+1);
    1144. 

  1144.               *(pScanline+2) = *(pDataline+2);
    1145. 

  1145.               *(pScanline+3) = *(pDataline+3);
    1146. 

  1146.             }
    1147. 

  1147.             else
    1148. 

  1148.             {
    1149. 

  1149.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    1150. 

  1150.               {                        /* do alpha composing */
    1151. 

  1151. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    1152. 

  1152.               int i;
    1153. 

  1153.               for (i=2; i >= 0; i--)
    1154. 

  1154.               {
    1155. 

  1155.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
    1156. 

  1156.               }
    1157. 

  1157. #else
    1158. 

  1158.                 MNG_COMPOSE8 (*pScanline,     *pDataline,     iFGa8, *pScanline    );
    1159. 

  1159.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
    1160. 

  1160.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iFGa8, *(pScanline+2));
    1161. 

  1161. #endif
    1162. 

  1162.                                        /* alpha remains fully opaque !!! */
    1163. 

  1163.               }
    1164. 

  1164.               else
    1165. 

  1165.               {                        /* now blend */
    1166. 

  1166.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    1167. 

  1167.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    1168. 

  1168.                             iCr8, iCg8, iCb8, iCa8);
    1169. 

  1169.                                        /* and return the composed values */
    1170. 

  1170.                 *pScanline     = iCr8;
    1171. 

  1171.                 *(pScanline+1) = iCg8;
    1172. 

  1172.                 *(pScanline+2) = iCb8;
    1173. 

  1173.                 *(pScanline+3) = iCa8;
    1174. 

  1174.               }
    1175. 

  1175.             }
    1176. 

  1176.           }
    1177. 

  1177. 

  1178.           pScanline += (pData->iColinc << 2);
    1179. 

  1179.           pDataline += 4;
    1180. 

  1180.         }
    1181. 

  1181.       }
    1182. 

  1182.     }
    1183. 

  1183.   }
    1184. 

  1184. 

  1185.   check_update_region (pData);
    1186. 

  1186. 

  1187. #ifdef MNG_SUPPORT_TRACE
    1188. 

  1188.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8, MNG_LC_END);
    1189. 

  1189. #endif
    1190. 

  1190. 

  1191.   return MNG_NOERROR;
    1192. 

  1192. }
    1193. 

  1193. #endif /* MNG_NO_16BIT_SUPPORT */
    1194. 

  1194. #endif /* MNG_SKIPCANVAS_RGBA8 */
    1195. 

  1195. 

  1196. /* ************************************************************************** */
    1197. 

  1197. 

  1198. #ifndef MNG_SKIPCANVAS_RGBA8_PM
    1199. 

  1199. #ifndef MNG_NO_16BIT_SUPPORT
    1200. 

  1200. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    1201. 

  1201. mng_retcode mng_display_rgba8_pm (mng_datap pData)
    1202. 

  1202. {
    1203. 

  1203.   mng_uint8p pScanline;
    1204. 

  1204.   mng_uint8p pDataline;
    1205. 

  1205.   mng_int32  iX;
    1206. 

  1206.   mng_uint32 s, t;
    1207. 

  1207. 

  1208. #ifdef MNG_SUPPORT_TRACE
    1209. 

  1209.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
    1210. 

  1210. #endif
    1211. 

  1211.                                        /* viewable row ? */
    1212. 

  1212.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    1213. 

  1213.   {                                    /* address destination row */
    1214. 

  1214.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    1215. 

  1215.                                                    pData->iRow + pData->iDestt -
    1216. 

  1216.                                                    pData->iSourcet);
    1217. 

  1217.                                        /* adjust destination row starting-point */
    1218. 

  1218.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    1219. 

  1219.     pDataline = pData->pRGBArow;       /* address source row */
    1220. 

  1220. 

  1221.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    1222. 

  1222.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    1223. 

  1223.     else
    1224. 

  1224.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    1225. 

  1225. 

  1226.     if (pData->bIsOpaque)              /* forget about transparency ? */
    1227. 

  1227.     {
    1228. 

  1228.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1229. 

  1229.       {
    1230. 

  1230.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1231. 

  1231.              iX += pData->iColinc)
    1232. 

  1232.         {                              /* scale down by dropping the LSB */
    1233. 

  1233. 		  if ((s = pDataline[6]) == 0)
    1234. 

  1234. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    1235. 

  1235. 		  else
    1236. 

  1236. 		  {
    1237. 

  1237. 			if (s == 255)
    1238. 

  1238. 			{
    1239. 

  1239.               pScanline[0] = pDataline[0];
    1240. 

  1240.               pScanline[1] = pDataline[2];
    1241. 

  1241. 		      pScanline[2] = pDataline[4];
    1242. 

  1242.               pScanline[3] = 255;
    1243. 

  1243. 			}
    1244. 

  1244. 			else
    1245. 

  1245. 			{
    1246. 

  1246. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1247. 

  1247.               int i;
    1248. 

  1248.               for (i=2; i >= 0; i--)
    1249. 

  1249.               {
    1250. 

  1250.                 pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
    1251. 

  1251.               }
    1252. 

  1252. #else
    1253. 

  1253.               pScanline[0] = DIV255B8(s * pDataline[0]);
    1254. 

  1254.               pScanline[1] = DIV255B8(s * pDataline[2]);
    1255. 

  1255.               pScanline[2] = DIV255B8(s * pDataline[4]);
    1256. 

  1256. #endif
    1257. 

  1257.               pScanline[3] = (mng_uint8)s;
    1258. 

  1258. 			}
    1259. 

  1259. 		  }
    1260. 

  1260.           pScanline += (pData->iColinc << 2);
    1261. 

  1261.           pDataline += 8;
    1262. 

  1262.         }
    1263. 

  1263.       }
    1264. 

  1264.       else
    1265. 

  1265.       {
    1266. 

  1266.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1267. 

  1267.              iX += pData->iColinc)
    1268. 

  1268.         {                              /* copy the values and premultiply */
    1269. 

  1269. 		  if ((s = pDataline[3]) == 0)
    1270. 

  1270. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    1271. 

  1271. 		  else
    1272. 

  1272. 		  {
    1273. 

  1273. 			if (s == 255)
    1274. 

  1274. 			{
    1275. 

  1275. #ifdef MNG_BIGENDIAN_SUPPORTED
    1276. 

  1276.               *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
    1277. 

  1277. #else
    1278. 

  1278.               pScanline[0] = pDataline[0];
    1279. 

  1279.               pScanline[1] = pDataline[1];
    1280. 

  1280. 		      pScanline[2] = pDataline[2];
    1281. 

  1281.               pScanline[3] = 255;
    1282. 

  1282. #endif
    1283. 

  1283. 			}
    1284. 

  1284. 			else
    1285. 

  1285. 			{
    1286. 

  1286. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1287. 

  1287.               int i;
    1288. 

  1288.               for (i=2; i >= 0; i--)
    1289. 

  1289.               {
    1290. 

  1290.                 pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
    1291. 

  1291.               }
    1292. 

  1292. #else
    1293. 

  1293.               pScanline[0] = DIV255B8(s * pDataline[0]);
    1294. 

  1294.               pScanline[1] = DIV255B8(s * pDataline[1]);
    1295. 

  1295. 		      pScanline[2] = DIV255B8(s * pDataline[2]);
    1296. 

  1296. #endif
    1297. 

  1297.               pScanline[3] = (mng_uint8)s;
    1298. 

  1298. 			}
    1299. 

  1299. 		  }
    1300. 

  1300. 

  1301.           pScanline += (pData->iColinc << 2);
    1302. 

  1302.           pDataline += 4;
    1303. 

  1303.         }
    1304. 

  1304.       }
    1305. 

  1305.     }
    1306. 

  1306.     else
    1307. 

  1307.     {
    1308. 

  1308.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1309. 

  1309.       {
    1310. 

  1310.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1311. 

  1311.              iX += pData->iColinc)
    1312. 

  1312.         {                              /* get alpha values */
    1313. 

  1313.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    1314. 

  1314.           {                            /* fully opaque or background fully transparent ? */
    1315. 

  1315.             if (s == 255)
    1316. 

  1316.             {                          /* plain copy it */
    1317. 

  1317.               pScanline[0] = pDataline[0];
    1318. 

  1318.               pScanline[1] = pDataline[2];
    1319. 

  1319.               pScanline[2] = pDataline[4];
    1320. 

  1320.               pScanline[3] = 255;
    1321. 

  1321.             }
    1322. 

  1322.             else
    1323. 

  1323.             {                          /* now blend (premultiplied) */
    1324. 

  1324. 			  t = 255 - s;
    1325. 

  1325. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1326. 

  1326.               {
    1327. 

  1327.                 int i;
    1328. 

  1328.                 for (i=2; i >= 0; i--)
    1329. 

  1329.                 {
    1330. 

  1330.                   pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
    1331. 

  1331.                      pScanline[2-i]);
    1332. 

  1332.                 }
    1333. 

  1333.               }
    1334. 

  1334. #else
    1335. 

  1335.               pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
    1336. 

  1336.               pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    1337. 

  1337. 			  pScanline[2] = DIV255B8(s * pDataline[4] + t * pScanline[2]);
    1338. 

  1338. #endif
    1339. 

  1339.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    1340. 

  1340.             }
    1341. 

  1341.           }
    1342. 

  1342. 

  1343.           pScanline += (pData->iColinc << 2);
    1344. 

  1344.           pDataline += 8;
    1345. 

  1345.         }
    1346. 

  1346.       }
    1347. 

  1347.       else
    1348. 

  1348.       {
    1349. 

  1349.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1350. 

  1350.              iX += pData->iColinc)
    1351. 

  1351.         {
    1352. 

  1352.           if ((s = pDataline[3]) != 0) /* any opacity at all ? */
    1353. 

  1353.           {                            /* fully opaque ? */
    1354. 

  1354.             if (s == 255)
    1355. 

  1355.             {                          /* then simply copy the values */
    1356. 

  1356. #ifdef MNG_BIGENDIAN_SUPPORTED
    1357. 

  1357.               *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
    1358. 

  1358. #else
    1359. 

  1359.               pScanline[0] = pDataline[0];
    1360. 

  1360.               pScanline[1] = pDataline[1];
    1361. 

  1361.               pScanline[2] = pDataline[2];
    1362. 

  1362.               pScanline[3] = 255;
    1363. 

  1363. #endif
    1364. 

  1364.             }
    1365. 

  1365.             else
    1366. 

  1366.             {                          /* now blend (premultiplied) */
    1367. 

  1367. 			  t = 255 - s;
    1368. 

  1368. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1369. 

  1369.               {
    1370. 

  1370.                 int i;
    1371. 

  1371.                 for (i=2; i >= 0; i--)
    1372. 

  1372.                 {
    1373. 

  1373.                   pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
    1374. 

  1374.                      pScanline[2-i]);
    1375. 

  1375.                 }
    1376. 

  1376.               }
    1377. 

  1377. #else
    1378. 

  1378.               pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
    1379. 

  1379.               pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
    1380. 

  1380. 			  pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    1381. 

  1381. #endif
    1382. 

  1382.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    1383. 

  1383.             }
    1384. 

  1384.           }
    1385. 

  1385. 

  1386.           pScanline += (pData->iColinc << 2);
    1387. 

  1387.           pDataline += 4;
    1388. 

  1388.         }
    1389. 

  1389.       }
    1390. 

  1390.     }
    1391. 

  1391.   }
    1392. 

  1392. 

  1393.   check_update_region (pData);
    1394. 

  1394. 

  1395. #ifdef MNG_SUPPORT_TRACE
    1396. 

  1396.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
    1397. 

  1397. #endif
    1398. 

  1398. 

  1399.   return MNG_NOERROR;
    1400. 

  1400. }
    1401. 

  1401. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    1402. 

  1402. mng_retcode mng_display_rgba8_pm (mng_datap pData)
    1403. 

  1403. {
    1404. 

  1404.   mng_uint8p pScanline;
    1405. 

  1405.   mng_uint8p pDataline;
    1406. 

  1406.   mng_int32  iX;
    1407. 

  1407.   mng_uint32 s, t;
    1408. 

  1408.   mng_uint8  iBps;
    1409. 

  1409. 

  1410. #ifdef MNG_SUPPORT_TRACE
    1411. 

  1411.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
    1412. 

  1412. #endif
    1413. 

  1413.                   
    1414. 

  1414.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    1415. 

  1415.                                        /* viewable row ? */
    1416. 

  1416.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    1417. 

  1417.   {                                    /* address destination row */
    1418. 

  1418.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    1419. 

  1419.                                                    pData->iRow + pData->iDestt -
    1420. 

  1420.                                                    pData->iSourcet);
    1421. 

  1421.                                        /* adjust destination row starting-point */
    1422. 

  1422.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    1423. 

  1423.     pDataline = pData->pRGBArow;       /* address source row */
    1424. 

  1424. 

  1425.     /* adjust source row starting-point */
    1426. 

  1426.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    1427. 

  1427. 

  1428.     if (pData->bIsOpaque)              /* forget about transparency ? */
    1429. 

  1429.     {
    1430. 

  1430.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1431. 

  1431.       {
    1432. 

  1432.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1433. 

  1433.              iX += pData->iColinc)
    1434. 

  1434.         {                              /* scale down by dropping the LSB */
    1435. 

  1435. 		  if ((s = pDataline[6]) == 0)
    1436. 

  1436. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    1437. 

  1437. 		  else
    1438. 

  1438. 		  {
    1439. 

  1439. 			if (s == 255)
    1440. 

  1440. 			{
    1441. 

  1441.               pScanline[0] = pDataline[0];
    1442. 

  1442.               pScanline[1] = pDataline[2];
    1443. 

  1443. 		      pScanline[2] = pDataline[4];
    1444. 

  1444.               pScanline[3] = 255;
    1445. 

  1445. 			}
    1446. 

  1446. 			else
    1447. 

  1447. 			{
    1448. 

  1448. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1449. 

  1449.               int i;
    1450. 

  1450.               for (i=2; i >= 0; i--)
    1451. 

  1451.               {
    1452. 

  1452.                 pScanline[2-i] = DIV255B8(s * pDataline[4-i-i]);
    1453. 

  1453.               }
    1454. 

  1454. #else
    1455. 

  1455.               pScanline[0] = DIV255B8(s * pDataline[0]);
    1456. 

  1456.               pScanline[1] = DIV255B8(s * pDataline[2]);
    1457. 

  1457.               pScanline[2] = DIV255B8(s * pDataline[4]);
    1458. 

  1458. #endif
    1459. 

  1459.               pScanline[3] = (mng_uint8)s;
    1460. 

  1460. 			}
    1461. 

  1461. 		  }
    1462. 

  1462.           pScanline += (pData->iColinc << 2);
    1463. 

  1463.           pDataline += 8;
    1464. 

  1464.         }
    1465. 

  1465.       }
    1466. 

  1466.       else
    1467. 

  1467.       {
    1468. 

  1468.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1469. 

  1469.              iX += pData->iColinc)
    1470. 

  1470.         {                              /* copy the values and premultiply */
    1471. 

  1471. 		  if ((s = pDataline[3]) == 0)
    1472. 

  1472. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    1473. 

  1473. 		  else
    1474. 

  1474. 		  {
    1475. 

  1475. 			if (s == 255)
    1476. 

  1476. 			{
    1477. 

  1477. #ifdef MNG_BIGENDIAN_SUPPORTED
    1478. 

  1478.               *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
    1479. 

  1479. #else
    1480. 

  1480.               pScanline[0] = pDataline[0];
    1481. 

  1481.               pScanline[1] = pDataline[1];
    1482. 

  1482. 		      pScanline[2] = pDataline[2];
    1483. 

  1483.               pScanline[3] = 255;
    1484. 

  1484. #endif
    1485. 

  1485. 			}
    1486. 

  1486. 			else
    1487. 

  1487. 			{
    1488. 

  1488. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1489. 

  1489.               int i;
    1490. 

  1490.               for (i=2; i >= 0; i--)
    1491. 

  1491.               {
    1492. 

  1492.                 pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
    1493. 

  1493.               }
    1494. 

  1494. #else
    1495. 

  1495.               pScanline[0] = DIV255B8(s * pDataline[0]);
    1496. 

  1496.               pScanline[1] = DIV255B8(s * pDataline[1]);
    1497. 

  1497. 		      pScanline[2] = DIV255B8(s * pDataline[2]);
    1498. 

  1498. #endif
    1499. 

  1499.               pScanline[3] = (mng_uint8)s;
    1500. 

  1500. 			}
    1501. 

  1501. 		  }
    1502. 

  1502. 

  1503.           pScanline += (pData->iColinc << 2);
    1504. 

  1504.           pDataline += 4;
    1505. 

  1505.         }
    1506. 

  1506.       }
    1507. 

  1507.     }
    1508. 

  1508.     else
    1509. 

  1509.     {
    1510. 

  1510.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1511. 

  1511.       {
    1512. 

  1512.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1513. 

  1513.              iX += pData->iColinc)
    1514. 

  1514.         {                              /* get alpha values */
    1515. 

  1515.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    1516. 

  1516.           {                            /* fully opaque or background fully transparent ? */
    1517. 

  1517.             if (s == 255)
    1518. 

  1518.             {                          /* plain copy it */
    1519. 

  1519.               pScanline[0] = pDataline[0];
    1520. 

  1520.               pScanline[1] = pDataline[2];
    1521. 

  1521.               pScanline[2] = pDataline[4];
    1522. 

  1522.               pScanline[3] = 255;
    1523. 

  1523.             }
    1524. 

  1524.             else
    1525. 

  1525.             {                          /* now blend (premultiplied) */
    1526. 

  1526. 			  t = 255 - s;
    1527. 

  1527. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1528. 

  1528.               {
    1529. 

  1529.                 int i;
    1530. 

  1530.                 for (i=2; i >= 0; i--)
    1531. 

  1531.                 {
    1532. 

  1532.                   pScanline[2-i] = DIV255B8(s * pDataline[4-i-i] + t *
    1533. 

  1533.                      pScanline[2-i]);
    1534. 

  1534.                 }
    1535. 

  1535.               }
    1536. 

  1536. #else
    1537. 

  1537.               pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
    1538. 

  1538.               pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    1539. 

  1539. 			  pScanline[2] = DIV255B8(s * pDataline[4] + t * pScanline[2]);
    1540. 

  1540. #endif
    1541. 

  1541.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    1542. 

  1542.             }
    1543. 

  1543.           }
    1544. 

  1544. 

  1545.           pScanline += (pData->iColinc << 2);
    1546. 

  1546.           pDataline += 8;
    1547. 

  1547.         }
    1548. 

  1548.       }
    1549. 

  1549.       else
    1550. 

  1550.       {
    1551. 

  1551.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1552. 

  1552.              iX += pData->iColinc)
    1553. 

  1553.         {
    1554. 

  1554.           if ((s = pDataline[3]) != 0) /* any opacity at all ? */
    1555. 

  1555.           {                            /* fully opaque ? */
    1556. 

  1556.             if (s == 255)
    1557. 

  1557.             {                          /* then simply copy the values */
    1558. 

  1558. #ifdef MNG_BIGENDIAN_SUPPORTED
    1559. 

  1559.               *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
    1560. 

  1560. #else
    1561. 

  1561.               pScanline[0] = pDataline[0];
    1562. 

  1562.               pScanline[1] = pDataline[1];
    1563. 

  1563.               pScanline[2] = pDataline[2];
    1564. 

  1564.               pScanline[3] = 255;
    1565. 

  1565. #endif
    1566. 

  1566.             }
    1567. 

  1567.             else
    1568. 

  1568.             {                          /* now blend (premultiplied) */
    1569. 

  1569. 			  t = 255 - s;
    1570. 

  1570. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1571. 

  1571.               {
    1572. 

  1572.                 int i;
    1573. 

  1573.                 for (i=2; i >= 0; i--)
    1574. 

  1574.                 {
    1575. 

  1575.                   pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
    1576. 

  1576.                      pScanline[2-i]);
    1577. 

  1577.                 }
    1578. 

  1578.               }
    1579. 

  1579. #else
    1580. 

  1580.               pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
    1581. 

  1581.               pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
    1582. 

  1582. 			  pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    1583. 

  1583. #endif
    1584. 

  1584.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    1585. 

  1585.             }
    1586. 

  1586.           }
    1587. 

  1587. 

  1588.           pScanline += (pData->iColinc << 2);
    1589. 

  1589.           pDataline += 4;
    1590. 

  1590.         }
    1591. 

  1591.       }
    1592. 

  1592.     }
    1593. 

  1593.   }
    1594. 

  1594. 

  1595.   check_update_region (pData);
    1596. 

  1596. 

  1597. #ifdef MNG_SUPPORT_TRACE
    1598. 

  1598.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
    1599. 

  1599. #endif
    1600. 

  1600. 

  1601.   return MNG_NOERROR;
    1602. 

  1602. }
    1603. 

  1603. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    1604. 

  1604. #else /* MNG_NO_16BIT_SUPPORT */
    1605. 

  1605. mng_retcode mng_display_rgba8_pm (mng_datap pData)
    1606. 

  1606. {
    1607. 

  1607.   mng_uint8p pScanline;
    1608. 

  1608.   mng_uint8p pDataline;
    1609. 

  1609.   mng_int32  iX;
    1610. 

  1610.   mng_uint32 s, t;
    1611. 

  1611. 

  1612. #ifdef MNG_SUPPORT_TRACE
    1613. 

  1613.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_START);
    1614. 

  1614. #endif
    1615. 

  1615.                                        /* viewable row ? */
    1616. 

  1616.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    1617. 

  1617.   {                                    /* address destination row */
    1618. 

  1618.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    1619. 

  1619.                                                    pData->iRow + pData->iDestt -
    1620. 

  1620.                                                    pData->iSourcet);
    1621. 

  1621.                                        /* adjust destination row starting-point */
    1622. 

  1622.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    1623. 

  1623.     pDataline = pData->pRGBArow;       /* address source row */
    1624. 

  1624. 

  1625.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    1626. 

  1626. 

  1627.     if (pData->bIsOpaque)              /* forget about transparency ? */
    1628. 

  1628.     {
    1629. 

  1629.       {
    1630. 

  1630.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1631. 

  1631.              iX += pData->iColinc)
    1632. 

  1632.         {                              /* copy the values and premultiply */
    1633. 

  1633. 		  if ((s = pDataline[3]) == 0)
    1634. 

  1634. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    1635. 

  1635. 		  else
    1636. 

  1636. 		  {
    1637. 

  1637. 			if (s == 255)
    1638. 

  1638. 			{
    1639. 

  1639. #ifdef MNG_BIGENDIAN_SUPPORTED
    1640. 

  1640.               *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
    1641. 

  1641. #else
    1642. 

  1642.               pScanline[0] = pDataline[0];
    1643. 

  1643.               pScanline[1] = pDataline[1];
    1644. 

  1644. 		      pScanline[2] = pDataline[2];
    1645. 

  1645.               pScanline[3] = 255;
    1646. 

  1646. #endif
    1647. 

  1647. 			}
    1648. 

  1648. 			else
    1649. 

  1649. 			{
    1650. 

  1650. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1651. 

  1651.               int i;
    1652. 

  1652.               for (i=2; i >= 0; i--)
    1653. 

  1653.               {
    1654. 

  1654.                 pScanline[2-i] = DIV255B8(s * pDataline[2-i]);
    1655. 

  1655.               }
    1656. 

  1656. #else
    1657. 

  1657.               pScanline[0] = DIV255B8(s * pDataline[0]);
    1658. 

  1658.               pScanline[1] = DIV255B8(s * pDataline[1]);
    1659. 

  1659. 		      pScanline[2] = DIV255B8(s * pDataline[2]);
    1660. 

  1660. #endif
    1661. 

  1661.               pScanline[3] = (mng_uint8)s;
    1662. 

  1662. 			}
    1663. 

  1663. 		  }
    1664. 

  1664. 

  1665.           pScanline += (pData->iColinc << 2);
    1666. 

  1666.           pDataline += 4;
    1667. 

  1667.         }
    1668. 

  1668.       }
    1669. 

  1669.     }
    1670. 

  1670.     else
    1671. 

  1671.     {
    1672. 

  1672.       {
    1673. 

  1673.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1674. 

  1674.              iX += pData->iColinc)
    1675. 

  1675.         {
    1676. 

  1676.           if ((s = pDataline[3]) != 0) /* any opacity at all ? */
    1677. 

  1677.           {                            /* fully opaque ? */
    1678. 

  1678.             if (s == 255)
    1679. 

  1679.             {                          /* then simply copy the values */
    1680. 

  1680. #ifdef MNG_BIGENDIAN_SUPPORTED
    1681. 

  1681.               *(mng_uint32*)pScanline = (*(mng_uint32*)pDataline) | 0x000000FF;
    1682. 

  1682. #else
    1683. 

  1683.               pScanline[0] = pDataline[0];
    1684. 

  1684.               pScanline[1] = pDataline[1];
    1685. 

  1685.               pScanline[2] = pDataline[2];
    1686. 

  1686.               pScanline[3] = 255;
    1687. 

  1687. #endif
    1688. 

  1688.             }
    1689. 

  1689.             else
    1690. 

  1690.             {                          /* now blend (premultiplied) */
    1691. 

  1691. 			  t = 255 - s;
    1692. 

  1692. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    1693. 

  1693.               {
    1694. 

  1694.                 int i;
    1695. 

  1695.                 for (i=2; i >= 0; i--)
    1696. 

  1696.                 {
    1697. 

  1697.                   pScanline[2-i] = DIV255B8(s * pDataline[2-i] + t *
    1698. 

  1698.                      pScanline[2-i]);
    1699. 

  1699.                 }
    1700. 

  1700.               }
    1701. 

  1701. #else
    1702. 

  1702.               pScanline[0] = DIV255B8(s * pDataline[0] + t * pScanline[0]);
    1703. 

  1703.               pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
    1704. 

  1704. 			  pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    1705. 

  1705. #endif
    1706. 

  1706.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    1707. 

  1707.             }
    1708. 

  1708.           }
    1709. 

  1709. 

  1710.           pScanline += (pData->iColinc << 2);
    1711. 

  1711.           pDataline += 4;
    1712. 

  1712.         }
    1713. 

  1713.       }
    1714. 

  1714.     }
    1715. 

  1715.   }
    1716. 

  1716. 

  1717.   check_update_region (pData);
    1718. 

  1718. 

  1719. #ifdef MNG_SUPPORT_TRACE
    1720. 

  1720.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA8_PM, MNG_LC_END);
    1721. 

  1721. #endif
    1722. 

  1722. 

  1723.   return MNG_NOERROR;
    1724. 

  1724. }
    1725. 

  1725. #endif /* MNG_NO_16BIT_SUPPORT */
    1726. 

  1726. #endif /* MNG_SKIPCANVAS_RGBA8_PM */
    1727. 

  1727. 

  1728. /* ************************************************************************** */
    1729. 

  1729. 

  1730. #ifndef MNG_SKIPCANVAS_ARGB8
    1731. 

  1731. #ifndef MNG_NO_16BIT_SUPPORT
    1732. 

  1732. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    1733. 

  1733. mng_retcode mng_display_argb8 (mng_datap pData)
    1734. 

  1734. {
    1735. 

  1735.   mng_uint8p pScanline;
    1736. 

  1736.   mng_uint8p pDataline;
    1737. 

  1737.   mng_int32  iX;
    1738. 

  1738.   mng_uint8  iFGa8, iBGa8, iCa8;
    1739. 

  1739.   mng_uint16 iFGa16, iBGa16, iCa16;
    1740. 

  1740.   mng_uint16 iFGr16, iFGg16, iFGb16;
    1741. 

  1741.   mng_uint16 iBGr16, iBGg16, iBGb16;
    1742. 

  1742.   mng_uint16 iCr16, iCg16, iCb16;
    1743. 

  1743.   mng_uint8  iCr8, iCg8, iCb8;
    1744. 

  1744. 

  1745. #ifdef MNG_SUPPORT_TRACE
    1746. 

  1746.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_START);
    1747. 

  1747. #endif
    1748. 

  1748. 

  1749.                                        /* viewable row ? */
    1750. 

  1750.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    1751. 

  1751.   {                                    /* address destination row */
    1752. 

  1752.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    1753. 

  1753.                                                    pData->iRow + pData->iDestt -
    1754. 

  1754.                                                    pData->iSourcet);
    1755. 

  1755.                                        /* adjust destination row starting-point */
    1756. 

  1756.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    1757. 

  1757.     pDataline = pData->pRGBArow;       /* address source row */
    1758. 

  1758. 

  1759.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    1760. 

  1760.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    1761. 

  1761.     else
    1762. 

  1762.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    1763. 

  1763. 

  1764.     if (pData->bIsOpaque)              /* forget about transparency ? */
    1765. 

  1765.     {
    1766. 

  1766.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1767. 

  1767.       {
    1768. 

  1768.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1769. 

  1769.              iX += pData->iColinc)
    1770. 

  1770.         {                              /* scale down by dropping the LSB */
    1771. 

  1771.           *pScanline     = *(pDataline+6);
    1772. 

  1772.           *(pScanline+1) = *pDataline;
    1773. 

  1773.           *(pScanline+2) = *(pDataline+2);
    1774. 

  1774.           *(pScanline+3) = *(pDataline+4);
    1775. 

  1775. 

  1776.           pScanline += (pData->iColinc << 2);
    1777. 

  1777.           pDataline += 8;
    1778. 

  1778.         }
    1779. 

  1779.       }
    1780. 

  1780.       else
    1781. 

  1781.       {
    1782. 

  1782.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1783. 

  1783.              iX += pData->iColinc)
    1784. 

  1784.         {                              /* copy the values */
    1785. 

  1785.           *pScanline     = *(pDataline+3);
    1786. 

  1786.           *(pScanline+1) = *pDataline;
    1787. 

  1787.           *(pScanline+2) = *(pDataline+1);
    1788. 

  1788.           *(pScanline+3) = *(pDataline+2);
    1789. 

  1789. 

  1790.           pScanline += (pData->iColinc << 2);
    1791. 

  1791.           pDataline += 4;
    1792. 

  1792.         }
    1793. 

  1793.       }
    1794. 

  1794.     }
    1795. 

  1795.     else
    1796. 

  1796.     {
    1797. 

  1797.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1798. 

  1798.       {
    1799. 

  1799.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1800. 

  1800.              iX += pData->iColinc)
    1801. 

  1801.         {                              /* get alpha values */
    1802. 

  1802.           iFGa16 = mng_get_uint16 (pDataline+6);
    1803. 

  1803.           iBGa16 = (mng_uint16)(*pScanline);
    1804. 

  1804.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    1805. 

  1805. 

  1806.           if (iFGa16)                  /* any opacity at all ? */
    1807. 

  1807.           {                            /* fully opaque or background fully transparent ? */
    1808. 

  1808.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    1809. 

  1809.             {                          /* plain copy it */
    1810. 

  1810.               *pScanline     = *(pDataline+6);
    1811. 

  1811.               *(pScanline+1) = *pDataline;
    1812. 

  1812.               *(pScanline+2) = *(pDataline+2);
    1813. 

  1813.               *(pScanline+3) = *(pDataline+4);
    1814. 

  1814.             }
    1815. 

  1815.             else
    1816. 

  1816.             {
    1817. 

  1817.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    1818. 

  1818.               {                        /* get the proper values */
    1819. 

  1819.                 iFGr16 = mng_get_uint16 (pDataline  );
    1820. 

  1820.                 iFGg16 = mng_get_uint16 (pDataline+2);
    1821. 

  1821.                 iFGb16 = mng_get_uint16 (pDataline+4);
    1822. 

  1822.                                        /* scale background up */
    1823. 

  1823.                 iBGr16 = (mng_uint16)(*(pScanline+1));
    1824. 

  1824.                 iBGg16 = (mng_uint16)(*(pScanline+2));
    1825. 

  1825.                 iBGb16 = (mng_uint16)(*(pScanline+3));
    1826. 

  1826.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    1827. 

  1827.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    1828. 

  1828.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    1829. 

  1829.                                        /* now compose */
    1830. 

  1830.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    1831. 

  1831.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    1832. 

  1832.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    1833. 

  1833.                                        /* and return the composed values */
    1834. 

  1834.                                        /* alpha remains fully opaque !!! */
    1835. 

  1835.                 *(pScanline+1) = (mng_uint8)(iFGr16 >> 8);
    1836. 

  1836.                 *(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
    1837. 

  1837.                 *(pScanline+3) = (mng_uint8)(iFGb16 >> 8);
    1838. 

  1838.               }
    1839. 

  1839.               else
    1840. 

  1840.               {                        /* scale background up */
    1841. 

  1841.                 iBGr16 = (mng_uint16)(*(pScanline+1));
    1842. 

  1842.                 iBGg16 = (mng_uint16)(*(pScanline+2));
    1843. 

  1843.                 iBGb16 = (mng_uint16)(*(pScanline+3));
    1844. 

  1844.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    1845. 

  1845.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    1846. 

  1846.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    1847. 

  1847.                                        /* let's blend */
    1848. 

  1848.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    1849. 

  1849.                              mng_get_uint16 (pDataline+2),
    1850. 

  1850.                              mng_get_uint16 (pDataline+4), iFGa16,
    1851. 

  1851.                              iBGr16, iBGg16, iBGb16, iBGa16,
    1852. 

  1852.                              iCr16,  iCg16,  iCb16,  iCa16);
    1853. 

  1853.                                        /* and return the composed values */
    1854. 

  1854.                 *pScanline     = (mng_uint8)(iCa16 >> 8);
    1855. 

  1855.                 *(pScanline+1) = (mng_uint8)(iCr16 >> 8);
    1856. 

  1856.                 *(pScanline+2) = (mng_uint8)(iCg16 >> 8);
    1857. 

  1857.                 *(pScanline+3) = (mng_uint8)(iCb16 >> 8);
    1858. 

  1858.               }
    1859. 

  1859.             }
    1860. 

  1860.           }
    1861. 

  1861. 

  1862.           pScanline += (pData->iColinc << 2);
    1863. 

  1863.           pDataline += 8;
    1864. 

  1864.         }
    1865. 

  1865.       }
    1866. 

  1866.       else
    1867. 

  1867.       {
    1868. 

  1868.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1869. 

  1869.              iX += pData->iColinc)
    1870. 

  1870.         {
    1871. 

  1871.           iFGa8 = *(pDataline+3);      /* get alpha values */
    1872. 

  1872.           iBGa8 = *pScanline;
    1873. 

  1873. 

  1874.           if (iFGa8)                   /* any opacity at all ? */
    1875. 

  1875.           {                            /* fully opaque or background fully transparent ? */
    1876. 

  1876.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    1877. 

  1877.             {                          /* then simply copy the values */
    1878. 

  1878.               *pScanline     = *(pDataline+3);
    1879. 

  1879.               *(pScanline+1) = *pDataline;
    1880. 

  1880.               *(pScanline+2) = *(pDataline+1);
    1881. 

  1881.               *(pScanline+3) = *(pDataline+2);
    1882. 

  1882.             }
    1883. 

  1883.             else
    1884. 

  1884.             {
    1885. 

  1885.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    1886. 

  1886.               {                        /* do simple alpha composing */
    1887. 

  1887.                                        /* alpha itself remains fully opaque !!! */
    1888. 

  1888.               }
    1889. 

  1889.               else
    1890. 

  1890.               {                        /* now blend */
    1891. 

  1891.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    1892. 

  1892.                             *(pScanline+1), *(pScanline+2), *(pScanline+3), iBGa8,
    1893. 

  1893.                             iCr8, iCg8, iCb8, iCa8);
    1894. 

  1894.                                        /* and return the composed values */
    1895. 

  1895.                 *pScanline     = iCa8;
    1896. 

  1896.                 *(pScanline+1) = iCr8;
    1897. 

  1897.                 *(pScanline+2) = iCg8;
    1898. 

  1898.                 *(pScanline+3) = iCb8;
    1899. 

  1899.               }
    1900. 

  1900.             }
    1901. 

  1901.           }
    1902. 

  1902. 

  1903.           pScanline += (pData->iColinc << 2);
    1904. 

  1904.           pDataline += 4;
    1905. 

  1905.         }
    1906. 

  1906.       }
    1907. 

  1907.     }
    1908. 

  1908.   }
    1909. 

  1909. 

  1910.   check_update_region (pData);
    1911. 

  1911. 

  1912. #ifdef MNG_SUPPORT_TRACE
    1913. 

  1913.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_END);
    1914. 

  1914. #endif
    1915. 

  1915. 

  1916.   return MNG_NOERROR;
    1917. 

  1917. }
    1918. 

  1918. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    1919. 

  1919. mng_retcode mng_display_argb8 (mng_datap pData)
    1920. 

  1920. {
    1921. 

  1921.   mng_uint8p pScanline;
    1922. 

  1922.   mng_uint8p pDataline;
    1923. 

  1923.   mng_int32  iX;
    1924. 

  1924.   mng_uint8  iFGa8, iBGa8, iCa8;
    1925. 

  1925.   mng_uint16 iFGa16, iBGa16, iCa16;
    1926. 

  1926.   mng_uint16 iFGg16;
    1927. 

  1927.   mng_uint16 iBGr16, iBGg16, iBGb16;
    1928. 

  1928.   mng_uint16 iCr16, iCg16, iCb16;
    1929. 

  1929.   mng_uint8  iCr8, iCg8, iCb8;
    1930. 

  1930.   mng_uint8  iBps;
    1931. 

  1931. 

  1932. #ifdef MNG_SUPPORT_TRACE
    1933. 

  1933.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_START);
    1934. 

  1934. #endif
    1935. 

  1935. 

  1936.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    1937. 

  1937.                                        /* viewable row ? */
    1938. 

  1938.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    1939. 

  1939.   {                                    /* address destination row */
    1940. 

  1940.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    1941. 

  1941.                                                    pData->iRow + pData->iDestt -
    1942. 

  1942.                                                    pData->iSourcet);
    1943. 

  1943.                                        /* adjust destination row starting-point */
    1944. 

  1944.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    1945. 

  1945.     pDataline = pData->pRGBArow;       /* address source row */
    1946. 

  1946. 

  1947.     /* adjust source row starting-point */
    1948. 

  1948.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    1949. 

  1949. 

  1950.     if (pData->bIsOpaque)              /* forget about transparency ? */
    1951. 

  1951.     {
    1952. 

  1952.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1953. 

  1953.              iX += pData->iColinc)
    1954. 

  1954.         {                              /* scale down by dropping the LSB */
    1955. 

  1955.           *pScanline     = *(pDataline+3*iBps);
    1956. 

  1956.           *(pScanline+1) = *pDataline;
    1957. 

  1957.           *(pScanline+2) = *(pDataline+iBps);
    1958. 

  1958.           *(pScanline+3) = *(pDataline+2*iBps);
    1959. 

  1959. 

  1960.           pScanline += (pData->iColinc << 2);
    1961. 

  1961.           pDataline += 4*iBps;
    1962. 

  1962.         }
    1963. 

  1963.     }
    1964. 

  1964.     else
    1965. 

  1965.     {
    1966. 

  1966.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    1967. 

  1967.       {
    1968. 

  1968.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    1969. 

  1969.              iX += pData->iColinc)
    1970. 

  1970.         {                              /* get alpha values */
    1971. 

  1971.           iFGa16 = mng_get_uint16 (pDataline+6);
    1972. 

  1972.           iBGa16 = (mng_uint16)(*pScanline);
    1973. 

  1973.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    1974. 

  1974. 

  1975.           if (iFGa16)                  /* any opacity at all ? */
    1976. 

  1976.           {                            /* fully opaque or background fully transparent ? */
    1977. 

  1977.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    1978. 

  1978.             {                          /* plain copy it */
    1979. 

  1979.               *pScanline     = *(pDataline+6);
    1980. 

  1980.               *(pScanline+1) = *pDataline;
    1981. 

  1981.               *(pScanline+2) = *(pDataline+2);
    1982. 

  1982.               *(pScanline+3) = *(pDataline+4);
    1983. 

  1983.             }
    1984. 

  1984.             else
    1985. 

  1985.             {
    1986. 

  1986.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    1987. 

  1987.               {                        /* get the proper values */
    1988. 

  1988.               int i;
    1989. 

  1989.               for (i=2; i >= 0; i--)
    1990. 

  1990.               {
    1991. 

  1991.                 iFGg16 = mng_get_uint16 (pDataline+i+i);
    1992. 

  1992.                                        /* scale background up */
    1993. 

  1993.                 iBGg16 = (mng_uint16)(*(pScanline+i+1));
    1994. 

  1994.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    1995. 

  1995.                                        /* now compose */
    1996. 

  1996.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    1997. 

  1997.                                        /* and return the composed values */
    1998. 

  1998.                                        /* alpha remains fully opaque !!! */
    1999. 

  1999.                 *(pScanline+i+1) = (mng_uint8)(iFGg16 >> 8);
    2000. 

  2000.               }
    2001. 

  2001.               }
    2002. 

  2002.               else
    2003. 

  2003.               {                        /* scale background up */
    2004. 

  2004.                 iBGr16 = (mng_uint16)(*(pScanline+1));
    2005. 

  2005.                 iBGg16 = (mng_uint16)(*(pScanline+2));
    2006. 

  2006.                 iBGb16 = (mng_uint16)(*(pScanline+3));
    2007. 

  2007.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    2008. 

  2008.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    2009. 

  2009.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    2010. 

  2010.                                        /* let's blend */
    2011. 

  2011.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    2012. 

  2012.                              mng_get_uint16 (pDataline+2),
    2013. 

  2013.                              mng_get_uint16 (pDataline+4), iFGa16,
    2014. 

  2014.                              iBGr16, iBGg16, iBGb16, iBGa16,
    2015. 

  2015.                              iCr16,  iCg16,  iCb16,  iCa16);
    2016. 

  2016.                                        /* and return the composed values */
    2017. 

  2017.                 *pScanline     = (mng_uint8)(iCa16 >> 8);
    2018. 

  2018.                 *(pScanline+1) = (mng_uint8)(iCr16 >> 8);
    2019. 

  2019.                 *(pScanline+2) = (mng_uint8)(iCg16 >> 8);
    2020. 

  2020.                 *(pScanline+3) = (mng_uint8)(iCb16 >> 8);
    2021. 

  2021.               }
    2022. 

  2022.             }
    2023. 

  2023.           }
    2024. 

  2024. 

  2025.           pScanline += (pData->iColinc << 2);
    2026. 

  2026.           pDataline += 8;
    2027. 

  2027.         }
    2028. 

  2028.       }
    2029. 

  2029.       else
    2030. 

  2030.       {
    2031. 

  2031.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2032. 

  2032.              iX += pData->iColinc)
    2033. 

  2033.         {
    2034. 

  2034.           iFGa8 = *(pDataline+3);      /* get alpha values */
    2035. 

  2035.           iBGa8 = *pScanline;
    2036. 

  2036. 

  2037.           if (iFGa8)                   /* any opacity at all ? */
    2038. 

  2038.           {                            /* fully opaque or background fully transparent ? */
    2039. 

  2039.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    2040. 

  2040.             {                          /* then simply copy the values */
    2041. 

  2041.               *pScanline     = *(pDataline+3);
    2042. 

  2042.               *(pScanline+1) = *pDataline;
    2043. 

  2043.               *(pScanline+2) = *(pDataline+1);
    2044. 

  2044.               *(pScanline+3) = *(pDataline+2);
    2045. 

  2045.             }
    2046. 

  2046.             else
    2047. 

  2047.             {
    2048. 

  2048.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    2049. 

  2049.               {                        /* do simple alpha composing */
    2050. 

  2050.                                        /* alpha itself remains fully opaque !!! */
    2051. 

  2051.               int i;
    2052. 

  2052.               for (i=2; i >= 0; i--)
    2053. 

  2053.               {
    2054. 

  2054.               MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+i), iFGa8, *(pScanline+i+1));
    2055. 

  2055.               }
    2056. 

  2056.               }
    2057. 

  2057.               else
    2058. 

  2058.               {                        /* now blend */
    2059. 

  2059.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    2060. 

  2060.                             *(pScanline+1), *(pScanline+2), *(pScanline+3), iBGa8,
    2061. 

  2061.                             iCr8, iCg8, iCb8, iCa8);
    2062. 

  2062.                                        /* and return the composed values */
    2063. 

  2063.                 *pScanline     = iCa8;
    2064. 

  2064.                 *(pScanline+1) = iCr8;
    2065. 

  2065.                 *(pScanline+2) = iCg8;
    2066. 

  2066.                 *(pScanline+3) = iCb8;
    2067. 

  2067.               }
    2068. 

  2068.             }
    2069. 

  2069.           }
    2070. 

  2070. 

  2071.           pScanline += (pData->iColinc << 2);
    2072. 

  2072.           pDataline += 4;
    2073. 

  2073.         }
    2074. 

  2074.       }
    2075. 

  2075.     }
    2076. 

  2076.   }
    2077. 

  2077. 

  2078.   check_update_region (pData);
    2079. 

  2079. 

  2080. #ifdef MNG_SUPPORT_TRACE
    2081. 

  2081.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_END);
    2082. 

  2082. #endif
    2083. 

  2083. 

  2084.   return MNG_NOERROR;
    2085. 

  2085. }
    2086. 

  2086. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    2087. 

  2087. #else /* MNG_NO_16BIT_SUPPORT */
    2088. 

  2088. mng_retcode mng_display_argb8 (mng_datap pData)
    2089. 

  2089. {
    2090. 

  2090.   mng_uint8p pScanline;
    2091. 

  2091.   mng_uint8p pDataline;
    2092. 

  2092.   mng_int32  iX;
    2093. 

  2093.   mng_uint8  iFGa8, iBGa8, iCa8;
    2094. 

  2094.   mng_uint8  iCr8, iCg8, iCb8;
    2095. 

  2095. 

  2096. #ifdef MNG_SUPPORT_TRACE
    2097. 

  2097.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_START);
    2098. 

  2098. #endif
    2099. 

  2099. 

  2100.                                        /* viewable row ? */
    2101. 

  2101.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    2102. 

  2102.   {                                    /* address destination row */
    2103. 

  2103.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    2104. 

  2104.                                                    pData->iRow + pData->iDestt -
    2105. 

  2105.                                                    pData->iSourcet);
    2106. 

  2106.                                        /* adjust destination row starting-point */
    2107. 

  2107.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    2108. 

  2108.     pDataline = pData->pRGBArow;       /* address source row */
    2109. 

  2109. 

  2110.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    2111. 

  2111. 

  2112.     if (pData->bIsOpaque)              /* forget about transparency ? */
    2113. 

  2113.     {
    2114. 

  2114.       {
    2115. 

  2115.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2116. 

  2116.              iX += pData->iColinc)
    2117. 

  2117.         {                              /* copy the values */
    2118. 

  2118.           *pScanline     = *(pDataline+3);
    2119. 

  2119.           *(pScanline+1) = *pDataline;
    2120. 

  2120.           *(pScanline+2) = *(pDataline+1);
    2121. 

  2121.           *(pScanline+3) = *(pDataline+2);
    2122. 

  2122. 

  2123.           pScanline += (pData->iColinc << 2);
    2124. 

  2124.           pDataline += 4;
    2125. 

  2125.         }
    2126. 

  2126.       }
    2127. 

  2127.     }
    2128. 

  2128.     else
    2129. 

  2129.     {
    2130. 

  2130.       {
    2131. 

  2131.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2132. 

  2132.              iX += pData->iColinc)
    2133. 

  2133.         {
    2134. 

  2134.           iFGa8 = *(pDataline+3);      /* get alpha values */
    2135. 

  2135.           iBGa8 = *pScanline;
    2136. 

  2136. 

  2137.           if (iFGa8)                   /* any opacity at all ? */
    2138. 

  2138.           {                            /* fully opaque or background fully transparent ? */
    2139. 

  2139.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    2140. 

  2140.             {                          /* then simply copy the values */
    2141. 

  2141.               *pScanline     = *(pDataline+3);
    2142. 

  2142.               *(pScanline+1) = *pDataline;
    2143. 

  2143.               *(pScanline+2) = *(pDataline+1);
    2144. 

  2144.               *(pScanline+3) = *(pDataline+2);
    2145. 

  2145.             }
    2146. 

  2146.             else
    2147. 

  2147.             {
    2148. 

  2148.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    2149. 

  2149.               {                        /* do simple alpha composing */
    2150. 

  2150.                                        /* alpha itself remains fully opaque !!! */
    2151. 

  2151. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    2152. 

  2152.               int i;
    2153. 

  2153.               for (i=2; i >= 0; i--)
    2154. 

  2154.               {
    2155. 

  2155.               MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+i), iFGa8, *(pScanline+i+1));
    2156. 

  2156.               }
    2157. 

  2157. #else
    2158. 

  2158.                 MNG_COMPOSE8 (*(pScanline+1), *pDataline,     iFGa8, *(pScanline+1));
    2159. 

  2159.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+1), iFGa8, *(pScanline+2));
    2160. 

  2160.                 MNG_COMPOSE8 (*(pScanline+3), *(pDataline+2), iFGa8, *(pScanline+3));
    2161. 

  2161. #endif
    2162. 

  2162.               }
    2163. 

  2163.               else
    2164. 

  2164.               {                        /* now blend */
    2165. 

  2165.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    2166. 

  2166.                             *(pScanline+1), *(pScanline+2), *(pScanline+3), iBGa8,
    2167. 

  2167.                             iCr8, iCg8, iCb8, iCa8);
    2168. 

  2168.                                        /* and return the composed values */
    2169. 

  2169.                 *pScanline     = iCa8;
    2170. 

  2170.                 *(pScanline+1) = iCr8;
    2171. 

  2171.                 *(pScanline+2) = iCg8;
    2172. 

  2172.                 *(pScanline+3) = iCb8;
    2173. 

  2173.               }
    2174. 

  2174.             }
    2175. 

  2175.           }
    2176. 

  2176. 

  2177.           pScanline += (pData->iColinc << 2);
    2178. 

  2178.           pDataline += 4;
    2179. 

  2179.         }
    2180. 

  2180.       }
    2181. 

  2181.     }
    2182. 

  2182.   }
    2183. 

  2183. 

  2184.   check_update_region (pData);
    2185. 

  2185. 

  2186. #ifdef MNG_SUPPORT_TRACE
    2187. 

  2187.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8, MNG_LC_END);
    2188. 

  2188. #endif
    2189. 

  2189. 

  2190.   return MNG_NOERROR;
    2191. 

  2191. }
    2192. 

  2192. #endif /* MNG_NO_16BIT_SUPPORT */
    2193. 

  2193. #endif /* MNG_SKIPCANVAS_ARGB8 */
    2194. 

  2194. 

  2195. /* ************************************************************************** */
    2196. 

  2196. 

  2197. #ifndef MNG_SKIPCANVAS_ARGB8_PM
    2198. 

  2198. #ifndef MNG_NO_16BIT_SUPPORT
    2199. 

  2199. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    2200. 

  2200. mng_retcode mng_display_argb8_pm (mng_datap pData)
    2201. 

  2201. {
    2202. 

  2202.   mng_uint8p pScanline;
    2203. 

  2203.   mng_uint8p pDataline;
    2204. 

  2204.   mng_int32  iX;
    2205. 

  2205.   mng_uint32 s, t;
    2206. 

  2206. 

  2207. #ifdef MNG_SUPPORT_TRACE
    2208. 

  2208.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
    2209. 

  2209. #endif
    2210. 

  2210.                                        /* viewable row ? */
    2211. 

  2211.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    2212. 

  2212.   {                                    /* address destination row */
    2213. 

  2213.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    2214. 

  2214.                                                    pData->iRow + pData->iDestt -
    2215. 

  2215.                                                    pData->iSourcet);
    2216. 

  2216.                                        /* adjust destination row starting-point */
    2217. 

  2217.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    2218. 

  2218.     pDataline = pData->pRGBArow;       /* address source row */
    2219. 

  2219. 

  2220.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    2221. 

  2221.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    2222. 

  2222.     else
    2223. 

  2223.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    2224. 

  2224. 

  2225.     if (pData->bIsOpaque)              /* forget about transparency ? */
    2226. 

  2226.     {
    2227. 

  2227.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2228. 

  2228.       {
    2229. 

  2229.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2230. 

  2230.              iX += pData->iColinc)
    2231. 

  2231.         {                              /* scale down by dropping the LSB */
    2232. 

  2232. 		  if ((s = pDataline[6]) == 0)
    2233. 

  2233. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    2234. 

  2234. 		  else
    2235. 

  2235. 		  {
    2236. 

  2236. 			if (s == 255)
    2237. 

  2237. 			{
    2238. 

  2238.               pScanline[0] = 255;
    2239. 

  2239.               pScanline[1] = pDataline[0];
    2240. 

  2240.               pScanline[2] = pDataline[2];
    2241. 

  2241. 		      pScanline[3] = pDataline[4];
    2242. 

  2242. 			}
    2243. 

  2243. 			else
    2244. 

  2244. 			{
    2245. 

  2245.               pScanline[0] = (mng_uint8)s;
    2246. 

  2246. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2247. 

  2247.               {
    2248. 

  2248.                 int i;
    2249. 

  2249.                 for (i=2; i >= 0; i--)
    2250. 

  2250.                 {
    2251. 

  2251.                   pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
    2252. 

  2252.                 }
    2253. 

  2253.               }
    2254. 

  2254. #else
    2255. 

  2255.               pScanline[1] = DIV255B8(s * pDataline[0]);
    2256. 

  2256.               pScanline[2] = DIV255B8(s * pDataline[2]);
    2257. 

  2257.               pScanline[3] = DIV255B8(s * pDataline[4]);
    2258. 

  2258. #endif
    2259. 

  2259. 			}
    2260. 

  2260. 		  }
    2261. 

  2261.           pScanline += (pData->iColinc << 2);
    2262. 

  2262.           pDataline += 8;
    2263. 

  2263.         }
    2264. 

  2264.       }
    2265. 

  2265.       else
    2266. 

  2266.       {
    2267. 

  2267.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2268. 

  2268.              iX += pData->iColinc)
    2269. 

  2269.         {                              /* copy the values and premultiply */
    2270. 

  2270. 		  if ((s = pDataline[3]) == 0)
    2271. 

  2271. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    2272. 

  2272. 		  else
    2273. 

  2273. 		  {
    2274. 

  2274. 			if (s == 255)
    2275. 

  2275. 			{
    2276. 

  2276.               pScanline[0] = 255;
    2277. 

  2277.               pScanline[1] = pDataline[0];
    2278. 

  2278.               pScanline[2] = pDataline[1];
    2279. 

  2279. 		      pScanline[3] = pDataline[2];
    2280. 

  2280. 			}
    2281. 

  2281. 			else
    2282. 

  2282. 			{
    2283. 

  2283.               pScanline[0] = (mng_uint8)s;
    2284. 

  2284. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2285. 

  2285.               {
    2286. 

  2286.                 int i;
    2287. 

  2287.                 for (i=2; i >= 0; i--)
    2288. 

  2288.                 {
    2289. 

  2289.                   pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
    2290. 

  2290.                 }
    2291. 

  2291.               }
    2292. 

  2292. #else
    2293. 

  2293.               pScanline[1] = DIV255B8(s * pDataline[0]);
    2294. 

  2294.               pScanline[2] = DIV255B8(s * pDataline[1]);
    2295. 

  2295. 		      pScanline[3] = DIV255B8(s * pDataline[2]);
    2296. 

  2296. #endif
    2297. 

  2297. 			}
    2298. 

  2298. 		  }
    2299. 

  2299. 

  2300.           pScanline += (pData->iColinc << 2);
    2301. 

  2301.           pDataline += 4;
    2302. 

  2302.         }
    2303. 

  2303.       }
    2304. 

  2304.     }
    2305. 

  2305.     else
    2306. 

  2306.     {
    2307. 

  2307.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2308. 

  2308.       {
    2309. 

  2309.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2310. 

  2310.              iX += pData->iColinc)
    2311. 

  2311.         {                              /* get alpha values */
    2312. 

  2312.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    2313. 

  2313.           {                            /* fully opaque or background fully transparent ? */
    2314. 

  2314.             if (s == 255)
    2315. 

  2315.             {                          /* plain copy it */
    2316. 

  2316.               pScanline[0] = 255;
    2317. 

  2317.               pScanline[1] = pDataline[0];
    2318. 

  2318.               pScanline[2] = pDataline[2];
    2319. 

  2319.               pScanline[3] = pDataline[4];
    2320. 

  2320.             }
    2321. 

  2321.             else
    2322. 

  2322.             {                          /* now blend (premultiplied) */
    2323. 

  2323. 			  t = 255 - s;
    2324. 

  2324.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    2325. 

  2325. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2326. 

  2326.               {
    2327. 

  2327.                 int i;
    2328. 

  2328.                 for (i=2; i >= 0; i--)
    2329. 

  2329.                 {
    2330. 

  2330.                   pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
    2331. 

  2331.                      pScanline[3-i]);
    2332. 

  2332.                 }
    2333. 

  2333.               }
    2334. 

  2334. #else
    2335. 

  2335.               pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
    2336. 

  2336.               pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    2337. 

  2337. 			  pScanline[3] = DIV255B8(s * pDataline[4] + t * pScanline[3]);
    2338. 

  2338. #endif
    2339. 

  2339.             }
    2340. 

  2340.           }
    2341. 

  2341. 

  2342.           pScanline += (pData->iColinc << 2);
    2343. 

  2343.           pDataline += 8;
    2344. 

  2344.         }
    2345. 

  2345.       }
    2346. 

  2346.       else
    2347. 

  2347.       {
    2348. 

  2348.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2349. 

  2349.              iX += pData->iColinc)
    2350. 

  2350.         {
    2351. 

  2351.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    2352. 

  2352.           {                            /* fully opaque ? */
    2353. 

  2353.             if (s == 255)
    2354. 

  2354.             {                          /* then simply copy the values */
    2355. 

  2355.               pScanline[0] = 255;
    2356. 

  2356.               pScanline[1] = pDataline[0];
    2357. 

  2357.               pScanline[2] = pDataline[1];
    2358. 

  2358.               pScanline[3] = pDataline[2];
    2359. 

  2359.             }
    2360. 

  2360.             else
    2361. 

  2361.             {                          /* now blend (premultiplied) */
    2362. 

  2362. 			  t = 255 - s;
    2363. 

  2363.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    2364. 

  2364. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2365. 

  2365.               {
    2366. 

  2366.                 int i;
    2367. 

  2367.                 for (i=2; i >= 0; i--)
    2368. 

  2368.                 {
    2369. 

  2369.                   pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
    2370. 

  2370.                      pScanline[3-i]);
    2371. 

  2371.                 }
    2372. 

  2372.               }
    2373. 

  2373. #else
    2374. 

  2374.               pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
    2375. 

  2375.               pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
    2376. 

  2376. 			  pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
    2377. 

  2377. #endif
    2378. 

  2378.             }
    2379. 

  2379.           }
    2380. 

  2380. 

  2381.           pScanline += (pData->iColinc << 2);
    2382. 

  2382.           pDataline += 4;
    2383. 

  2383.         }
    2384. 

  2384.       }
    2385. 

  2385.     }
    2386. 

  2386.   }
    2387. 

  2387. 

  2388.   check_update_region (pData);
    2389. 

  2389. 

  2390. #ifdef MNG_SUPPORT_TRACE
    2391. 

  2391.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
    2392. 

  2392. #endif
    2393. 

  2393. 

  2394.   return MNG_NOERROR;
    2395. 

  2395. }
    2396. 

  2396. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    2397. 

  2397. mng_retcode mng_display_argb8_pm (mng_datap pData)
    2398. 

  2398. {
    2399. 

  2399.   mng_uint8p pScanline;
    2400. 

  2400.   mng_uint8p pDataline;
    2401. 

  2401.   mng_int32  iX;
    2402. 

  2402.   mng_uint32 s, t;
    2403. 

  2403.   mng_uint8  iBps;
    2404. 

  2404. 

  2405. #ifdef MNG_SUPPORT_TRACE
    2406. 

  2406.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
    2407. 

  2407. #endif
    2408. 

  2408. 

  2409.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    2410. 

  2410.                                        /* viewable row ? */
    2411. 

  2411.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    2412. 

  2412.   {                                    /* address destination row */
    2413. 

  2413.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    2414. 

  2414.                                                    pData->iRow + pData->iDestt -
    2415. 

  2415.                                                    pData->iSourcet);
    2416. 

  2416.                                        /* adjust destination row starting-point */
    2417. 

  2417.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    2418. 

  2418.     pDataline = pData->pRGBArow;       /* address source row */
    2419. 

  2419. 

  2420.     /* adjust source row starting-point */
    2421. 

  2421.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    2422. 

  2422. 

  2423.     if (pData->bIsOpaque)              /* forget about transparency ? */
    2424. 

  2424.     {
    2425. 

  2425.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2426. 

  2426.       {
    2427. 

  2427.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2428. 

  2428.              iX += pData->iColinc)
    2429. 

  2429.         {                              /* scale down by dropping the LSB */
    2430. 

  2430. 		  if ((s = pDataline[6]) == 0)
    2431. 

  2431. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    2432. 

  2432. 		  else
    2433. 

  2433. 		  {
    2434. 

  2434. 			if (s == 255)
    2435. 

  2435. 			{
    2436. 

  2436.               pScanline[0] = 255;
    2437. 

  2437.               pScanline[1] = pDataline[0];
    2438. 

  2438.               pScanline[2] = pDataline[2];
    2439. 

  2439. 		      pScanline[3] = pDataline[4];
    2440. 

  2440. 			}
    2441. 

  2441. 			else
    2442. 

  2442. 			{
    2443. 

  2443.               pScanline[0] = (mng_uint8)s;
    2444. 

  2444. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2445. 

  2445.               {
    2446. 

  2446.                 int i;
    2447. 

  2447.                 for (i=2; i >= 0; i--)
    2448. 

  2448.                 {
    2449. 

  2449.                   pScanline[3-i] = DIV255B8(s * pDataline[4-i-i]);
    2450. 

  2450.                 }
    2451. 

  2451.               }
    2452. 

  2452. #else
    2453. 

  2453.               pScanline[1] = DIV255B8(s * pDataline[0]);
    2454. 

  2454.               pScanline[2] = DIV255B8(s * pDataline[2]);
    2455. 

  2455.               pScanline[3] = DIV255B8(s * pDataline[4]);
    2456. 

  2456. #endif
    2457. 

  2457. 			}
    2458. 

  2458. 		  }
    2459. 

  2459.           pScanline += (pData->iColinc << 2);
    2460. 

  2460.           pDataline += 8;
    2461. 

  2461.         }
    2462. 

  2462.       }
    2463. 

  2463.       else
    2464. 

  2464.       {
    2465. 

  2465.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2466. 

  2466.              iX += pData->iColinc)
    2467. 

  2467.         {                              /* copy the values and premultiply */
    2468. 

  2468. 		  if ((s = pDataline[3]) == 0)
    2469. 

  2469. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    2470. 

  2470. 		  else
    2471. 

  2471. 		  {
    2472. 

  2472. 			if (s == 255)
    2473. 

  2473. 			{
    2474. 

  2474.               pScanline[0] = 255;
    2475. 

  2475.               pScanline[1] = pDataline[0];
    2476. 

  2476.               pScanline[2] = pDataline[1];
    2477. 

  2477. 		      pScanline[3] = pDataline[2];
    2478. 

  2478. 			}
    2479. 

  2479. 			else
    2480. 

  2480. 			{
    2481. 

  2481.               pScanline[0] = (mng_uint8)s;
    2482. 

  2482. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2483. 

  2483.               {
    2484. 

  2484.                 int i;
    2485. 

  2485.                 for (i=2; i >= 0; i--)
    2486. 

  2486.                 {
    2487. 

  2487.                   pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
    2488. 

  2488.                 }
    2489. 

  2489.               }
    2490. 

  2490. #else
    2491. 

  2491.               pScanline[1] = DIV255B8(s * pDataline[0]);
    2492. 

  2492.               pScanline[2] = DIV255B8(s * pDataline[1]);
    2493. 

  2493. 		      pScanline[3] = DIV255B8(s * pDataline[2]);
    2494. 

  2494. #endif
    2495. 

  2495. 			}
    2496. 

  2496. 		  }
    2497. 

  2497. 

  2498.           pScanline += (pData->iColinc << 2);
    2499. 

  2499.           pDataline += 4;
    2500. 

  2500.         }
    2501. 

  2501.       }
    2502. 

  2502.     }
    2503. 

  2503.     else
    2504. 

  2504.     {
    2505. 

  2505.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2506. 

  2506.       {
    2507. 

  2507.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2508. 

  2508.              iX += pData->iColinc)
    2509. 

  2509.         {                              /* get alpha values */
    2510. 

  2510.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    2511. 

  2511.           {                            /* fully opaque or background fully transparent ? */
    2512. 

  2512.             if (s == 255)
    2513. 

  2513.             {                          /* plain copy it */
    2514. 

  2514.               pScanline[0] = 255;
    2515. 

  2515.               pScanline[1] = pDataline[0];
    2516. 

  2516.               pScanline[2] = pDataline[2];
    2517. 

  2517.               pScanline[3] = pDataline[4];
    2518. 

  2518.             }
    2519. 

  2519.             else
    2520. 

  2520.             {                          /* now blend (premultiplied) */
    2521. 

  2521. 			  t = 255 - s;
    2522. 

  2522.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    2523. 

  2523. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2524. 

  2524.               {
    2525. 

  2525.                 int i;
    2526. 

  2526.                 for (i=2; i >= 0; i--)
    2527. 

  2527.                 {
    2528. 

  2528.                   pScanline[3-i] = DIV255B8(s * pDataline[4-i-i] + t *
    2529. 

  2529.                      pScanline[3-i]);
    2530. 

  2530.                 }
    2531. 

  2531.               }
    2532. 

  2532. #else
    2533. 

  2533.               pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
    2534. 

  2534.               pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    2535. 

  2535. 			  pScanline[3] = DIV255B8(s * pDataline[4] + t * pScanline[3]);
    2536. 

  2536. #endif
    2537. 

  2537.             }
    2538. 

  2538.           }
    2539. 

  2539. 

  2540.           pScanline += (pData->iColinc << 2);
    2541. 

  2541.           pDataline += 8;
    2542. 

  2542.         }
    2543. 

  2543.       }
    2544. 

  2544.       else
    2545. 

  2545.       {
    2546. 

  2546.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2547. 

  2547.              iX += pData->iColinc)
    2548. 

  2548.         {
    2549. 

  2549.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    2550. 

  2550.           {                            /* fully opaque ? */
    2551. 

  2551.             if (s == 255)
    2552. 

  2552.             {                          /* then simply copy the values */
    2553. 

  2553.               pScanline[0] = 255;
    2554. 

  2554.               pScanline[1] = pDataline[0];
    2555. 

  2555.               pScanline[2] = pDataline[1];
    2556. 

  2556.               pScanline[3] = pDataline[2];
    2557. 

  2557.             }
    2558. 

  2558.             else
    2559. 

  2559.             {                          /* now blend (premultiplied) */
    2560. 

  2560. 			  t = 255 - s;
    2561. 

  2561.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    2562. 

  2562. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2563. 

  2563.               {
    2564. 

  2564.                 int i;
    2565. 

  2565.                 for (i=2; i >= 0; i--)
    2566. 

  2566.                 {
    2567. 

  2567.                   pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
    2568. 

  2568.                      pScanline[3-i]);
    2569. 

  2569.                 }
    2570. 

  2570.               }
    2571. 

  2571. #else
    2572. 

  2572.               pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
    2573. 

  2573.               pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
    2574. 

  2574. 			  pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
    2575. 

  2575. #endif
    2576. 

  2576.             }
    2577. 

  2577.           }
    2578. 

  2578. 

  2579.           pScanline += (pData->iColinc << 2);
    2580. 

  2580.           pDataline += 4;
    2581. 

  2581.         }
    2582. 

  2582.       }
    2583. 

  2583.     }
    2584. 

  2584.   }
    2585. 

  2585. 

  2586.   check_update_region (pData);
    2587. 

  2587. 

  2588. #ifdef MNG_SUPPORT_TRACE
    2589. 

  2589.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
    2590. 

  2590. #endif
    2591. 

  2591. 

  2592.   return MNG_NOERROR;
    2593. 

  2593. }
    2594. 

  2594. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    2595. 

  2595. #else /* MNG_NO_16BIT_SUPPORT */
    2596. 

  2596. mng_retcode mng_display_argb8_pm (mng_datap pData)
    2597. 

  2597. {
    2598. 

  2598.   mng_uint8p pScanline;
    2599. 

  2599.   mng_uint8p pDataline;
    2600. 

  2600.   mng_int32  iX;
    2601. 

  2601.   mng_uint32 s, t;
    2602. 

  2602. 

  2603. #ifdef MNG_SUPPORT_TRACE
    2604. 

  2604.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_START);
    2605. 

  2605. #endif
    2606. 

  2606.                                        /* viewable row ? */
    2607. 

  2607.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    2608. 

  2608.   {                                    /* address destination row */
    2609. 

  2609.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    2610. 

  2610.                                                    pData->iRow + pData->iDestt -
    2611. 

  2611.                                                    pData->iSourcet);
    2612. 

  2612.                                        /* adjust destination row starting-point */
    2613. 

  2613.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    2614. 

  2614.     pDataline = pData->pRGBArow;       /* address source row */
    2615. 

  2615. 

  2616.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    2617. 

  2617. 

  2618.     if (pData->bIsOpaque)              /* forget about transparency ? */
    2619. 

  2619.     {
    2620. 

  2620.       {
    2621. 

  2621.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2622. 

  2622.              iX += pData->iColinc)
    2623. 

  2623.         {                              /* copy the values and premultiply */
    2624. 

  2624. 		  if ((s = pDataline[3]) == 0)
    2625. 

  2625. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    2626. 

  2626. 		  else
    2627. 

  2627. 		  {
    2628. 

  2628. 			if (s == 255)
    2629. 

  2629. 			{
    2630. 

  2630.               pScanline[0] = 255;
    2631. 

  2631.               pScanline[1] = pDataline[0];
    2632. 

  2632.               pScanline[2] = pDataline[1];
    2633. 

  2633. 		      pScanline[3] = pDataline[2];
    2634. 

  2634. 			}
    2635. 

  2635. 			else
    2636. 

  2636. 			{
    2637. 

  2637.               pScanline[0] = (mng_uint8)s;
    2638. 

  2638. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2639. 

  2639.               {
    2640. 

  2640.                 int i;
    2641. 

  2641.                 for (i=2; i >= 0; i--)
    2642. 

  2642.                 {
    2643. 

  2643.                   pScanline[3-i] = DIV255B8(s * pDataline[2-i]);
    2644. 

  2644.                 }
    2645. 

  2645.               }
    2646. 

  2646. #else
    2647. 

  2647.               pScanline[1] = DIV255B8(s * pDataline[0]);
    2648. 

  2648.               pScanline[2] = DIV255B8(s * pDataline[1]);
    2649. 

  2649. 		      pScanline[3] = DIV255B8(s * pDataline[2]);
    2650. 

  2650. #endif
    2651. 

  2651. 			}
    2652. 

  2652. 		  }
    2653. 

  2653. 

  2654.           pScanline += (pData->iColinc << 2);
    2655. 

  2655.           pDataline += 4;
    2656. 

  2656.         }
    2657. 

  2657.       }
    2658. 

  2658.     }
    2659. 

  2659.     else
    2660. 

  2660.     {
    2661. 

  2661.       {
    2662. 

  2662.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2663. 

  2663.              iX += pData->iColinc)
    2664. 

  2664.         {
    2665. 

  2665.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    2666. 

  2666.           {                            /* fully opaque ? */
    2667. 

  2667.             if (s == 255)
    2668. 

  2668.             {                          /* then simply copy the values */
    2669. 

  2669.               pScanline[0] = 255;
    2670. 

  2670.               pScanline[1] = pDataline[0];
    2671. 

  2671.               pScanline[2] = pDataline[1];
    2672. 

  2672.               pScanline[3] = pDataline[2];
    2673. 

  2673.             }
    2674. 

  2674.             else
    2675. 

  2675.             {                          /* now blend (premultiplied) */
    2676. 

  2676. 			  t = 255 - s;
    2677. 

  2677.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    2678. 

  2678. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    2679. 

  2679.               {
    2680. 

  2680.                 int i;
    2681. 

  2681.                 for (i=2; i >= 0; i--)
    2682. 

  2682.                 {
    2683. 

  2683.                   pScanline[3-i] = DIV255B8(s * pDataline[2-i] + t *
    2684. 

  2684.                      pScanline[3-i]);
    2685. 

  2685.                 }
    2686. 

  2686.               }
    2687. 

  2687. #else
    2688. 

  2688.               pScanline[1] = DIV255B8(s * pDataline[0] + t * pScanline[1]);
    2689. 

  2689.               pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
    2690. 

  2690. 			  pScanline[3] = DIV255B8(s * pDataline[2] + t * pScanline[3]);
    2691. 

  2691. #endif
    2692. 

  2692.             }
    2693. 

  2693.           }
    2694. 

  2694. 

  2695.           pScanline += (pData->iColinc << 2);
    2696. 

  2696.           pDataline += 4;
    2697. 

  2697.         }
    2698. 

  2698.       }
    2699. 

  2699.     }
    2700. 

  2700.   }
    2701. 

  2701. 

  2702.   check_update_region (pData);
    2703. 

  2703. 

  2704. #ifdef MNG_SUPPORT_TRACE
    2705. 

  2705.   MNG_TRACE (pData, MNG_FN_DISPLAY_ARGB8_PM, MNG_LC_END);
    2706. 

  2706. #endif
    2707. 

  2707. 

  2708.   return MNG_NOERROR;
    2709. 

  2709. }
    2710. 

  2710. #endif /* MNG_NO_16BIT_SUPPORT */
    2711. 

  2711. #endif /* MNG_SKIPCANVAS_ARGB8_PM */
    2712. 

  2712. 

  2713. /* ************************************************************************** */
    2714. 

  2714. 

  2715. #ifndef MNG_SKIPCANVAS_RGB8_A8
    2716. 

  2716. #ifndef MNG_NO_16BIT_SUPPORT
    2717. 

  2717. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    2718. 

  2718. mng_retcode mng_display_rgb8_a8 (mng_datap pData)
    2719. 

  2719. {
    2720. 

  2720.   mng_uint8p pScanline;
    2721. 

  2721.   mng_uint8p pAlphaline;
    2722. 

  2722.   mng_uint8p pDataline;
    2723. 

  2723.   mng_int32  iX;
    2724. 

  2724.   mng_uint8  iFGa8, iBGa8, iCa8;
    2725. 

  2725.   mng_uint16 iFGa16, iBGa16, iCa16;
    2726. 

  2726.   mng_uint16 iFGr16, iFGg16, iFGb16;
    2727. 

  2727.   mng_uint16 iBGr16, iBGg16, iBGb16;
    2728. 

  2728.   mng_uint16 iCr16, iCg16, iCb16;
    2729. 

  2729.   mng_uint8  iCr8, iCg8, iCb8;
    2730. 

  2730. 

  2731. #ifdef MNG_SUPPORT_TRACE
    2732. 

  2732.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
    2733. 

  2733. #endif
    2734. 

  2734.                                        /* viewable row ? */
    2735. 

  2735.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    2736. 

  2736.   {                                    /* address destination rows */
    2737. 

  2737.     pScanline  = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    2738. 

  2738.                                                     pData->iRow + pData->iDestt -
    2739. 

  2739.                                                     pData->iSourcet);
    2740. 

  2740.     pAlphaline = (mng_uint8p)pData->fGetalphaline  (((mng_handle)pData),
    2741. 

  2741.                                                     pData->iRow + pData->iDestt -
    2742. 

  2742.                                                     pData->iSourcet);
    2743. 

  2743.                                        /* adjust destination rows starting-point */
    2744. 

  2744.     pScanline  = pScanline  + (pData->iCol * 3) + (pData->iDestl * 3);
    2745. 

  2745.     pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
    2746. 

  2746. 

  2747.     pDataline  = pData->pRGBArow;      /* address source row */
    2748. 

  2748. 

  2749.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    2750. 

  2750.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    2751. 

  2751.     else
    2752. 

  2752.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    2753. 

  2753. 

  2754.     if (pData->bIsOpaque)              /* forget about transparency ? */
    2755. 

  2755.     {
    2756. 

  2756.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2757. 

  2757.       {
    2758. 

  2758.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2759. 

  2759.              iX += pData->iColinc)
    2760. 

  2760.         {                              /* scale down by dropping the LSB */
    2761. 

  2761.           *pScanline     = *pDataline;
    2762. 

  2762.           *(pScanline+1) = *(pDataline+2);
    2763. 

  2763.           *(pScanline+2) = *(pDataline+4);
    2764. 

  2764.           *pAlphaline    = *(pDataline+6);
    2765. 

  2765. 

  2766.           pScanline  += (pData->iColinc * 3);
    2767. 

  2767.           pAlphaline += pData->iColinc;
    2768. 

  2768.           pDataline  += 8;
    2769. 

  2769.         }
    2770. 

  2770.       }
    2771. 

  2771.       else
    2772. 

  2772.       {
    2773. 

  2773.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2774. 

  2774.              iX += pData->iColinc)
    2775. 

  2775.         {                              /* copy the values */
    2776. 

  2776.           *pScanline     = *pDataline;
    2777. 

  2777.           *(pScanline+1) = *(pDataline+1);
    2778. 

  2778.           *(pScanline+2) = *(pDataline+2);
    2779. 

  2779.           *pAlphaline    = *(pDataline+3);
    2780. 

  2780. 

  2781.           pScanline  += (pData->iColinc * 3);
    2782. 

  2782.           pAlphaline += pData->iColinc;
    2783. 

  2783.           pDataline  += 4;
    2784. 

  2784.         }
    2785. 

  2785.       }
    2786. 

  2786.     }
    2787. 

  2787.     else
    2788. 

  2788.     {
    2789. 

  2789.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2790. 

  2790.       {
    2791. 

  2791.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2792. 

  2792.              iX += pData->iColinc)
    2793. 

  2793.         {                              /* get alpha values */
    2794. 

  2794.           iFGa16 = mng_get_uint16 (pDataline+6);
    2795. 

  2795.           iBGa16 = (mng_uint16)(*pAlphaline);
    2796. 

  2796.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    2797. 

  2797. 

  2798.           if (iFGa16)                  /* any opacity at all ? */
    2799. 

  2799.           {                            /* fully opaque or background fully transparent ? */
    2800. 

  2800.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    2801. 

  2801.             {                          /* plain copy it */
    2802. 

  2802.               *pScanline     = *pDataline;
    2803. 

  2803.               *(pScanline+1) = *(pDataline+2);
    2804. 

  2804.               *(pScanline+2) = *(pDataline+4);
    2805. 

  2805.               *pAlphaline    = *(pDataline+6);
    2806. 

  2806.             }
    2807. 

  2807.             else
    2808. 

  2808.             {
    2809. 

  2809.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    2810. 

  2810.               {                        /* get the proper values */
    2811. 

  2811.                 iFGr16 = mng_get_uint16 (pDataline  );
    2812. 

  2812.                 iFGg16 = mng_get_uint16 (pDataline+2);
    2813. 

  2813.                 iFGb16 = mng_get_uint16 (pDataline+4);
    2814. 

  2814.                                        /* scale background up */
    2815. 

  2815.                 iBGr16 = (mng_uint16)(*pScanline    );
    2816. 

  2816.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    2817. 

  2817.                 iBGb16 = (mng_uint16)(*(pScanline+2));
    2818. 

  2818.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    2819. 

  2819.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    2820. 

  2820.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    2821. 

  2821.                                        /* now compose */
    2822. 

  2822.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    2823. 

  2823.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    2824. 

  2824.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    2825. 

  2825.                                        /* and return the composed values */
    2826. 

  2826.                 *pScanline     = (mng_uint8)(iFGr16 >> 8);
    2827. 

  2827.                 *(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
    2828. 

  2828.                 *(pScanline+2) = (mng_uint8)(iFGb16 >> 8);
    2829. 

  2829.                                        /* alpha remains fully opaque !!! */
    2830. 

  2830.               }
    2831. 

  2831.               else
    2832. 

  2832.               {                        /* scale background up */
    2833. 

  2833.                 iBGr16 = (mng_uint16)(*pScanline    );
    2834. 

  2834.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    2835. 

  2835.                 iBGb16 = (mng_uint16)(*(pScanline+2));
    2836. 

  2836.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    2837. 

  2837.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    2838. 

  2838.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    2839. 

  2839.                                        /* let's blend */
    2840. 

  2840.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    2841. 

  2841.                              mng_get_uint16 (pDataline+2),
    2842. 

  2842.                              mng_get_uint16 (pDataline+4), iFGa16,
    2843. 

  2843.                              iBGr16, iBGg16, iBGb16, iBGa16,
    2844. 

  2844.                              iCr16,  iCg16,  iCb16,  iCa16);
    2845. 

  2845.                                        /* and return the composed values */
    2846. 

  2846.                 *pScanline     = (mng_uint8)(iCr16 >> 8);
    2847. 

  2847.                 *(pScanline+1) = (mng_uint8)(iCg16 >> 8);
    2848. 

  2848.                 *(pScanline+2) = (mng_uint8)(iCb16 >> 8);
    2849. 

  2849.                 *pAlphaline    = (mng_uint8)(iCa16 >> 8);
    2850. 

  2850.               }
    2851. 

  2851.             }
    2852. 

  2852.           }
    2853. 

  2853. 

  2854.           pScanline  += (pData->iColinc * 3);
    2855. 

  2855.           pAlphaline += pData->iColinc;
    2856. 

  2856.           pDataline  += 8;
    2857. 

  2857.         }
    2858. 

  2858.       }
    2859. 

  2859.       else
    2860. 

  2860.       {
    2861. 

  2861.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2862. 

  2862.              iX += pData->iColinc)
    2863. 

  2863.         {
    2864. 

  2864.           iFGa8 = *(pDataline+3);      /* get alpha values */
    2865. 

  2865.           iBGa8 = *pAlphaline;
    2866. 

  2866. 

  2867.           if (iFGa8)                   /* any opacity at all ? */
    2868. 

  2868.           {                            /* fully opaque or background fully transparent ? */
    2869. 

  2869.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    2870. 

  2870.             {                          /* then simply copy the values */
    2871. 

  2871.               *pScanline     = *pDataline;
    2872. 

  2872.               *(pScanline+1) = *(pDataline+1);
    2873. 

  2873.               *(pScanline+2) = *(pDataline+2);
    2874. 

  2874.               *pAlphaline    = *(pDataline+3);
    2875. 

  2875.             }
    2876. 

  2876.             else
    2877. 

  2877.             {
    2878. 

  2878.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    2879. 

  2879.               {                        /* do alpha composing */
    2880. 

  2880.                 MNG_COMPOSE8 (*pScanline,     *pDataline,     iFGa8, *pScanline    );
    2881. 

  2881.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
    2882. 

  2882.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iFGa8, *(pScanline+2));
    2883. 

  2883.                                        /* alpha remains fully opaque !!! */
    2884. 

  2884.               }
    2885. 

  2885.               else
    2886. 

  2886.               {                        /* now blend */
    2887. 

  2887.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    2888. 

  2888.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    2889. 

  2889.                             iCr8, iCg8, iCb8, iCa8);
    2890. 

  2890.                                        /* and return the composed values */
    2891. 

  2891.                 *pScanline     = iCr8;
    2892. 

  2892.                 *(pScanline+1) = iCg8;
    2893. 

  2893.                 *(pScanline+2) = iCb8;
    2894. 

  2894.                 *pAlphaline    = iCa8;
    2895. 

  2895.               }
    2896. 

  2896.             }
    2897. 

  2897.           }
    2898. 

  2898. 

  2899.           pScanline  += (pData->iColinc * 3);
    2900. 

  2900.           pAlphaline += pData->iColinc;
    2901. 

  2901.           pDataline  += 4;
    2902. 

  2902.         }
    2903. 

  2903.       }
    2904. 

  2904.     }
    2905. 

  2905.   }
    2906. 

  2906. 

  2907.   check_update_region (pData);
    2908. 

  2908. 

  2909. #ifdef MNG_SUPPORT_TRACE
    2910. 

  2910.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
    2911. 

  2911. #endif
    2912. 

  2912. 

  2913.   return MNG_NOERROR;
    2914. 

  2914. }
    2915. 

  2915. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    2916. 

  2916. mng_retcode mng_display_rgb8_a8 (mng_datap pData)
    2917. 

  2917. {
    2918. 

  2918.   mng_uint8p pScanline;
    2919. 

  2919.   mng_uint8p pAlphaline;
    2920. 

  2920.   mng_uint8p pDataline;
    2921. 

  2921.   mng_int32  iX;
    2922. 

  2922.   mng_uint8  iFGa8, iBGa8, iCa8;
    2923. 

  2923.   mng_uint16 iFGa16, iBGa16, iCa16;
    2924. 

  2924.   mng_uint16 iFGg16;
    2925. 

  2925.   mng_uint16 iBGr16, iBGg16, iBGb16;
    2926. 

  2926.   mng_uint16 iCr16, iCg16, iCb16;
    2927. 

  2927.   mng_uint8  iCr8, iCg8, iCb8;
    2928. 

  2928.   mng_uint8  iBps;
    2929. 

  2929. 

  2930. #ifdef MNG_SUPPORT_TRACE
    2931. 

  2931.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
    2932. 

  2932. #endif
    2933. 

  2933. 

  2934.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    2935. 

  2935.                                        /* viewable row ? */
    2936. 

  2936.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    2937. 

  2937.   {                                    /* address destination rows */
    2938. 

  2938.     pScanline  = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    2939. 

  2939.                                                     pData->iRow + pData->iDestt -
    2940. 

  2940.                                                     pData->iSourcet);
    2941. 

  2941.     pAlphaline = (mng_uint8p)pData->fGetalphaline  (((mng_handle)pData),
    2942. 

  2942.                                                     pData->iRow + pData->iDestt -
    2943. 

  2943.                                                     pData->iSourcet);
    2944. 

  2944.                                        /* adjust destination rows starting-point */
    2945. 

  2945.     pScanline  = pScanline  + (pData->iCol * 3) + (pData->iDestl * 3);
    2946. 

  2946.     pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
    2947. 

  2947. 

  2948.     pDataline  = pData->pRGBArow;      /* address source row */
    2949. 

  2949. 

  2950.     /* adjust source row starting-point */
    2951. 

  2951.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    2952. 

  2952. 

  2953.     if (pData->bIsOpaque)              /* forget about transparency ? */
    2954. 

  2954.     {
    2955. 

  2955.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2956. 

  2956.              iX += pData->iColinc)
    2957. 

  2957.         {                              /* scale down by dropping the LSB */
    2958. 

  2958.           *pScanline     = *pDataline;
    2959. 

  2959.           *(pScanline+1) = *(pDataline+iBps);
    2960. 

  2960.           *(pScanline+2) = *(pDataline+2*iBps);
    2961. 

  2961.           *pAlphaline    = *(pDataline+3*iBps);
    2962. 

  2962. 

  2963.           pScanline  += (pData->iColinc * 3);
    2964. 

  2964.           pAlphaline += pData->iColinc;
    2965. 

  2965.           pDataline  += 4*iBps;
    2966. 

  2966.         }
    2967. 

  2967.     }
    2968. 

  2968.     else
    2969. 

  2969.     {
    2970. 

  2970.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    2971. 

  2971.       {
    2972. 

  2972.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    2973. 

  2973.              iX += pData->iColinc)
    2974. 

  2974.         {                              /* get alpha values */
    2975. 

  2975.           iFGa16 = mng_get_uint16 (pDataline+6);
    2976. 

  2976.           iBGa16 = (mng_uint16)(*pAlphaline);
    2977. 

  2977.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    2978. 

  2978. 

  2979.           if (iFGa16)                  /* any opacity at all ? */
    2980. 

  2980.           {                            /* fully opaque or background fully transparent ? */
    2981. 

  2981.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    2982. 

  2982.             {                          /* plain copy it */
    2983. 

  2983.               *pScanline     = *pDataline;
    2984. 

  2984.               *(pScanline+1) = *(pDataline+2);
    2985. 

  2985.               *(pScanline+2) = *(pDataline+4);
    2986. 

  2986.               *pAlphaline    = *(pDataline+6);
    2987. 

  2987.             }
    2988. 

  2988.             else
    2989. 

  2989.             {
    2990. 

  2990.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    2991. 

  2991.               {                        /* get the proper values */
    2992. 

  2992.               int i;
    2993. 

  2993.               for (i=2; i >= 0; i--)
    2994. 

  2994.               {
    2995. 

  2995.                 iFGg16 = mng_get_uint16 (pDataline+i+i);
    2996. 

  2996.                                        /* scale background up */
    2997. 

  2997.                 iBGg16 = (mng_uint16)(*(pScanline+i));
    2998. 

  2998.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    2999. 

  2999.                                        /* now compose */
    3000. 

  3000.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    3001. 

  3001.                                        /* and return the composed values */
    3002. 

  3002.                 *(pScanline+i) = (mng_uint8)(iFGg16 >> 8);
    3003. 

  3003.                                        /* alpha remains fully opaque !!! */
    3004. 

  3004.               }
    3005. 

  3005.               }
    3006. 

  3006.               else
    3007. 

  3007.               {                        /* scale background up */
    3008. 

  3008.                 iBGr16 = (mng_uint16)(*pScanline    );
    3009. 

  3009.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    3010. 

  3010.                 iBGb16 = (mng_uint16)(*(pScanline+2));
    3011. 

  3011.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    3012. 

  3012.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    3013. 

  3013.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    3014. 

  3014.                                        /* let's blend */
    3015. 

  3015.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    3016. 

  3016.                              mng_get_uint16 (pDataline+2),
    3017. 

  3017.                              mng_get_uint16 (pDataline+4), iFGa16,
    3018. 

  3018.                              iBGr16, iBGg16, iBGb16, iBGa16,
    3019. 

  3019.                              iCr16,  iCg16,  iCb16,  iCa16);
    3020. 

  3020.                                        /* and return the composed values */
    3021. 

  3021.                 *pScanline     = (mng_uint8)(iCr16 >> 8);
    3022. 

  3022.                 *(pScanline+1) = (mng_uint8)(iCg16 >> 8);
    3023. 

  3023.                 *(pScanline+2) = (mng_uint8)(iCb16 >> 8);
    3024. 

  3024.                 *pAlphaline    = (mng_uint8)(iCa16 >> 8);
    3025. 

  3025.               }
    3026. 

  3026.             }
    3027. 

  3027.           }
    3028. 

  3028. 

  3029.           pScanline  += (pData->iColinc * 3);
    3030. 

  3030.           pAlphaline += pData->iColinc;
    3031. 

  3031.           pDataline  += 8;
    3032. 

  3032.         }
    3033. 

  3033.       }
    3034. 

  3034.       else
    3035. 

  3035.       {
    3036. 

  3036.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3037. 

  3037.              iX += pData->iColinc)
    3038. 

  3038.         {
    3039. 

  3039.           iFGa8 = *(pDataline+3);      /* get alpha values */
    3040. 

  3040.           iBGa8 = *pAlphaline;
    3041. 

  3041. 

  3042.           if (iFGa8)                   /* any opacity at all ? */
    3043. 

  3043.           {                            /* fully opaque or background fully transparent ? */
    3044. 

  3044.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    3045. 

  3045.             {                          /* then simply copy the values */
    3046. 

  3046.               *pScanline     = *pDataline;
    3047. 

  3047.               *(pScanline+1) = *(pDataline+1);
    3048. 

  3048.               *(pScanline+2) = *(pDataline+2);
    3049. 

  3049.               *pAlphaline    = *(pDataline+3);
    3050. 

  3050.             }
    3051. 

  3051.             else
    3052. 

  3052.             {
    3053. 

  3053.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    3054. 

  3054.               {                        /* do alpha composing */
    3055. 

  3055.               int i;
    3056. 

  3056.               for (i=2; i >= 0; i--)
    3057. 

  3057.               {
    3058. 

  3058.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
    3059. 

  3059.               }
    3060. 

  3060.                                        /* alpha remains fully opaque !!! */
    3061. 

  3061.               }
    3062. 

  3062.               else
    3063. 

  3063.               {                        /* now blend */
    3064. 

  3064.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    3065. 

  3065.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    3066. 

  3066.                             iCr8, iCg8, iCb8, iCa8);
    3067. 

  3067.                                        /* and return the composed values */
    3068. 

  3068.                 *pScanline     = iCr8;
    3069. 

  3069.                 *(pScanline+1) = iCg8;
    3070. 

  3070.                 *(pScanline+2) = iCb8;
    3071. 

  3071.                 *pAlphaline    = iCa8;
    3072. 

  3072.               }
    3073. 

  3073.             }
    3074. 

  3074.           }
    3075. 

  3075. 

  3076.           pScanline  += (pData->iColinc * 3);
    3077. 

  3077.           pAlphaline += pData->iColinc;
    3078. 

  3078.           pDataline  += 4;
    3079. 

  3079.         }
    3080. 

  3080.       }
    3081. 

  3081.     }
    3082. 

  3082.   }
    3083. 

  3083. 

  3084.   check_update_region (pData);
    3085. 

  3085. 

  3086. #ifdef MNG_SUPPORT_TRACE
    3087. 

  3087.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
    3088. 

  3088. #endif
    3089. 

  3089. 

  3090.   return MNG_NOERROR;
    3091. 

  3091. }
    3092. 

  3092. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    3093. 

  3093. #else /* MNG_NO_16BIT_SUPPORT */
    3094. 

  3094. mng_retcode mng_display_rgb8_a8 (mng_datap pData)
    3095. 

  3095. {
    3096. 

  3096.   mng_uint8p pScanline;
    3097. 

  3097.   mng_uint8p pAlphaline;
    3098. 

  3098.   mng_uint8p pDataline;
    3099. 

  3099.   mng_int32  iX;
    3100. 

  3100.   mng_uint8  iFGa8, iBGa8, iCa8;
    3101. 

  3101.   mng_uint8  iCr8, iCg8, iCb8;
    3102. 

  3102. 

  3103. #ifdef MNG_SUPPORT_TRACE
    3104. 

  3104.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_START);
    3105. 

  3105. #endif
    3106. 

  3106.                                        /* viewable row ? */
    3107. 

  3107.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3108. 

  3108.   {                                    /* address destination rows */
    3109. 

  3109.     pScanline  = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3110. 

  3110.                                                     pData->iRow + pData->iDestt -
    3111. 

  3111.                                                     pData->iSourcet);
    3112. 

  3112.     pAlphaline = (mng_uint8p)pData->fGetalphaline  (((mng_handle)pData),
    3113. 

  3113.                                                     pData->iRow + pData->iDestt -
    3114. 

  3114.                                                     pData->iSourcet);
    3115. 

  3115.                                        /* adjust destination rows starting-point */
    3116. 

  3116.     pScanline  = pScanline  + (pData->iCol * 3) + (pData->iDestl * 3);
    3117. 

  3117.     pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
    3118. 

  3118. 

  3119.     pDataline  = pData->pRGBArow;      /* address source row */
    3120. 

  3120. 

  3121.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    3122. 

  3122. 

  3123.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3124. 

  3124.     {
    3125. 

  3125.       {
    3126. 

  3126.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3127. 

  3127.              iX += pData->iColinc)
    3128. 

  3128.         {                              /* copy the values */
    3129. 

  3129.           *pScanline     = *pDataline;
    3130. 

  3130.           *(pScanline+1) = *(pDataline+1);
    3131. 

  3131.           *(pScanline+2) = *(pDataline+2);
    3132. 

  3132.           *pAlphaline    = *(pDataline+3);
    3133. 

  3133. 

  3134.           pScanline  += (pData->iColinc * 3);
    3135. 

  3135.           pAlphaline += pData->iColinc;
    3136. 

  3136.           pDataline  += 4;
    3137. 

  3137.         }
    3138. 

  3138.       }
    3139. 

  3139.     }
    3140. 

  3140.     else
    3141. 

  3141.     {
    3142. 

  3142.       {
    3143. 

  3143.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3144. 

  3144.              iX += pData->iColinc)
    3145. 

  3145.         {
    3146. 

  3146.           iFGa8 = *(pDataline+3);      /* get alpha values */
    3147. 

  3147.           iBGa8 = *pAlphaline;
    3148. 

  3148. 

  3149.           if (iFGa8)                   /* any opacity at all ? */
    3150. 

  3150.           {                            /* fully opaque or background fully transparent ? */
    3151. 

  3151.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    3152. 

  3152.             {                          /* then simply copy the values */
    3153. 

  3153.               *pScanline     = *pDataline;
    3154. 

  3154.               *(pScanline+1) = *(pDataline+1);
    3155. 

  3155.               *(pScanline+2) = *(pDataline+2);
    3156. 

  3156.               *pAlphaline    = *(pDataline+3);
    3157. 

  3157.             }
    3158. 

  3158.             else
    3159. 

  3159.             {
    3160. 

  3160.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    3161. 

  3161.               {                        /* do alpha composing */
    3162. 

  3162. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    3163. 

  3163.               int i;
    3164. 

  3164.               for (i=2; i >= 0; i--)
    3165. 

  3165.               {
    3166. 

  3166.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+i), iFGa8, *(pScanline+i));
    3167. 

  3167.               }
    3168. 

  3168. #else
    3169. 

  3169.                 MNG_COMPOSE8 (*pScanline,     *pDataline,     iFGa8, *pScanline    );
    3170. 

  3170.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
    3171. 

  3171.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+2), iFGa8, *(pScanline+2));
    3172. 

  3172. #endif
    3173. 

  3173.                                        /* alpha remains fully opaque !!! */
    3174. 

  3174.               }
    3175. 

  3175.               else
    3176. 

  3176.               {                        /* now blend */
    3177. 

  3177.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    3178. 

  3178.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    3179. 

  3179.                             iCr8, iCg8, iCb8, iCa8);
    3180. 

  3180.                                        /* and return the composed values */
    3181. 

  3181.                 *pScanline     = iCr8;
    3182. 

  3182.                 *(pScanline+1) = iCg8;
    3183. 

  3183.                 *(pScanline+2) = iCb8;
    3184. 

  3184.                 *pAlphaline    = iCa8;
    3185. 

  3185.               }
    3186. 

  3186.             }
    3187. 

  3187.           }
    3188. 

  3188. 

  3189.           pScanline  += (pData->iColinc * 3);
    3190. 

  3190.           pAlphaline += pData->iColinc;
    3191. 

  3191.           pDataline  += 4;
    3192. 

  3192.         }
    3193. 

  3193.       }
    3194. 

  3194.     }
    3195. 

  3195.   }
    3196. 

  3196. 

  3197.   check_update_region (pData);
    3198. 

  3198. 

  3199. #ifdef MNG_SUPPORT_TRACE
    3200. 

  3200.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB8_A8, MNG_LC_END);
    3201. 

  3201. #endif
    3202. 

  3202. 

  3203.   return MNG_NOERROR;
    3204. 

  3204. }
    3205. 

  3205. #endif /* MNG_NO_16BIT_SUPPORT */
    3206. 

  3206. #endif /* MNG_SKIPCANVAS_RGB8_A8 */
    3207. 

  3207. 

  3208. /* ************************************************************************** */
    3209. 

  3209. 

  3210. #ifndef MNG_SKIPCANVAS_BGR8
    3211. 

  3211. #ifndef MNG_NO_16BIT_SUPPORT
    3212. 

  3212. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    3213. 

  3213. mng_retcode mng_display_bgr8 (mng_datap pData)
    3214. 

  3214. {
    3215. 

  3215.   mng_uint8p pScanline;
    3216. 

  3216.   mng_uint8p pDataline;
    3217. 

  3217.   mng_int32  iX;
    3218. 

  3218.   mng_uint16 iA16;
    3219. 

  3219.   mng_uint16 iFGr16, iFGg16, iFGb16;
    3220. 

  3220.   mng_uint16 iBGr16, iBGg16, iBGb16;
    3221. 

  3221.   mng_uint8  iA8;
    3222. 

  3222. 

  3223. #ifdef MNG_SUPPORT_TRACE
    3224. 

  3224.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_START);
    3225. 

  3225. #endif
    3226. 

  3226.                                        /* viewable row ? */
    3227. 

  3227.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3228. 

  3228.   {                                    /* address destination row */
    3229. 

  3229.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3230. 

  3230.                                                    pData->iRow + pData->iDestt -
    3231. 

  3231.                                                    pData->iSourcet);
    3232. 

  3232.                                        /* adjust destination row starting-point */
    3233. 

  3233.     pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
    3234. 

  3234.     pDataline = pData->pRGBArow;       /* address source row */
    3235. 

  3235. 

  3236.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    3237. 

  3237.       pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 8;
    3238. 

  3238.     else
    3239. 

  3239.       pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
    3240. 

  3240. 

  3241.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3242. 

  3242.     {
    3243. 

  3243.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3244. 

  3244.       {
    3245. 

  3245.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3246. 

  3246.              iX += pData->iColinc)
    3247. 

  3247.         {                              /* scale down by dropping the LSB */
    3248. 

  3248.           *pScanline     = *(pDataline+4);
    3249. 

  3249.           *(pScanline+1) = *(pDataline+2);
    3250. 

  3250.           *(pScanline+2) = *pDataline;
    3251. 

  3251. 

  3252.           pScanline += (pData->iColinc * 3);
    3253. 

  3253.           pDataline += 8;
    3254. 

  3254.         }
    3255. 

  3255.       }
    3256. 

  3256.       else
    3257. 

  3257.       {
    3258. 

  3258.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3259. 

  3259.              iX += pData->iColinc)
    3260. 

  3260.         {                              /* copy the values */
    3261. 

  3261.           *pScanline     = *(pDataline+2);
    3262. 

  3262.           *(pScanline+1) = *(pDataline+1);
    3263. 

  3263.           *(pScanline+2) = *pDataline;
    3264. 

  3264. 

  3265.           pScanline += (pData->iColinc * 3);
    3266. 

  3266.           pDataline += 4;
    3267. 

  3267.         }
    3268. 

  3268.       }
    3269. 

  3269.     }
    3270. 

  3270.     else
    3271. 

  3271.     {
    3272. 

  3272.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3273. 

  3273.       {
    3274. 

  3274.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3275. 

  3275.              iX += pData->iColinc)
    3276. 

  3276.         {                              /* get alpha value */
    3277. 

  3277.           iA16 = mng_get_uint16 (pDataline+6);
    3278. 

  3278. 

  3279.           if (iA16)                    /* any opacity at all ? */
    3280. 

  3280.           {
    3281. 

  3281.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    3282. 

  3282.             {                          /* scale down by dropping the LSB */
    3283. 

  3283.               *pScanline     = *(pDataline+4);
    3284. 

  3284.               *(pScanline+1) = *(pDataline+2);
    3285. 

  3285.               *(pScanline+2) = *pDataline;
    3286. 

  3286.             }
    3287. 

  3287.             else
    3288. 

  3288.             {                          /* get the proper values */
    3289. 

  3289.               iFGr16 = mng_get_uint16 (pDataline  );
    3290. 

  3290.               iFGg16 = mng_get_uint16 (pDataline+2);
    3291. 

  3291.               iFGb16 = mng_get_uint16 (pDataline+4);
    3292. 

  3292.                                        /* scale background up */
    3293. 

  3293.               iBGr16 = (mng_uint16)(*(pScanline+2));
    3294. 

  3294.               iBGg16 = (mng_uint16)(*(pScanline+1));
    3295. 

  3295.               iBGb16 = (mng_uint16)(*pScanline    );
    3296. 

  3296.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    3297. 

  3297.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    3298. 

  3298.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    3299. 

  3299.                                        /* now compose */
    3300. 

  3300.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    3301. 

  3301.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    3302. 

  3302.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    3303. 

  3303.                                        /* and return the composed values */
    3304. 

  3304.               *pScanline     = (mng_uint8)(iFGb16 >> 8);
    3305. 

  3305.               *(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
    3306. 

  3306.               *(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
    3307. 

  3307.             }
    3308. 

  3308.           }
    3309. 

  3309. 

  3310.           pScanline += (pData->iColinc * 3);
    3311. 

  3311.           pDataline += 8;
    3312. 

  3312.         }
    3313. 

  3313.       }
    3314. 

  3314.       else
    3315. 

  3315.       {
    3316. 

  3316.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3317. 

  3317.              iX += pData->iColinc)
    3318. 

  3318.         {
    3319. 

  3319.           iA8 = *(pDataline+3);        /* get alpha value */
    3320. 

  3320. 

  3321.           if (iA8)                     /* any opacity at all ? */
    3322. 

  3322.           {
    3323. 

  3323.             if (iA8 == 0xFF)           /* fully opaque ? */
    3324. 

  3324.             {                          /* then simply copy the values */
    3325. 

  3325.               *pScanline     = *(pDataline+2);
    3326. 

  3326.               *(pScanline+1) = *(pDataline+1);
    3327. 

  3327.               *(pScanline+2) = *pDataline;
    3328. 

  3328.             }
    3329. 

  3329.             else
    3330. 

  3330.             {                          /* do alpha composing */
    3331. 

  3331.               MNG_COMPOSE8 (*pScanline,     *(pDataline+2), iA8, *pScanline    );
    3332. 

  3332.               MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
    3333. 

  3333.               MNG_COMPOSE8 (*(pScanline+2), *pDataline,     iA8, *(pScanline+2));
    3334. 

  3334.             }
    3335. 

  3335.           }
    3336. 

  3336. 

  3337.           pScanline += (pData->iColinc * 3);
    3338. 

  3338.           pDataline += 4;
    3339. 

  3339.         }
    3340. 

  3340.       }
    3341. 

  3341.     }
    3342. 

  3342.   }
    3343. 

  3343. 

  3344.   check_update_region (pData);
    3345. 

  3345. 

  3346. #ifdef MNG_SUPPORT_TRACE
    3347. 

  3347.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_END);
    3348. 

  3348. #endif
    3349. 

  3349. 

  3350.   return MNG_NOERROR;
    3351. 

  3351. }
    3352. 

  3352. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    3353. 

  3353. mng_retcode mng_display_bgr8 (mng_datap pData)
    3354. 

  3354. {
    3355. 

  3355.   mng_uint8p pScanline;
    3356. 

  3356.   mng_uint8p pDataline;
    3357. 

  3357.   mng_int32  iX;
    3358. 

  3358.   mng_uint16 iA16;
    3359. 

  3359.   mng_uint16 iFGg16;
    3360. 

  3360.   mng_uint16 iBGg16;
    3361. 

  3361.   mng_uint8  iA8;
    3362. 

  3362.   mng_uint8  iBps;
    3363. 

  3363. 

  3364. #ifdef MNG_SUPPORT_TRACE
    3365. 

  3365.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_START);
    3366. 

  3366. #endif
    3367. 

  3367. 

  3368.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    3369. 

  3369.                                        /* viewable row ? */
    3370. 

  3370.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3371. 

  3371.   {                                    /* address destination row */
    3372. 

  3372.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3373. 

  3373.                                                    pData->iRow + pData->iDestt -
    3374. 

  3374.                                                    pData->iSourcet);
    3375. 

  3375.                                        /* adjust destination row starting-point */
    3376. 

  3376.     pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
    3377. 

  3377.     pDataline = pData->pRGBArow;       /* address source row */
    3378. 

  3378. 

  3379.     /* adjust source row starting-point */
    3380. 

  3380.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    3381. 

  3381. 

  3382.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3383. 

  3383.     {
    3384. 

  3384.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3385. 

  3385.              iX += pData->iColinc)
    3386. 

  3386.         {                              /* scale down by dropping the LSB */
    3387. 

  3387.           *pScanline     = *(pDataline+2*iBps);
    3388. 

  3388.           *(pScanline+1) = *(pDataline+iBps);
    3389. 

  3389.           *(pScanline+2) = *pDataline;
    3390. 

  3390. 

  3391.           pScanline += (pData->iColinc * 3);
    3392. 

  3392.           pDataline += 4*iBps;
    3393. 

  3393.         }
    3394. 

  3394.     }
    3395. 

  3395.     else
    3396. 

  3396.     {
    3397. 

  3397.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3398. 

  3398.       {
    3399. 

  3399.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3400. 

  3400.              iX += pData->iColinc)
    3401. 

  3401.         {                              /* get alpha value */
    3402. 

  3402.           iA16 = mng_get_uint16 (pDataline+6);
    3403. 

  3403. 

  3404.           if (iA16)                    /* any opacity at all ? */
    3405. 

  3405.           {
    3406. 

  3406.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    3407. 

  3407.             {                          /* scale down by dropping the LSB */
    3408. 

  3408.               *pScanline     = *(pDataline+4);
    3409. 

  3409.               *(pScanline+1) = *(pDataline+2);
    3410. 

  3410.               *(pScanline+2) = *pDataline;
    3411. 

  3411.             }
    3412. 

  3412.             else
    3413. 

  3413.             {                          /* get the proper values */
    3414. 

  3414.               int i;
    3415. 

  3415.               for (i=2; i >= 0; i--)
    3416. 

  3416.               {
    3417. 

  3417.               iFGg16 = mng_get_uint16 (pDataline+i+i);
    3418. 

  3418.                                        /* scale background up */
    3419. 

  3419.               iBGg16 = (mng_uint16)(*(pScanline+2-i));
    3420. 

  3420.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    3421. 

  3421.                                        /* now compose */
    3422. 

  3422.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    3423. 

  3423.                                        /* and return the composed values */
    3424. 

  3424.               *(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
    3425. 

  3425.               }
    3426. 

  3426.             }
    3427. 

  3427.           }
    3428. 

  3428. 

  3429.           pScanline += (pData->iColinc * 3);
    3430. 

  3430.           pDataline += 8;
    3431. 

  3431.         }
    3432. 

  3432.       }
    3433. 

  3433.       else
    3434. 

  3434.       {
    3435. 

  3435.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3436. 

  3436.              iX += pData->iColinc)
    3437. 

  3437.         {
    3438. 

  3438.           iA8 = *(pDataline+3);        /* get alpha value */
    3439. 

  3439. 

  3440.           if (iA8)                     /* any opacity at all ? */
    3441. 

  3441.           {
    3442. 

  3442.             if (iA8 == 0xFF)           /* fully opaque ? */
    3443. 

  3443.             {                          /* then simply copy the values */
    3444. 

  3444.               *pScanline     = *(pDataline+2);
    3445. 

  3445.               *(pScanline+1) = *(pDataline+1);
    3446. 

  3446.               *(pScanline+2) = *pDataline;
    3447. 

  3447.             }
    3448. 

  3448.             else
    3449. 

  3449.             {                          /* do alpha composing */
    3450. 

  3450.               int i;
    3451. 

  3451.               for (i=2; i >= 0; i--)
    3452. 

  3452.               {
    3453. 

  3453.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iA8, *(pScanline+i));
    3454. 

  3454.               }
    3455. 

  3455.             }
    3456. 

  3456.           }
    3457. 

  3457. 

  3458.           pScanline += (pData->iColinc * 3);
    3459. 

  3459.           pDataline += 4;
    3460. 

  3460.         }
    3461. 

  3461.       }
    3462. 

  3462.     }
    3463. 

  3463.   }
    3464. 

  3464. 

  3465.   check_update_region (pData);
    3466. 

  3466. 

  3467. #ifdef MNG_SUPPORT_TRACE
    3468. 

  3468.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_END);
    3469. 

  3469. #endif
    3470. 

  3470. 

  3471.   return MNG_NOERROR;
    3472. 

  3472. }
    3473. 

  3473. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    3474. 

  3474. #else /* MNG_NO_16BIT_SUPPORT */
    3475. 

  3475. mng_retcode mng_display_bgr8 (mng_datap pData)
    3476. 

  3476. {
    3477. 

  3477.   mng_uint8p pScanline;
    3478. 

  3478.   mng_uint8p pDataline;
    3479. 

  3479.   mng_int32  iX;
    3480. 

  3480.   mng_uint8  iA8;
    3481. 

  3481. 

  3482. #ifdef MNG_SUPPORT_TRACE
    3483. 

  3483.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_START);
    3484. 

  3484. #endif
    3485. 

  3485.                                        /* viewable row ? */
    3486. 

  3486.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3487. 

  3487.   {                                    /* address destination row */
    3488. 

  3488.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3489. 

  3489.                                                    pData->iRow + pData->iDestt -
    3490. 

  3490.                                                    pData->iSourcet);
    3491. 

  3491.                                        /* adjust destination row starting-point */
    3492. 

  3492.     pScanline = pScanline + (pData->iCol * 3) + (pData->iDestl * 3);
    3493. 

  3493.     pDataline = pData->pRGBArow;       /* address source row */
    3494. 

  3494. 

  3495.       pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
    3496. 

  3496. 

  3497.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3498. 

  3498.     {
    3499. 

  3499.       {
    3500. 

  3500.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3501. 

  3501.              iX += pData->iColinc)
    3502. 

  3502.         {                              /* copy the values */
    3503. 

  3503.           *pScanline     = *(pDataline+2);
    3504. 

  3504.           *(pScanline+1) = *(pDataline+1);
    3505. 

  3505.           *(pScanline+2) = *pDataline;
    3506. 

  3506. 

  3507.           pScanline += (pData->iColinc * 3);
    3508. 

  3508.           pDataline += 4;
    3509. 

  3509.         }
    3510. 

  3510.       }
    3511. 

  3511.     }
    3512. 

  3512.     else
    3513. 

  3513.     {
    3514. 

  3514.       {
    3515. 

  3515.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3516. 

  3516.              iX += pData->iColinc)
    3517. 

  3517.         {
    3518. 

  3518.           iA8 = *(pDataline+3);        /* get alpha value */
    3519. 

  3519. 

  3520.           if (iA8)                     /* any opacity at all ? */
    3521. 

  3521.           {
    3522. 

  3522.             if (iA8 == 0xFF)           /* fully opaque ? */
    3523. 

  3523.             {                          /* then simply copy the values */
    3524. 

  3524.               *pScanline     = *(pDataline+2);
    3525. 

  3525.               *(pScanline+1) = *(pDataline+1);
    3526. 

  3526.               *(pScanline+2) = *pDataline;
    3527. 

  3527.             }
    3528. 

  3528.             else
    3529. 

  3529.             {                          /* do alpha composing */
    3530. 

  3530. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    3531. 

  3531.               int i;
    3532. 

  3532.               for (i=2; i >= 0; i--)
    3533. 

  3533.               {
    3534. 

  3534.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iA8, *(pScanline+i));
    3535. 

  3535.               }
    3536. 

  3536. #else
    3537. 

  3537.               MNG_COMPOSE8 (*pScanline,     *(pDataline+2), iA8, *pScanline    );
    3538. 

  3538.               MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
    3539. 

  3539.               MNG_COMPOSE8 (*(pScanline+2), *pDataline,     iA8, *(pScanline+2));
    3540. 

  3540. #endif
    3541. 

  3541.             }
    3542. 

  3542.           }
    3543. 

  3543. 

  3544.           pScanline += (pData->iColinc * 3);
    3545. 

  3545.           pDataline += 4;
    3546. 

  3546.         }
    3547. 

  3547.       }
    3548. 

  3548.     }
    3549. 

  3549.   }
    3550. 

  3550. 

  3551.   check_update_region (pData);
    3552. 

  3552. 

  3553. #ifdef MNG_SUPPORT_TRACE
    3554. 

  3554.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR8, MNG_LC_END);
    3555. 

  3555. #endif
    3556. 

  3556. 

  3557.   return MNG_NOERROR;
    3558. 

  3558. }
    3559. 

  3559. #endif /* MNG_NO_16BIT_SUPPORT */
    3560. 

  3560. #endif /* MNG_SKIPCANVAS_BGR8 */
    3561. 

  3561. 

  3562. /* ************************************************************************** */
    3563. 

  3563. 

  3564. #ifndef MNG_SKIPCANVAS_BGRX8
    3565. 

  3565. #ifndef MNG_NO_16BIT_SUPPORT
    3566. 

  3566. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    3567. 

  3567. mng_retcode mng_display_bgrx8 (mng_datap pData)
    3568. 

  3568. {
    3569. 

  3569.   mng_uint8p pScanline;
    3570. 

  3570.   mng_uint8p pDataline;
    3571. 

  3571.   mng_int32  iX;
    3572. 

  3572.   mng_uint16 iA16;
    3573. 

  3573.   mng_uint16 iFGr16, iFGg16, iFGb16;
    3574. 

  3574.   mng_uint16 iBGr16, iBGg16, iBGb16;
    3575. 

  3575.   mng_uint8  iA8;
    3576. 

  3576. 

  3577. #ifdef MNG_SUPPORT_TRACE
    3578. 

  3578.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_START);
    3579. 

  3579. #endif
    3580. 

  3580.                                        /* viewable row ? */
    3581. 

  3581.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3582. 

  3582.   {                                    /* address destination row */
    3583. 

  3583.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3584. 

  3584.                                                    pData->iRow + pData->iDestt -
    3585. 

  3585.                                                    pData->iSourcet);
    3586. 

  3586.                                        /* adjust destination row starting-point */
    3587. 

  3587.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    3588. 

  3588.     pDataline = pData->pRGBArow;       /* address source row */
    3589. 

  3589. 

  3590.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    3591. 

  3591.       pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 8;
    3592. 

  3592.     else
    3593. 

  3593.       pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
    3594. 

  3594. 

  3595.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3596. 

  3596.     {
    3597. 

  3597.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3598. 

  3598.       {
    3599. 

  3599.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3600. 

  3600.              iX += pData->iColinc)
    3601. 

  3601.         {                              /* scale down by dropping the LSB */
    3602. 

  3602.           *pScanline     = *(pDataline+4);
    3603. 

  3603.           *(pScanline+1) = *(pDataline+2);
    3604. 

  3604.           *(pScanline+2) = *pDataline;
    3605. 

  3605.           *(pScanline+3) = 0xFF;       /* filler byte */
    3606. 

  3606. 

  3607.           pScanline += (pData->iColinc << 2);
    3608. 

  3608.           pDataline += 8;
    3609. 

  3609.         }
    3610. 

  3610.       }
    3611. 

  3611.       else
    3612. 

  3612.       {
    3613. 

  3613.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3614. 

  3614.              iX += pData->iColinc)
    3615. 

  3615.         {                              /* copy the values */
    3616. 

  3616.           *pScanline     = *(pDataline+2);
    3617. 

  3617.           *(pScanline+1) = *(pDataline+1);
    3618. 

  3618.           *(pScanline+2) = *pDataline;
    3619. 

  3619.           *(pScanline+3) = 0xFF;       /* filler byte */
    3620. 

  3620. 

  3621.           pScanline += (pData->iColinc << 2);
    3622. 

  3622.           pDataline += 4;
    3623. 

  3623.         }
    3624. 

  3624.       }
    3625. 

  3625.     }
    3626. 

  3626.     else
    3627. 

  3627.     {
    3628. 

  3628.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3629. 

  3629.       {
    3630. 

  3630.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3631. 

  3631.              iX += pData->iColinc)
    3632. 

  3632.         {                              /* get alpha value */
    3633. 

  3633.           iA16 = mng_get_uint16 (pDataline+6);
    3634. 

  3634. 

  3635.           if (iA16)                    /* any opacity at all ? */
    3636. 

  3636.           {
    3637. 

  3637.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    3638. 

  3638.             {                          /* scale down by dropping the LSB */
    3639. 

  3639.               *pScanline     = *(pDataline+4);
    3640. 

  3640.               *(pScanline+1) = *(pDataline+2);
    3641. 

  3641.               *(pScanline+2) = *pDataline;
    3642. 

  3642.               *(pScanline+3) = 0xFF;   /* filler byte */
    3643. 

  3643.             }
    3644. 

  3644.             else
    3645. 

  3645.             {                          /* get the proper values */
    3646. 

  3646.               iFGr16 = mng_get_uint16 (pDataline  );
    3647. 

  3647.               iFGg16 = mng_get_uint16 (pDataline+2);
    3648. 

  3648.               iFGb16 = mng_get_uint16 (pDataline+4);
    3649. 

  3649.                                        /* scale background up */
    3650. 

  3650.               iBGr16 = (mng_uint16)(*(pScanline+2));
    3651. 

  3651.               iBGg16 = (mng_uint16)(*(pScanline+1));
    3652. 

  3652.               iBGb16 = (mng_uint16)(*pScanline    );
    3653. 

  3653.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    3654. 

  3654.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    3655. 

  3655.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    3656. 

  3656.                                        /* now compose */
    3657. 

  3657.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    3658. 

  3658.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    3659. 

  3659.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    3660. 

  3660.                                        /* and return the composed values */
    3661. 

  3661.               *pScanline     = (mng_uint8)(iFGb16 >> 8);
    3662. 

  3662.               *(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
    3663. 

  3663.               *(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
    3664. 

  3664.               *(pScanline+3) = 0xFF;   /* filler byte */
    3665. 

  3665.             }
    3666. 

  3666.           }
    3667. 

  3667. 

  3668.           pScanline += (pData->iColinc << 2);
    3669. 

  3669.           pDataline += 8;
    3670. 

  3670.         }
    3671. 

  3671.       }
    3672. 

  3672.       else
    3673. 

  3673.       {
    3674. 

  3674.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3675. 

  3675.              iX += pData->iColinc)
    3676. 

  3676.         {
    3677. 

  3677.           iA8 = *(pDataline+3);        /* get alpha value */
    3678. 

  3678. 

  3679.           if (iA8)                     /* any opacity at all ? */
    3680. 

  3680.           {
    3681. 

  3681.             if (iA8 == 0xFF)           /* fully opaque ? */
    3682. 

  3682.             {                          /* then simply copy the values */
    3683. 

  3683.               *pScanline     = *(pDataline+2);
    3684. 

  3684.               *(pScanline+1) = *(pDataline+1);
    3685. 

  3685.               *(pScanline+2) = *pDataline;
    3686. 

  3686.               *(pScanline+3) = 0xFF;   /* filler byte */
    3687. 

  3687.             }
    3688. 

  3688.             else
    3689. 

  3689.             {                          /* do alpha composing */
    3690. 

  3690.               MNG_COMPOSE8 (*pScanline,     *(pDataline+2), iA8, *pScanline    );
    3691. 

  3691.               MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
    3692. 

  3692.               MNG_COMPOSE8 (*(pScanline+2), *pDataline,     iA8, *(pScanline+2));
    3693. 

  3693.               *(pScanline+3) = 0xFF;   /* filler byte */
    3694. 

  3694.             }
    3695. 

  3695.           }
    3696. 

  3696. 

  3697.           pScanline += (pData->iColinc << 2);
    3698. 

  3698.           pDataline += 4;
    3699. 

  3699.         }
    3700. 

  3700.       }
    3701. 

  3701.     }
    3702. 

  3702.   }
    3703. 

  3703. 

  3704.   check_update_region (pData);
    3705. 

  3705. 

  3706. #ifdef MNG_SUPPORT_TRACE
    3707. 

  3707.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_END);
    3708. 

  3708. #endif
    3709. 

  3709. 

  3710.   return MNG_NOERROR;
    3711. 

  3711. }
    3712. 

  3712. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    3713. 

  3713. mng_retcode mng_display_bgrx8 (mng_datap pData)
    3714. 

  3714. {
    3715. 

  3715.   mng_uint8p pScanline;
    3716. 

  3716.   mng_uint8p pDataline;
    3717. 

  3717.   mng_int32  iX;
    3718. 

  3718.   mng_uint16 iA16;
    3719. 

  3719.   mng_uint16 iFGg16;
    3720. 

  3720.   mng_uint16 iBGg16;
    3721. 

  3721.   mng_uint8  iA8;
    3722. 

  3722.   mng_uint8  iBps;
    3723. 

  3723. 

  3724. #ifdef MNG_SUPPORT_TRACE
    3725. 

  3725.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_START);
    3726. 

  3726. #endif
    3727. 

  3727. 

  3728.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    3729. 

  3729.                                        /* viewable row ? */
    3730. 

  3730.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3731. 

  3731.   {                                    /* address destination row */
    3732. 

  3732.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3733. 

  3733.                                                    pData->iRow + pData->iDestt -
    3734. 

  3734.                                                    pData->iSourcet);
    3735. 

  3735.                                        /* adjust destination row starting-point */
    3736. 

  3736.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    3737. 

  3737.     pDataline = pData->pRGBArow;       /* address source row */
    3738. 

  3738. 

  3739.     /* adjust source row starting-point */
    3740. 

  3740.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    3741. 

  3741. 

  3742.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3743. 

  3743.     {
    3744. 

  3744.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3745. 

  3745.              iX += pData->iColinc)
    3746. 

  3746.         {                              /* scale down by dropping the LSB */
    3747. 

  3747.           *pScanline     = *(pDataline+2*iBps);
    3748. 

  3748.           *(pScanline+1) = *(pDataline+iBps);
    3749. 

  3749.           *(pScanline+2) = *pDataline;
    3750. 

  3750.           *(pScanline+3) = 0xFF;       /* filler byte */
    3751. 

  3751. 

  3752.           pScanline += (pData->iColinc << 2);
    3753. 

  3753.           pDataline += 4*iBps;
    3754. 

  3754.         }
    3755. 

  3755.     }
    3756. 

  3756.     else
    3757. 

  3757.     {
    3758. 

  3758.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3759. 

  3759.       {
    3760. 

  3760.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3761. 

  3761.              iX += pData->iColinc)
    3762. 

  3762.         {                              /* get alpha value */
    3763. 

  3763.           iA16 = mng_get_uint16 (pDataline+6);
    3764. 

  3764. 

  3765.           if (iA16)                    /* any opacity at all ? */
    3766. 

  3766.           {
    3767. 

  3767.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    3768. 

  3768.             {                          /* scale down by dropping the LSB */
    3769. 

  3769.               *pScanline     = *(pDataline+4);
    3770. 

  3770.               *(pScanline+1) = *(pDataline+2);
    3771. 

  3771.               *(pScanline+2) = *pDataline;
    3772. 

  3772.               *(pScanline+3) = 0xFF;   /* filler byte */
    3773. 

  3773.             }
    3774. 

  3774.             else
    3775. 

  3775.             {                          /* get the proper values */
    3776. 

  3776.               int i;
    3777. 

  3777.               for (i=2; i >= 0; i--)
    3778. 

  3778.               {
    3779. 

  3779.               iFGg16 = mng_get_uint16 (pDataline+i+i);
    3780. 

  3780.                                        /* scale background up */
    3781. 

  3781.               iBGg16 = (mng_uint16)(*(pScanline+2-i));
    3782. 

  3782.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    3783. 

  3783.                                        /* now compose */
    3784. 

  3784.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    3785. 

  3785.                                        /* and return the composed values */
    3786. 

  3786.               *(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
    3787. 

  3787.               }
    3788. 

  3788.               *(pScanline+3) = 0xFF;   /* filler byte */
    3789. 

  3789.             }
    3790. 

  3790.           }
    3791. 

  3791. 

  3792.           pScanline += (pData->iColinc << 2);
    3793. 

  3793.           pDataline += 8;
    3794. 

  3794.         }
    3795. 

  3795.       }
    3796. 

  3796.       else
    3797. 

  3797.       {
    3798. 

  3798.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3799. 

  3799.              iX += pData->iColinc)
    3800. 

  3800.         {
    3801. 

  3801.           iA8 = *(pDataline+3);        /* get alpha value */
    3802. 

  3802. 

  3803.           if (iA8)                     /* any opacity at all ? */
    3804. 

  3804.           {
    3805. 

  3805.             if (iA8 == 0xFF)           /* fully opaque ? */
    3806. 

  3806.             {                          /* then simply copy the values */
    3807. 

  3807.               *pScanline     = *(pDataline+2);
    3808. 

  3808.               *(pScanline+1) = *(pDataline+1);
    3809. 

  3809.               *(pScanline+2) = *pDataline;
    3810. 

  3810.               *(pScanline+3) = 0xFF;   /* filler byte */
    3811. 

  3811.             }
    3812. 

  3812.             else
    3813. 

  3813.             {                          /* do alpha composing */
    3814. 

  3814.               int i;
    3815. 

  3815.               for (i=2; i >= 0; i--)
    3816. 

  3816.               {
    3817. 

  3817.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iA8, *(pScanline+i));
    3818. 

  3818.               }
    3819. 

  3819.               *(pScanline+3) = 0xFF;   /* filler byte */
    3820. 

  3820.             }
    3821. 

  3821.           }
    3822. 

  3822. 

  3823.           pScanline += (pData->iColinc << 2);
    3824. 

  3824.           pDataline += 4;
    3825. 

  3825.         }
    3826. 

  3826.       }
    3827. 

  3827.     }
    3828. 

  3828.   }
    3829. 

  3829. 

  3830.   check_update_region (pData);
    3831. 

  3831. 

  3832. #ifdef MNG_SUPPORT_TRACE
    3833. 

  3833.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_END);
    3834. 

  3834. #endif
    3835. 

  3835. 

  3836.   return MNG_NOERROR;
    3837. 

  3837. }
    3838. 

  3838. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    3839. 

  3839. #else /* MNG_NO_16BIT_SUPPORT */
    3840. 

  3840. mng_retcode mng_display_bgrx8 (mng_datap pData)
    3841. 

  3841. {
    3842. 

  3842.   mng_uint8p pScanline;
    3843. 

  3843.   mng_uint8p pDataline;
    3844. 

  3844.   mng_int32  iX;
    3845. 

  3845.   mng_uint8  iA8;
    3846. 

  3846. 

  3847. #ifdef MNG_SUPPORT_TRACE
    3848. 

  3848.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_START);
    3849. 

  3849. #endif
    3850. 

  3850.                                        /* viewable row ? */
    3851. 

  3851.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3852. 

  3852.   {                                    /* address destination row */
    3853. 

  3853.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3854. 

  3854.                                                    pData->iRow + pData->iDestt -
    3855. 

  3855.                                                    pData->iSourcet);
    3856. 

  3856.                                        /* adjust destination row starting-point */
    3857. 

  3857.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    3858. 

  3858.     pDataline = pData->pRGBArow;       /* address source row */
    3859. 

  3859. 

  3860.       pDataline = pDataline + (pData->iSourcel / pData->iColinc) * 4;
    3861. 

  3861. 

  3862.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3863. 

  3863.     {
    3864. 

  3864.       {
    3865. 

  3865.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3866. 

  3866.              iX += pData->iColinc)
    3867. 

  3867.         {                              /* copy the values */
    3868. 

  3868.           *pScanline     = *(pDataline+2);
    3869. 

  3869.           *(pScanline+1) = *(pDataline+1);
    3870. 

  3870.           *(pScanline+2) = *pDataline;
    3871. 

  3871.           *(pScanline+3) = 0xFF;       /* filler byte */
    3872. 

  3872. 

  3873.           pScanline += (pData->iColinc << 2);
    3874. 

  3874.           pDataline += 4;
    3875. 

  3875.         }
    3876. 

  3876.       }
    3877. 

  3877.     }
    3878. 

  3878.     else
    3879. 

  3879.     {
    3880. 

  3880.       {
    3881. 

  3881.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3882. 

  3882.              iX += pData->iColinc)
    3883. 

  3883.         {
    3884. 

  3884.           iA8 = *(pDataline+3);        /* get alpha value */
    3885. 

  3885. 

  3886.           if (iA8)                     /* any opacity at all ? */
    3887. 

  3887.           {
    3888. 

  3888.             if (iA8 == 0xFF)           /* fully opaque ? */
    3889. 

  3889.             {                          /* then simply copy the values */
    3890. 

  3890.               *pScanline     = *(pDataline+2);
    3891. 

  3891.               *(pScanline+1) = *(pDataline+1);
    3892. 

  3892.               *(pScanline+2) = *pDataline;
    3893. 

  3893.               *(pScanline+3) = 0xFF;   /* filler byte */
    3894. 

  3894.             }
    3895. 

  3895.             else
    3896. 

  3896.             {                          /* do alpha composing */
    3897. 

  3897. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    3898. 

  3898.               int i;
    3899. 

  3899.               for (i=2; i >= 0; i--)
    3900. 

  3900.               {
    3901. 

  3901.               MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iA8, *(pScanline+i));
    3902. 

  3902.               }
    3903. 

  3903. #else
    3904. 

  3904.               MNG_COMPOSE8 (*pScanline,     *(pDataline+2), iA8, *pScanline    );
    3905. 

  3905.               MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iA8, *(pScanline+1));
    3906. 

  3906.               MNG_COMPOSE8 (*(pScanline+2), *pDataline,     iA8, *(pScanline+2));
    3907. 

  3907. #endif
    3908. 

  3908.               *(pScanline+3) = 0xFF;   /* filler byte */
    3909. 

  3909.             }
    3910. 

  3910.           }
    3911. 

  3911. 

  3912.           pScanline += (pData->iColinc << 2);
    3913. 

  3913.           pDataline += 4;
    3914. 

  3914.         }
    3915. 

  3915.       }
    3916. 

  3916.     }
    3917. 

  3917.   }
    3918. 

  3918. 

  3919.   check_update_region (pData);
    3920. 

  3920. 

  3921. #ifdef MNG_SUPPORT_TRACE
    3922. 

  3922.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRX8, MNG_LC_END);
    3923. 

  3923. #endif
    3924. 

  3924. 

  3925.   return MNG_NOERROR;
    3926. 

  3926. }
    3927. 

  3927. #endif /* MNG_NO_16BIT_SUPPORT */
    3928. 

  3928. #endif /* MNG_SKIPCANVAS_BGRX8 */
    3929. 

  3929. 

  3930. /* ************************************************************************** */
    3931. 

  3931. 

  3932. #ifndef MNG_SKIPCANVAS_BGRA8
    3933. 

  3933. #ifndef MNG_NO_16BIT_SUPPORT
    3934. 

  3934. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    3935. 

  3935. mng_retcode mng_display_bgra8 (mng_datap pData)
    3936. 

  3936. {
    3937. 

  3937.   mng_uint8p pScanline;
    3938. 

  3938.   mng_uint8p pDataline;
    3939. 

  3939.   mng_int32  iX;
    3940. 

  3940.   mng_uint8  iFGa8, iBGa8, iCa8;
    3941. 

  3941.   mng_uint16 iFGa16, iBGa16, iCa16;
    3942. 

  3942.   mng_uint16 iFGr16, iFGg16, iFGb16;
    3943. 

  3943.   mng_uint16 iBGr16, iBGg16, iBGb16;
    3944. 

  3944.   mng_uint16 iCr16, iCg16, iCb16;
    3945. 

  3945.   mng_uint8  iCr8, iCg8, iCb8;
    3946. 

  3946. 

  3947. #ifdef MNG_SUPPORT_TRACE
    3948. 

  3948.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_START);
    3949. 

  3949. #endif
    3950. 

  3950.                                        /* viewable row ? */
    3951. 

  3951.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    3952. 

  3952.   {                                    /* address destination row */
    3953. 

  3953.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    3954. 

  3954.                                                    pData->iRow + pData->iDestt -
    3955. 

  3955.                                                    pData->iSourcet);
    3956. 

  3956.                                        /* adjust destination row starting-point */
    3957. 

  3957.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    3958. 

  3958.     pDataline = pData->pRGBArow;       /* address source row */
    3959. 

  3959. 

  3960.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    3961. 

  3961.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    3962. 

  3962.     else
    3963. 

  3963.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    3964. 

  3964. 

  3965.     if (pData->bIsOpaque)              /* forget about transparency ? */
    3966. 

  3966.     {
    3967. 

  3967.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3968. 

  3968.       {
    3969. 

  3969.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3970. 

  3970.              iX += pData->iColinc)
    3971. 

  3971.         {                              /* scale down by dropping the LSB */
    3972. 

  3972.           *pScanline     = *(pDataline+4);
    3973. 

  3973.           *(pScanline+1) = *(pDataline+2);
    3974. 

  3974.           *(pScanline+2) = *pDataline;
    3975. 

  3975.           *(pScanline+3) = *(pDataline+6);
    3976. 

  3976. 

  3977.           pScanline += (pData->iColinc << 2);
    3978. 

  3978.           pDataline += 8;
    3979. 

  3979.         }
    3980. 

  3980.       }
    3981. 

  3981.       else
    3982. 

  3982.       {
    3983. 

  3983.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    3984. 

  3984.              iX += pData->iColinc)
    3985. 

  3985.         {                              /* copy the values */
    3986. 

  3986.           *pScanline     = *(pDataline+2);
    3987. 

  3987.           *(pScanline+1) = *(pDataline+1);
    3988. 

  3988.           *(pScanline+2) = *pDataline;
    3989. 

  3989.           *(pScanline+3) = *(pDataline+3);
    3990. 

  3990. 

  3991.           pScanline += (pData->iColinc << 2);
    3992. 

  3992.           pDataline += 4;
    3993. 

  3993.         }
    3994. 

  3994.       }
    3995. 

  3995.     }
    3996. 

  3996.     else
    3997. 

  3997.     {
    3998. 

  3998.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    3999. 

  3999.       {
    4000. 

  4000.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4001. 

  4001.              iX += pData->iColinc)
    4002. 

  4002.         {                              /* get alpha values */
    4003. 

  4003.           iFGa16 = mng_get_uint16 (pDataline+6);
    4004. 

  4004.           iBGa16 = (mng_uint16)(*(pScanline+3));
    4005. 

  4005.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    4006. 

  4006. 

  4007.           if (iFGa16)                  /* any opacity at all ? */
    4008. 

  4008.           {                            /* fully opaque or background fully transparent ? */
    4009. 

  4009.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    4010. 

  4010.             {                          /* plain copy it */
    4011. 

  4011.               *pScanline     = *(pDataline+4);
    4012. 

  4012.               *(pScanline+1) = *(pDataline+2);
    4013. 

  4013.               *(pScanline+2) = *pDataline;
    4014. 

  4014.               *(pScanline+3) = *(pDataline+6);
    4015. 

  4015.             }
    4016. 

  4016.             else
    4017. 

  4017.             {
    4018. 

  4018.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    4019. 

  4019.               {                        /* get the proper values */
    4020. 

  4020.                 iFGr16 = mng_get_uint16 (pDataline  );
    4021. 

  4021.                 iFGg16 = mng_get_uint16 (pDataline+2);
    4022. 

  4022.                 iFGb16 = mng_get_uint16 (pDataline+4);
    4023. 

  4023.                                        /* scale background up */
    4024. 

  4024.                 iBGr16 = (mng_uint16)(*(pScanline+2));
    4025. 

  4025.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    4026. 

  4026.                 iBGb16 = (mng_uint16)(*pScanline    );
    4027. 

  4027.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    4028. 

  4028.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    4029. 

  4029.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    4030. 

  4030.                                        /* now compose */
    4031. 

  4031.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    4032. 

  4032.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    4033. 

  4033.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    4034. 

  4034.                                        /* and return the composed values */
    4035. 

  4035.                 *pScanline     = (mng_uint8)(iFGb16 >> 8);
    4036. 

  4036.                 *(pScanline+1) = (mng_uint8)(iFGg16 >> 8);
    4037. 

  4037.                 *(pScanline+2) = (mng_uint8)(iFGr16 >> 8);
    4038. 

  4038.                                        /* alpha remains fully opaque !!! */
    4039. 

  4039.               }
    4040. 

  4040.               else
    4041. 

  4041.               {                        /* scale background up */
    4042. 

  4042.                 iBGr16 = (mng_uint16)(*(pScanline+2));
    4043. 

  4043.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    4044. 

  4044.                 iBGb16 = (mng_uint16)(*pScanline    );
    4045. 

  4045.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    4046. 

  4046.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    4047. 

  4047.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    4048. 

  4048.                                        /* let's blend */
    4049. 

  4049.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    4050. 

  4050.                              mng_get_uint16 (pDataline+2),
    4051. 

  4051.                              mng_get_uint16 (pDataline+4), iFGa16,
    4052. 

  4052.                              iBGr16, iBGg16, iBGb16, iBGa16,
    4053. 

  4053.                              iCr16,  iCg16,  iCb16,  iCa16);
    4054. 

  4054.                                        /* and return the composed values */
    4055. 

  4055.                 *pScanline     = (mng_uint8)(iCb16 >> 8);
    4056. 

  4056.                 *(pScanline+1) = (mng_uint8)(iCg16 >> 8);
    4057. 

  4057.                 *(pScanline+2) = (mng_uint8)(iCr16 >> 8);
    4058. 

  4058.                 *(pScanline+3) = (mng_uint8)(iCa16 >> 8);
    4059. 

  4059.               }
    4060. 

  4060.             }
    4061. 

  4061.           }
    4062. 

  4062. 

  4063.           pScanline += (pData->iColinc << 2);
    4064. 

  4064.           pDataline += 8;
    4065. 

  4065.         }
    4066. 

  4066.       }
    4067. 

  4067.       else
    4068. 

  4068.       {
    4069. 

  4069.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4070. 

  4070.              iX += pData->iColinc)
    4071. 

  4071.         {
    4072. 

  4072.           iFGa8 = *(pDataline+3);      /* get alpha values */
    4073. 

  4073.           iBGa8 = *(pScanline+3);
    4074. 

  4074. 

  4075.           if (iFGa8)                   /* any opacity at all ? */
    4076. 

  4076.           {                            /* fully opaque or background fully transparent ? */
    4077. 

  4077.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    4078. 

  4078.             {                          /* then simply copy the values */
    4079. 

  4079.               *pScanline     = *(pDataline+2);
    4080. 

  4080.               *(pScanline+1) = *(pDataline+1);
    4081. 

  4081.               *(pScanline+2) = *pDataline;
    4082. 

  4082.               *(pScanline+3) = *(pDataline+3);
    4083. 

  4083.             }
    4084. 

  4084.             else
    4085. 

  4085.             {
    4086. 

  4086.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    4087. 

  4087.               {                        /* do alpha composing */
    4088. 

  4088.                 MNG_COMPOSE8 (*pScanline,     *(pDataline+2), iFGa8, *pScanline    );
    4089. 

  4089.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
    4090. 

  4090.                 MNG_COMPOSE8 (*(pScanline+2), *pDataline,     iFGa8, *(pScanline+2));
    4091. 

  4091.                                        /* alpha remains fully opaque !!! */
    4092. 

  4092.               }
    4093. 

  4093.               else
    4094. 

  4094.               {                        /* now blend */
    4095. 

  4095.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    4096. 

  4096.                             *(pScanline+2), *(pScanline+1), *pScanline,     iBGa8,
    4097. 

  4097.                             iCr8, iCg8, iCb8, iCa8);
    4098. 

  4098.                                        /* and return the composed values */
    4099. 

  4099.                 *pScanline     = iCb8;
    4100. 

  4100.                 *(pScanline+1) = iCg8;
    4101. 

  4101.                 *(pScanline+2) = iCr8;
    4102. 

  4102.                 *(pScanline+3) = iCa8;
    4103. 

  4103.               }
    4104. 

  4104.             }
    4105. 

  4105.           }
    4106. 

  4106. 

  4107.           pScanline += (pData->iColinc << 2);
    4108. 

  4108.           pDataline += 4;
    4109. 

  4109.         }
    4110. 

  4110.       }
    4111. 

  4111.     }
    4112. 

  4112.   }
    4113. 

  4113. 

  4114.   check_update_region (pData);
    4115. 

  4115. 

  4116. #ifdef MNG_SUPPORT_TRACE
    4117. 

  4117.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_END);
    4118. 

  4118. #endif
    4119. 

  4119. 

  4120.   return MNG_NOERROR;
    4121. 

  4121. }
    4122. 

  4122. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    4123. 

  4123. mng_retcode mng_display_bgra8 (mng_datap pData)
    4124. 

  4124. {
    4125. 

  4125.   mng_uint8p pScanline;
    4126. 

  4126.   mng_uint8p pDataline;
    4127. 

  4127.   mng_int32  iX;
    4128. 

  4128.   mng_uint8  iFGa8, iBGa8, iCa8;
    4129. 

  4129.   mng_uint16 iFGa16, iBGa16, iCa16;
    4130. 

  4130.   mng_uint16 iFGg16;
    4131. 

  4131.   mng_uint16 iBGr16, iBGg16, iBGb16;
    4132. 

  4132.   mng_uint16 iCr16, iCg16, iCb16;
    4133. 

  4133.   mng_uint8  iCr8, iCg8, iCb8;
    4134. 

  4134.   mng_uint8  iBps;
    4135. 

  4135. 

  4136. #ifdef MNG_SUPPORT_TRACE
    4137. 

  4137.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_START);
    4138. 

  4138. #endif
    4139. 

  4139. 

  4140.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    4141. 

  4141.                                        /* viewable row ? */
    4142. 

  4142.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    4143. 

  4143.   {                                    /* address destination row */
    4144. 

  4144.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    4145. 

  4145.                                                    pData->iRow + pData->iDestt -
    4146. 

  4146.                                                    pData->iSourcet);
    4147. 

  4147.                                        /* adjust destination row starting-point */
    4148. 

  4148.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    4149. 

  4149.     pDataline = pData->pRGBArow;       /* address source row */
    4150. 

  4150. 

  4151.     /* adjust source row starting-point */
    4152. 

  4152.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    4153. 

  4153. 

  4154.     if (pData->bIsOpaque)              /* forget about transparency ? */
    4155. 

  4155.     {
    4156. 

  4156.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4157. 

  4157.              iX += pData->iColinc)
    4158. 

  4158.         {                              /* scale down by dropping the LSB */
    4159. 

  4159.           *pScanline     = *(pDataline+2*iBps);
    4160. 

  4160.           *(pScanline+1) = *(pDataline+iBps);
    4161. 

  4161.           *(pScanline+2) = *pDataline;
    4162. 

  4162.           *(pScanline+3) = *(pDataline+3*iBps);
    4163. 

  4163. 

  4164.           pScanline += (pData->iColinc << 2);
    4165. 

  4165.           pDataline += 4*iBps;
    4166. 

  4166.         }
    4167. 

  4167.     }
    4168. 

  4168.     else
    4169. 

  4169.     {
    4170. 

  4170.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4171. 

  4171.       {
    4172. 

  4172.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4173. 

  4173.              iX += pData->iColinc)
    4174. 

  4174.         {                              /* get alpha values */
    4175. 

  4175.           iFGa16 = mng_get_uint16 (pDataline+6);
    4176. 

  4176.           iBGa16 = (mng_uint16)(*(pScanline+3));
    4177. 

  4177.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    4178. 

  4178. 

  4179.           if (iFGa16)                  /* any opacity at all ? */
    4180. 

  4180.           {                            /* fully opaque or background fully transparent ? */
    4181. 

  4181.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    4182. 

  4182.             {                          /* plain copy it */
    4183. 

  4183.               *pScanline     = *(pDataline+4);
    4184. 

  4184.               *(pScanline+1) = *(pDataline+2);
    4185. 

  4185.               *(pScanline+2) = *pDataline;
    4186. 

  4186.               *(pScanline+3) = *(pDataline+6);
    4187. 

  4187.             }
    4188. 

  4188.             else
    4189. 

  4189.             {
    4190. 

  4190.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    4191. 

  4191.               {                        /* get the proper values */
    4192. 

  4192.               int i;
    4193. 

  4193.               for (i=2; i >= 0; i--)
    4194. 

  4194.               {
    4195. 

  4195.                 iFGg16 = mng_get_uint16 (pDataline+i+i);
    4196. 

  4196.                                        /* scale background up */
    4197. 

  4197.                 iBGg16 = (mng_uint16)(*(pScanline+2-i));
    4198. 

  4198.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    4199. 

  4199.                                        /* now compose */
    4200. 

  4200.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    4201. 

  4201.                                        /* and return the composed values */
    4202. 

  4202.                 *(pScanline+2-i) = (mng_uint8)(iFGg16 >> 8);
    4203. 

  4203.                                        /* alpha remains fully opaque !!! */
    4204. 

  4204.               }
    4205. 

  4205.               }
    4206. 

  4206.               else
    4207. 

  4207.               {                        /* scale background up */
    4208. 

  4208.                 iBGr16 = (mng_uint16)(*(pScanline+2));
    4209. 

  4209.                 iBGg16 = (mng_uint16)(*(pScanline+1));
    4210. 

  4210.                 iBGb16 = (mng_uint16)(*pScanline    );
    4211. 

  4211.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    4212. 

  4212.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    4213. 

  4213.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    4214. 

  4214.                                        /* let's blend */
    4215. 

  4215.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    4216. 

  4216.                              mng_get_uint16 (pDataline+2),
    4217. 

  4217.                              mng_get_uint16 (pDataline+4), iFGa16,
    4218. 

  4218.                              iBGr16, iBGg16, iBGb16, iBGa16,
    4219. 

  4219.                              iCr16,  iCg16,  iCb16,  iCa16);
    4220. 

  4220.                                        /* and return the composed values */
    4221. 

  4221.                 *pScanline     = (mng_uint8)(iCb16 >> 8);
    4222. 

  4222.                 *(pScanline+1) = (mng_uint8)(iCg16 >> 8);
    4223. 

  4223.                 *(pScanline+2) = (mng_uint8)(iCr16 >> 8);
    4224. 

  4224.                 *(pScanline+3) = (mng_uint8)(iCa16 >> 8);
    4225. 

  4225.               }
    4226. 

  4226.             }
    4227. 

  4227.           }
    4228. 

  4228. 

  4229.           pScanline += (pData->iColinc << 2);
    4230. 

  4230.           pDataline += 8;
    4231. 

  4231.         }
    4232. 

  4232.       }
    4233. 

  4233.       else
    4234. 

  4234.       {
    4235. 

  4235.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4236. 

  4236.              iX += pData->iColinc)
    4237. 

  4237.         {
    4238. 

  4238.           iFGa8 = *(pDataline+3);      /* get alpha values */
    4239. 

  4239.           iBGa8 = *(pScanline+3);
    4240. 

  4240. 

  4241.           if (iFGa8)                   /* any opacity at all ? */
    4242. 

  4242.           {                            /* fully opaque or background fully transparent ? */
    4243. 

  4243.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    4244. 

  4244.             {                          /* then simply copy the values */
    4245. 

  4245.               *pScanline     = *(pDataline+2);
    4246. 

  4246.               *(pScanline+1) = *(pDataline+1);
    4247. 

  4247.               *(pScanline+2) = *pDataline;
    4248. 

  4248.               *(pScanline+3) = *(pDataline+3);
    4249. 

  4249.             }
    4250. 

  4250.             else
    4251. 

  4251.             {
    4252. 

  4252.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    4253. 

  4253.               {                        /* do alpha composing */
    4254. 

  4254.                 int i;
    4255. 

  4255.                 for (i=2; i >= 0; i--)
    4256. 

  4256.                 {
    4257. 

  4257.                 MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iFGa8, *(pScanline+i));
    4258. 

  4258.                 }
    4259. 

  4259.                                        /* alpha remains fully opaque !!! */
    4260. 

  4260.               }
    4261. 

  4261.               else
    4262. 

  4262.               {                        /* now blend */
    4263. 

  4263.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    4264. 

  4264.                             *(pScanline+2), *(pScanline+1), *pScanline,     iBGa8,
    4265. 

  4265.                             iCr8, iCg8, iCb8, iCa8);
    4266. 

  4266.                                        /* and return the composed values */
    4267. 

  4267.                 *pScanline     = iCb8;
    4268. 

  4268.                 *(pScanline+1) = iCg8;
    4269. 

  4269.                 *(pScanline+2) = iCr8;
    4270. 

  4270.                 *(pScanline+3) = iCa8;
    4271. 

  4271.               }
    4272. 

  4272.             }
    4273. 

  4273.           }
    4274. 

  4274. 

  4275.           pScanline += (pData->iColinc << 2);
    4276. 

  4276.           pDataline += 4;
    4277. 

  4277.         }
    4278. 

  4278.       }
    4279. 

  4279.     }
    4280. 

  4280.   }
    4281. 

  4281. 

  4282.   check_update_region (pData);
    4283. 

  4283. 

  4284. #ifdef MNG_SUPPORT_TRACE
    4285. 

  4285.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_END);
    4286. 

  4286. #endif
    4287. 

  4287. 

  4288.   return MNG_NOERROR;
    4289. 

  4289. }
    4290. 

  4290. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    4291. 

  4291. #else /* MNG_NO_16BIT_SUPPORT */
    4292. 

  4292. mng_retcode mng_display_bgra8 (mng_datap pData)
    4293. 

  4293. {
    4294. 

  4294.   mng_uint8p pScanline;
    4295. 

  4295.   mng_uint8p pDataline;
    4296. 

  4296.   mng_int32  iX;
    4297. 

  4297.   mng_uint8  iFGa8, iBGa8, iCa8;
    4298. 

  4298.   mng_uint8  iCr8, iCg8, iCb8;
    4299. 

  4299. 

  4300. #ifdef MNG_SUPPORT_TRACE
    4301. 

  4301.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_START);
    4302. 

  4302. #endif
    4303. 

  4303.                                        /* viewable row ? */
    4304. 

  4304.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    4305. 

  4305.   {                                    /* address destination row */
    4306. 

  4306.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    4307. 

  4307.                                                    pData->iRow + pData->iDestt -
    4308. 

  4308.                                                    pData->iSourcet);
    4309. 

  4309.                                        /* adjust destination row starting-point */
    4310. 

  4310.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    4311. 

  4311.     pDataline = pData->pRGBArow;       /* address source row */
    4312. 

  4312. 

  4313.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    4314. 

  4314. 

  4315.     if (pData->bIsOpaque)              /* forget about transparency ? */
    4316. 

  4316.     {
    4317. 

  4317.       {
    4318. 

  4318.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4319. 

  4319.              iX += pData->iColinc)
    4320. 

  4320.         {                              /* copy the values */
    4321. 

  4321.           *pScanline     = *(pDataline+2);
    4322. 

  4322.           *(pScanline+1) = *(pDataline+1);
    4323. 

  4323.           *(pScanline+2) = *pDataline;
    4324. 

  4324.           *(pScanline+3) = *(pDataline+3);
    4325. 

  4325. 

  4326.           pScanline += (pData->iColinc << 2);
    4327. 

  4327.           pDataline += 4;
    4328. 

  4328.         }
    4329. 

  4329.       }
    4330. 

  4330.     }
    4331. 

  4331.     else
    4332. 

  4332.     {
    4333. 

  4333.       {
    4334. 

  4334.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4335. 

  4335.              iX += pData->iColinc)
    4336. 

  4336.         {
    4337. 

  4337.           iFGa8 = *(pDataline+3);      /* get alpha values */
    4338. 

  4338.           iBGa8 = *(pScanline+3);
    4339. 

  4339. 

  4340.           if (iFGa8)                   /* any opacity at all ? */
    4341. 

  4341.           {                            /* fully opaque or background fully transparent ? */
    4342. 

  4342.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    4343. 

  4343.             {                          /* then simply copy the values */
    4344. 

  4344.               *pScanline     = *(pDataline+2);
    4345. 

  4345.               *(pScanline+1) = *(pDataline+1);
    4346. 

  4346.               *(pScanline+2) = *pDataline;
    4347. 

  4347.               *(pScanline+3) = *(pDataline+3);
    4348. 

  4348.             }
    4349. 

  4349.             else
    4350. 

  4350.             {
    4351. 

  4351.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    4352. 

  4352.               {                        /* do alpha composing */
    4353. 

  4353. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    4354. 

  4354.                 int i;
    4355. 

  4355.                 for (i=2; i >= 0; i--)
    4356. 

  4356.                 {
    4357. 

  4357.                 MNG_COMPOSE8 (*(pScanline+i), *(pDataline+2-i), iFGa8, *(pScanline+i));
    4358. 

  4358.                 }
    4359. 

  4359. #else
    4360. 

  4360.                 MNG_COMPOSE8 (*pScanline,     *(pDataline+2), iFGa8, *pScanline    );
    4361. 

  4361.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+1), iFGa8, *(pScanline+1));
    4362. 

  4362.                 MNG_COMPOSE8 (*(pScanline+2), *pDataline,     iFGa8, *(pScanline+2));
    4363. 

  4363. #endif
    4364. 

  4364.                                        /* alpha remains fully opaque !!! */
    4365. 

  4365.               }
    4366. 

  4366.               else
    4367. 

  4367.               {                        /* now blend */
    4368. 

  4368.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    4369. 

  4369.                             *(pScanline+2), *(pScanline+1), *pScanline,     iBGa8,
    4370. 

  4370.                             iCr8, iCg8, iCb8, iCa8);
    4371. 

  4371.                                        /* and return the composed values */
    4372. 

  4372.                 *pScanline     = iCb8;
    4373. 

  4373.                 *(pScanline+1) = iCg8;
    4374. 

  4374.                 *(pScanline+2) = iCr8;
    4375. 

  4375.                 *(pScanline+3) = iCa8;
    4376. 

  4376.               }
    4377. 

  4377.             }
    4378. 

  4378.           }
    4379. 

  4379. 

  4380.           pScanline += (pData->iColinc << 2);
    4381. 

  4381.           pDataline += 4;
    4382. 

  4382.         }
    4383. 

  4383.       }
    4384. 

  4384.     }
    4385. 

  4385.   }
    4386. 

  4386. 

  4387.   check_update_region (pData);
    4388. 

  4388. 

  4389. #ifdef MNG_SUPPORT_TRACE
    4390. 

  4390.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8, MNG_LC_END);
    4391. 

  4391. #endif
    4392. 

  4392. 

  4393.   return MNG_NOERROR;
    4394. 

  4394. }
    4395. 

  4395. #endif /* MNG_NO_16BIT_SUPPORT */
    4396. 

  4396. #endif /* MNG_SKIPCANVAS_BGRA8 */
    4397. 

  4397. 

  4398. /* ************************************************************************** */
    4399. 

  4399. 

  4400. #ifndef MNG_SKIPCANVAS_BGRA8_PM
    4401. 

  4401. #ifndef MNG_NO_16BIT_SUPPORT
    4402. 

  4402. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    4403. 

  4403. mng_retcode mng_display_bgra8_pm (mng_datap pData)
    4404. 

  4404. {
    4405. 

  4405.   mng_uint8p pScanline;
    4406. 

  4406.   mng_uint8p pDataline;
    4407. 

  4407.   mng_int32  iX;
    4408. 

  4408.   mng_uint32 s, t;
    4409. 

  4409. 

  4410. #ifdef MNG_SUPPORT_TRACE
    4411. 

  4411.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_START);
    4412. 

  4412. #endif
    4413. 

  4413.                                        /* viewable row ? */
    4414. 

  4414.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    4415. 

  4415.   {                                    /* address destination row */
    4416. 

  4416.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    4417. 

  4417.                                                    pData->iRow + pData->iDestt -
    4418. 

  4418.                                                    pData->iSourcet);
    4419. 

  4419.                                        /* adjust destination row starting-point */
    4420. 

  4420.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    4421. 

  4421.     pDataline = pData->pRGBArow;       /* address source row */
    4422. 

  4422. 

  4423.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    4424. 

  4424.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    4425. 

  4425.     else
    4426. 

  4426.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    4427. 

  4427. 

  4428.     if (pData->bIsOpaque)              /* forget about transparency ? */
    4429. 

  4429.     {
    4430. 

  4430.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4431. 

  4431.       {
    4432. 

  4432.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4433. 

  4433.              iX += pData->iColinc)
    4434. 

  4434.         {                              /* scale down by dropping the LSB */
    4435. 

  4435.           if ((s = pDataline[6]) == 0)
    4436. 

  4436.             *(mng_uint32*) pScanline = 0; /* set all components = 0 */
    4437. 

  4437.           else
    4438. 

  4438.           {
    4439. 

  4439.             if (s == 255)
    4440. 

  4440.             {
    4441. 

  4441.               pScanline[0] = pDataline[4];
    4442. 

  4442.               pScanline[1] = pDataline[2];
    4443. 

  4443.               pScanline[2] = pDataline[0];
    4444. 

  4444.               pScanline[3] = 255;
    4445. 

  4445.             }
    4446. 

  4446.             else
    4447. 

  4447.             {
    4448. 

  4448.               pScanline[0] = DIV255B8(s * pDataline[4]);
    4449. 

  4449.               pScanline[1] = DIV255B8(s * pDataline[2]);
    4450. 

  4450.               pScanline[2] = DIV255B8(s * pDataline[0]);
    4451. 

  4451.               pScanline[3] = (mng_uint8)s;
    4452. 

  4452.             }
    4453. 

  4453.           }
    4454. 

  4454.           pScanline += (pData->iColinc << 2);
    4455. 

  4455.           pDataline += 8;
    4456. 

  4456.         }
    4457. 

  4457.       }
    4458. 

  4458.       else
    4459. 

  4459.       {
    4460. 

  4460.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4461. 

  4461.              iX += pData->iColinc)
    4462. 

  4462.         {                              /* copy the values and premultiply */
    4463. 

  4463.           if ((s = pDataline[3]) == 0)
    4464. 

  4464.             *(mng_uint32*) pScanline = 0; /* set all components = 0 */
    4465. 

  4465.           else
    4466. 

  4466.           {
    4467. 

  4467.             if (s == 255)
    4468. 

  4468.             {
    4469. 

  4469.               pScanline[0] = pDataline[2];
    4470. 

  4470.               pScanline[1] = pDataline[1];
    4471. 

  4471.               pScanline[2] = pDataline[0];
    4472. 

  4472.               pScanline[3] = 255;
    4473. 

  4473.             }
    4474. 

  4474.             else
    4475. 

  4475.             {
    4476. 

  4476.               pScanline[0] = DIV255B8(s * pDataline[2]);
    4477. 

  4477.               pScanline[1] = DIV255B8(s * pDataline[1]);
    4478. 

  4478.               pScanline[2] = DIV255B8(s * pDataline[0]);
    4479. 

  4479.               pScanline[3] = (mng_uint8)s;
    4480. 

  4480.             }
    4481. 

  4481.           }
    4482. 

  4482. 

  4483.           pScanline += (pData->iColinc << 2);
    4484. 

  4484.           pDataline += 4;
    4485. 

  4485.         }
    4486. 

  4486.       }
    4487. 

  4487.     }
    4488. 

  4488.     else
    4489. 

  4489.     {
    4490. 

  4490.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4491. 

  4491.       {
    4492. 

  4492.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4493. 

  4493.              iX += pData->iColinc)
    4494. 

  4494.         {                              /* get alpha values */
    4495. 

  4495.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    4496. 

  4496.           {                            /* fully opaque or background fully transparent ? */
    4497. 

  4497.             if (s == 255)
    4498. 

  4498.             {                          /* plain copy it */
    4499. 

  4499.               pScanline[0] = pDataline[4];
    4500. 

  4500.               pScanline[1] = pDataline[2];
    4501. 

  4501.               pScanline[2] = pDataline[0];
    4502. 

  4502.               pScanline[3] = 255;
    4503. 

  4503.             }
    4504. 

  4504.             else
    4505. 

  4505.             {                          /* now blend (premultiplied) */
    4506. 

  4506.               t = 255 - s;
    4507. 

  4507. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4508. 

  4508.               {
    4509. 

  4509.                 int i;
    4510. 

  4510.                 for (i=2; i >= 0; i--)
    4511. 

  4511.                 {
    4512. 

  4512.                   pScanline[i] = DIV255B8(s * pDataline[4-i-i] + t *
    4513. 

  4513.                      pScanline[i]);
    4514. 

  4514.                 }
    4515. 

  4515.               }
    4516. 

  4516. #else
    4517. 

  4517.               pScanline[0] = DIV255B8(s * pDataline[4] + t * pScanline[0]);
    4518. 

  4518.               pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    4519. 

  4519.               pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
    4520. 

  4520. #endif
    4521. 

  4521.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    4522. 

  4522.             }
    4523. 

  4523.           }
    4524. 

  4524. 

  4525.           pScanline += (pData->iColinc << 2);
    4526. 

  4526.           pDataline += 8;
    4527. 

  4527.         }
    4528. 

  4528.       }
    4529. 

  4529.       else
    4530. 

  4530.       {
    4531. 

  4531.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4532. 

  4532.              iX += pData->iColinc)
    4533. 

  4533.         {
    4534. 

  4534.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    4535. 

  4535.           {                            /* fully opaque ? */
    4536. 

  4536.             if (s == 255)
    4537. 

  4537.             {                          /* then simply copy the values */
    4538. 

  4538.               pScanline[0] = pDataline[2];
    4539. 

  4539.               pScanline[1] = pDataline[1];
    4540. 

  4540.               pScanline[2] = pDataline[0];
    4541. 

  4541.               pScanline[3] = 255;
    4542. 

  4542.             }
    4543. 

  4543.             else
    4544. 

  4544.             {                          /* now blend (premultiplied) */
    4545. 

  4545.               t = 255 - s;
    4546. 

  4546. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4547. 

  4547.               {
    4548. 

  4548.                 int i;
    4549. 

  4549.                 for (i=2; i >= 0; i--)
    4550. 

  4550.                 {
    4551. 

  4551.                   pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
    4552. 

  4552.                      pScanline[i]);
    4553. 

  4553.                 }
    4554. 

  4554.               }
    4555. 

  4555. #else
    4556. 

  4556.               pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
    4557. 

  4557.               pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
    4558. 

  4558.               pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
    4559. 

  4559. #endif
    4560. 

  4560.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    4561. 

  4561.             }
    4562. 

  4562.           }
    4563. 

  4563. 

  4564.           pScanline += (pData->iColinc << 2);
    4565. 

  4565.           pDataline += 4;
    4566. 

  4566.         }
    4567. 

  4567.       }
    4568. 

  4568.     }
    4569. 

  4569.   }
    4570. 

  4570. 

  4571.   check_update_region (pData);
    4572. 

  4572. 

  4573. #ifdef MNG_SUPPORT_TRACE
    4574. 

  4574.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
    4575. 

  4575. #endif
    4576. 

  4576. 

  4577.   return MNG_NOERROR;
    4578. 

  4578. }
    4579. 

  4579. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    4580. 

  4580. mng_retcode mng_display_bgra8_pm (mng_datap pData)
    4581. 

  4581. {
    4582. 

  4582.   mng_uint8p pScanline;
    4583. 

  4583.   mng_uint8p pDataline;
    4584. 

  4584.   mng_int32  iX;
    4585. 

  4585.   mng_uint32 s, t;
    4586. 

  4586.   mng_uint8  iBps;
    4587. 

  4587. 

  4588. #ifdef MNG_SUPPORT_TRACE
    4589. 

  4589.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_START);
    4590. 

  4590. #endif
    4591. 

  4591. 

  4592.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    4593. 

  4593.                                        /* viewable row ? */
    4594. 

  4594.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    4595. 

  4595.   {                                    /* address destination row */
    4596. 

  4596.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    4597. 

  4597.                                                    pData->iRow + pData->iDestt -
    4598. 

  4598.                                                    pData->iSourcet);
    4599. 

  4599.                                        /* adjust destination row starting-point */
    4600. 

  4600.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    4601. 

  4601.     pDataline = pData->pRGBArow;       /* address source row */
    4602. 

  4602. 

  4603.     /* adjust source row starting-point */
    4604. 

  4604.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    4605. 

  4605. 

  4606.     if (pData->bIsOpaque)              /* forget about transparency ? */
    4607. 

  4607.     {
    4608. 

  4608.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4609. 

  4609.       {
    4610. 

  4610.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4611. 

  4611.              iX += pData->iColinc)
    4612. 

  4612.         {                              /* scale down by dropping the LSB */
    4613. 

  4613.           if ((s = pDataline[6]) == 0)
    4614. 

  4614.             *(mng_uint32*) pScanline = 0; /* set all components = 0 */
    4615. 

  4615.           else
    4616. 

  4616.           {
    4617. 

  4617.             if (s == 255)
    4618. 

  4618.             {
    4619. 

  4619.               pScanline[0] = pDataline[4];
    4620. 

  4620.               pScanline[1] = pDataline[2];
    4621. 

  4621.               pScanline[2] = pDataline[0];
    4622. 

  4622.               pScanline[3] = 255;
    4623. 

  4623.             }
    4624. 

  4624.             else
    4625. 

  4625.             {
    4626. 

  4626. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4627. 

  4627.               int i;
    4628. 

  4628.               for (i=2; i >= 0; i--)
    4629. 

  4629.               {
    4630. 

  4630.                 pScanline[i] = DIV255B8(s * pDataline[4-i-i]);
    4631. 

  4631.               }
    4632. 

  4632. #else
    4633. 

  4633.               pScanline[0] = DIV255B8(s * pDataline[4]);
    4634. 

  4634.               pScanline[1] = DIV255B8(s * pDataline[2]);
    4635. 

  4635.               pScanline[2] = DIV255B8(s * pDataline[0]);
    4636. 

  4636. #endif
    4637. 

  4637.               pScanline[3] = (mng_uint8)s;
    4638. 

  4638.             }
    4639. 

  4639.           }
    4640. 

  4640.           pScanline += (pData->iColinc << 2);
    4641. 

  4641.           pDataline += 8;
    4642. 

  4642.         }
    4643. 

  4643.       }
    4644. 

  4644.       else
    4645. 

  4645.       {
    4646. 

  4646.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4647. 

  4647.              iX += pData->iColinc)
    4648. 

  4648.         {                              /* copy the values and premultiply */
    4649. 

  4649.           if ((s = pDataline[3]) == 0)
    4650. 

  4650.             *(mng_uint32*) pScanline = 0; /* set all components = 0 */
    4651. 

  4651.           else
    4652. 

  4652.           {
    4653. 

  4653.             if (s == 255)
    4654. 

  4654.             {
    4655. 

  4655.               pScanline[0] = pDataline[2];
    4656. 

  4656.               pScanline[1] = pDataline[1];
    4657. 

  4657.               pScanline[2] = pDataline[0];
    4658. 

  4658.               pScanline[3] = 255;
    4659. 

  4659.             }
    4660. 

  4660.             else
    4661. 

  4661.             {
    4662. 

  4662. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4663. 

  4663.               int i;
    4664. 

  4664.               for (i=2; i >= 0; i--)
    4665. 

  4665.               {
    4666. 

  4666.                 pScanline[i] = DIV255B8(s * pDataline[2-i]);
    4667. 

  4667.               }
    4668. 

  4668. #else
    4669. 

  4669.               pScanline[0] = DIV255B8(s * pDataline[2]);
    4670. 

  4670.               pScanline[1] = DIV255B8(s * pDataline[1]);
    4671. 

  4671.               pScanline[2] = DIV255B8(s * pDataline[0]);
    4672. 

  4672. #endif
    4673. 

  4673.               pScanline[3] = (mng_uint8)s;
    4674. 

  4674.             }
    4675. 

  4675.           }
    4676. 

  4676. 

  4677.           pScanline += (pData->iColinc << 2);
    4678. 

  4678.           pDataline += 4;
    4679. 

  4679.         }
    4680. 

  4680.       }
    4681. 

  4681.     }
    4682. 

  4682.     else
    4683. 

  4683.     {
    4684. 

  4684.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4685. 

  4685.       {
    4686. 

  4686.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4687. 

  4687.              iX += pData->iColinc)
    4688. 

  4688.         {                              /* get alpha values */
    4689. 

  4689.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    4690. 

  4690.           {                            /* fully opaque or background fully transparent ? */
    4691. 

  4691.             if (s == 255)
    4692. 

  4692.             {                          /* plain copy it */
    4693. 

  4693.               pScanline[0] = pDataline[4];
    4694. 

  4694.               pScanline[1] = pDataline[2];
    4695. 

  4695.               pScanline[2] = pDataline[0];
    4696. 

  4696.               pScanline[3] = 255;
    4697. 

  4697.             }
    4698. 

  4698.             else
    4699. 

  4699.             {                          /* now blend (premultiplied) */
    4700. 

  4700.               t = 255 - s;
    4701. 

  4701. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4702. 

  4702.               {
    4703. 

  4703.                 int i;
    4704. 

  4704.                 for (i=2; i >= 0; i--)
    4705. 

  4705.                 {
    4706. 

  4706.                   pScanline[i] = DIV255B8(s * pDataline[4-i-i] + t *
    4707. 

  4707.                      pScanline[i]);
    4708. 

  4708.                 }
    4709. 

  4709.               }
    4710. 

  4710. #else
    4711. 

  4711.               pScanline[0] = DIV255B8(s * pDataline[4] + t * pScanline[0]);
    4712. 

  4712.               pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    4713. 

  4713.               pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
    4714. 

  4714. #endif
    4715. 

  4715.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    4716. 

  4716.             }
    4717. 

  4717.           }
    4718. 

  4718. 

  4719.           pScanline += (pData->iColinc << 2);
    4720. 

  4720.           pDataline += 8;
    4721. 

  4721.         }
    4722. 

  4722.       }
    4723. 

  4723.       else
    4724. 

  4724.       {
    4725. 

  4725.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4726. 

  4726.              iX += pData->iColinc)
    4727. 

  4727.         {
    4728. 

  4728.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    4729. 

  4729.           {                            /* fully opaque ? */
    4730. 

  4730.             if (s == 255)
    4731. 

  4731.             {                          /* then simply copy the values */
    4732. 

  4732.               pScanline[0] = pDataline[2];
    4733. 

  4733.               pScanline[1] = pDataline[1];
    4734. 

  4734.               pScanline[2] = pDataline[0];
    4735. 

  4735.               pScanline[3] = 255;
    4736. 

  4736.             }
    4737. 

  4737.             else
    4738. 

  4738.             {                          /* now blend (premultiplied) */
    4739. 

  4739.               t = 255 - s;
    4740. 

  4740. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4741. 

  4741.               {
    4742. 

  4742.                 int i;
    4743. 

  4743.                 for (i=2; i >= 0; i--)
    4744. 

  4744.                 {
    4745. 

  4745.                   pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
    4746. 

  4746.                      pScanline[i]);
    4747. 

  4747.                 }
    4748. 

  4748.               }
    4749. 

  4749. #else
    4750. 

  4750.               pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
    4751. 

  4751.               pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
    4752. 

  4752.               pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
    4753. 

  4753. #endif
    4754. 

  4754.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    4755. 

  4755.             }
    4756. 

  4756.           }
    4757. 

  4757. 

  4758.           pScanline += (pData->iColinc << 2);
    4759. 

  4759.           pDataline += 4;
    4760. 

  4760.         }
    4761. 

  4761.       }
    4762. 

  4762.     }
    4763. 

  4763.   }
    4764. 

  4764. 

  4765.   check_update_region (pData);
    4766. 

  4766. 

  4767. #ifdef MNG_SUPPORT_TRACE
    4768. 

  4768.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
    4769. 

  4769. #endif
    4770. 

  4770. 

  4771.   return MNG_NOERROR;
    4772. 

  4772. }
    4773. 

  4773. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    4774. 

  4774. #else /* MNG_NO_16BIT_SUPPORT */
    4775. 

  4775. mng_retcode mng_display_bgra8_pm (mng_datap pData)
    4776. 

  4776. {
    4777. 

  4777.   mng_uint8p pScanline;
    4778. 

  4778.   mng_uint8p pDataline;
    4779. 

  4779.   mng_int32  iX;
    4780. 

  4780.   mng_uint32 s, t;
    4781. 

  4781. 

  4782. #ifdef MNG_SUPPORT_TRACE
    4783. 

  4783.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_START);
    4784. 

  4784. #endif
    4785. 

  4785.                                        /* viewable row ? */
    4786. 

  4786.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    4787. 

  4787.   {                                    /* address destination row */
    4788. 

  4788.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    4789. 

  4789.                                                    pData->iRow + pData->iDestt -
    4790. 

  4790.                                                    pData->iSourcet);
    4791. 

  4791.                                        /* adjust destination row starting-point */
    4792. 

  4792.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    4793. 

  4793.     pDataline = pData->pRGBArow;       /* address source row */
    4794. 

  4794. 

  4795.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    4796. 

  4796. 

  4797.     if (pData->bIsOpaque)              /* forget about transparency ? */
    4798. 

  4798.     {
    4799. 

  4799.       {
    4800. 

  4800.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4801. 

  4801.              iX += pData->iColinc)
    4802. 

  4802.         {                              /* copy the values and premultiply */
    4803. 

  4803.           if ((s = pDataline[3]) == 0)
    4804. 

  4804.             *(mng_uint32*) pScanline = 0; /* set all components = 0 */
    4805. 

  4805.           else
    4806. 

  4806.           {
    4807. 

  4807.             if (s == 255)
    4808. 

  4808.             {
    4809. 

  4809.               pScanline[0] = pDataline[2];
    4810. 

  4810.               pScanline[1] = pDataline[1];
    4811. 

  4811.               pScanline[2] = pDataline[0];
    4812. 

  4812.               pScanline[3] = 255;
    4813. 

  4813.             }
    4814. 

  4814.             else
    4815. 

  4815.             {
    4816. 

  4816. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4817. 

  4817.               int i;
    4818. 

  4818.               for (i=2; i >= 0; i--)
    4819. 

  4819.               {
    4820. 

  4820.                 pScanline[i] = DIV255B8(s * pDataline[2-i]);
    4821. 

  4821.               }
    4822. 

  4822. #else
    4823. 

  4823.               pScanline[0] = DIV255B8(s * pDataline[2]);
    4824. 

  4824.               pScanline[1] = DIV255B8(s * pDataline[1]);
    4825. 

  4825.               pScanline[2] = DIV255B8(s * pDataline[0]);
    4826. 

  4826. #endif
    4827. 

  4827.               pScanline[3] = (mng_uint8)s;
    4828. 

  4828.             }
    4829. 

  4829.           }
    4830. 

  4830. 

  4831.           pScanline += (pData->iColinc << 2);
    4832. 

  4832.           pDataline += 4;
    4833. 

  4833.         }
    4834. 

  4834.       }
    4835. 

  4835.     }
    4836. 

  4836.     else
    4837. 

  4837.     {
    4838. 

  4838.       {
    4839. 

  4839.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4840. 

  4840.              iX += pData->iColinc)
    4841. 

  4841.         {
    4842. 

  4842.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    4843. 

  4843.           {                            /* fully opaque ? */
    4844. 

  4844.             if (s == 255)
    4845. 

  4845.             {                          /* then simply copy the values */
    4846. 

  4846.               pScanline[0] = pDataline[2];
    4847. 

  4847.               pScanline[1] = pDataline[1];
    4848. 

  4848.               pScanline[2] = pDataline[0];
    4849. 

  4849.               pScanline[3] = 255;
    4850. 

  4850.             }
    4851. 

  4851.             else
    4852. 

  4852.             {                          /* now blend (premultiplied) */
    4853. 

  4853.               t = 255 - s;
    4854. 

  4854. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    4855. 

  4855.               {
    4856. 

  4856.                 int i;
    4857. 

  4857.                 for (i=2; i >= 0; i--)
    4858. 

  4858.                 {
    4859. 

  4859.                   pScanline[i] = DIV255B8(s * pDataline[2-i] + t *
    4860. 

  4860.                      pScanline[i]);
    4861. 

  4861.                 }
    4862. 

  4862.               }
    4863. 

  4863. #else
    4864. 

  4864.               pScanline[0] = DIV255B8(s * pDataline[2] + t * pScanline[0]);
    4865. 

  4865.               pScanline[1] = DIV255B8(s * pDataline[1] + t * pScanline[1]);
    4866. 

  4866.               pScanline[2] = DIV255B8(s * pDataline[0] + t * pScanline[2]);
    4867. 

  4867. #endif
    4868. 

  4868.               pScanline[3] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[3])));
    4869. 

  4869.             }
    4870. 

  4870.           }
    4871. 

  4871. 

  4872.           pScanline += (pData->iColinc << 2);
    4873. 

  4873.           pDataline += 4;
    4874. 

  4874.         }
    4875. 

  4875.       }
    4876. 

  4876.     }
    4877. 

  4877.   }
    4878. 

  4878. 

  4879.   check_update_region (pData);
    4880. 

  4880. 

  4881. #ifdef MNG_SUPPORT_TRACE
    4882. 

  4882.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA8PM, MNG_LC_END);
    4883. 

  4883. #endif
    4884. 

  4884. 

  4885.   return MNG_NOERROR;
    4886. 

  4886. }
    4887. 

  4887. #endif /* MNG_NO_16BIT_SUPPORT */
    4888. 

  4888. #endif /* MNG_SKIPCANVAS_BGRA8_PM */
    4889. 

  4889. 

  4890. /* ************************************************************************** */
    4891. 

  4891. 

  4892. #ifndef MNG_SKIPCANVAS_ABGR8
    4893. 

  4893. #ifndef MNG_NO_16BIT_SUPPORT
    4894. 

  4894. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    4895. 

  4895. mng_retcode mng_display_abgr8 (mng_datap pData)
    4896. 

  4896. {
    4897. 

  4897.   mng_uint8p pScanline;
    4898. 

  4898.   mng_uint8p pDataline;
    4899. 

  4899.   mng_int32  iX;
    4900. 

  4900.   mng_uint8  iFGa8, iBGa8, iCa8;
    4901. 

  4901.   mng_uint16 iFGa16, iBGa16, iCa16;
    4902. 

  4902.   mng_uint16 iFGr16, iFGg16, iFGb16;
    4903. 

  4903.   mng_uint16 iBGr16, iBGg16, iBGb16;
    4904. 

  4904.   mng_uint16 iCr16, iCg16, iCb16;
    4905. 

  4905.   mng_uint8  iCr8, iCg8, iCb8;
    4906. 

  4906. 

  4907. #ifdef MNG_SUPPORT_TRACE
    4908. 

  4908.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_START);
    4909. 

  4909. #endif
    4910. 

  4910.                                        /* viewable row ? */
    4911. 

  4911.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    4912. 

  4912.   {                                    /* address destination row */
    4913. 

  4913.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    4914. 

  4914.                                                    pData->iRow + pData->iDestt -
    4915. 

  4915.                                                    pData->iSourcet);
    4916. 

  4916.                                        /* adjust destination row starting-point */
    4917. 

  4917.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    4918. 

  4918.     pDataline = pData->pRGBArow;       /* address source row */
    4919. 

  4919. 

  4920.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    4921. 

  4921.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    4922. 

  4922.     else
    4923. 

  4923.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    4924. 

  4924. 

  4925.     if (pData->bIsOpaque)              /* forget about transparency ? */
    4926. 

  4926.     {
    4927. 

  4927.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4928. 

  4928.       {
    4929. 

  4929.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4930. 

  4930.              iX += pData->iColinc)
    4931. 

  4931.         {                              /* scale down by dropping the LSB */
    4932. 

  4932.           *pScanline     = *(pDataline+6);
    4933. 

  4933.           *(pScanline+1) = *(pDataline+4);
    4934. 

  4934.           *(pScanline+2) = *(pDataline+2);
    4935. 

  4935.           *(pScanline+3) = *pDataline;
    4936. 

  4936. 

  4937.           pScanline += (pData->iColinc << 2);
    4938. 

  4938.           pDataline += 8;
    4939. 

  4939.         }
    4940. 

  4940.       }
    4941. 

  4941.       else
    4942. 

  4942.       {
    4943. 

  4943.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4944. 

  4944.              iX += pData->iColinc)
    4945. 

  4945.         {                              /* copy the values */
    4946. 

  4946.           *pScanline     = *(pDataline+3);
    4947. 

  4947.           *(pScanline+1) = *(pDataline+2);
    4948. 

  4948.           *(pScanline+2) = *(pDataline+1);
    4949. 

  4949.           *(pScanline+3) = *pDataline;
    4950. 

  4950. 

  4951.           pScanline += (pData->iColinc << 2);
    4952. 

  4952.           pDataline += 4;
    4953. 

  4953.         }
    4954. 

  4954.       }
    4955. 

  4955.     }
    4956. 

  4956.     else
    4957. 

  4957.     {
    4958. 

  4958.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    4959. 

  4959.       {
    4960. 

  4960.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    4961. 

  4961.              iX += pData->iColinc)
    4962. 

  4962.         {                              /* get alpha values */
    4963. 

  4963.           iFGa16 = mng_get_uint16 (pDataline+6);
    4964. 

  4964.           iBGa16 = (mng_uint16)(*pScanline);
    4965. 

  4965.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    4966. 

  4966. 

  4967.           if (iFGa16)                  /* any opacity at all ? */
    4968. 

  4968.           {                            /* fully opaque or background fully transparent ? */
    4969. 

  4969.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    4970. 

  4970.             {                          /* plain copy it */
    4971. 

  4971.               *pScanline     = *(pDataline+6);
    4972. 

  4972.               *(pScanline+1) = *(pDataline+4);
    4973. 

  4973.               *(pScanline+2) = *(pDataline+2);
    4974. 

  4974.               *(pScanline+3) = *pDataline;
    4975. 

  4975.             }
    4976. 

  4976.             else
    4977. 

  4977.             {
    4978. 

  4978.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    4979. 

  4979.               {                        /* get the proper values */
    4980. 

  4980.                 iFGr16 = mng_get_uint16 (pDataline  );
    4981. 

  4981.                 iFGg16 = mng_get_uint16 (pDataline+2);
    4982. 

  4982.                 iFGb16 = mng_get_uint16 (pDataline+4);
    4983. 

  4983.                                        /* scale background up */
    4984. 

  4984.                 iBGr16 = (mng_uint16)(*(pScanline+3));
    4985. 

  4985.                 iBGg16 = (mng_uint16)(*(pScanline+2));
    4986. 

  4986.                 iBGb16 = (mng_uint16)(*(pScanline+1));
    4987. 

  4987.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    4988. 

  4988.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    4989. 

  4989.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    4990. 

  4990.                                        /* now compose */
    4991. 

  4991.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    4992. 

  4992.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    4993. 

  4993.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    4994. 

  4994.                                        /* and return the composed values */
    4995. 

  4995.                                        /* alpha itself remains fully opaque !!! */
    4996. 

  4996.                 *(pScanline+1) = (mng_uint8)(iFGb16 >> 8);
    4997. 

  4997.                 *(pScanline+2) = (mng_uint8)(iFGg16 >> 8);
    4998. 

  4998.                 *(pScanline+3) = (mng_uint8)(iFGr16 >> 8);
    4999. 

  4999.               }
    5000. 

  5000.               else
    5001. 

  5001.               {                        /* scale background up */
    5002. 

  5002.                 iBGr16 = (mng_uint16)(*(pScanline+3));
    5003. 

  5003.                 iBGg16 = (mng_uint16)(*(pScanline+2));
    5004. 

  5004.                 iBGb16 = (mng_uint16)(*(pScanline+1));
    5005. 

  5005.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    5006. 

  5006.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    5007. 

  5007.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    5008. 

  5008.                                        /* let's blend */
    5009. 

  5009.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    5010. 

  5010.                              mng_get_uint16 (pDataline+2),
    5011. 

  5011.                              mng_get_uint16 (pDataline+4), iFGa16,
    5012. 

  5012.                              iBGr16, iBGg16, iBGb16, iBGa16,
    5013. 

  5013.                              iCr16,  iCg16,  iCb16,  iCa16);
    5014. 

  5014.                                        /* and return the composed values */
    5015. 

  5015.                 *pScanline     = (mng_uint8)(iCa16 >> 8);
    5016. 

  5016.                 *(pScanline+1) = (mng_uint8)(iCb16 >> 8);
    5017. 

  5017.                 *(pScanline+2) = (mng_uint8)(iCg16 >> 8);
    5018. 

  5018.                 *(pScanline+3) = (mng_uint8)(iCr16 >> 8);
    5019. 

  5019.               }
    5020. 

  5020.             }
    5021. 

  5021.           }
    5022. 

  5022. 

  5023.           pScanline += (pData->iColinc << 2);
    5024. 

  5024.           pDataline += 8;
    5025. 

  5025.         }
    5026. 

  5026.       }
    5027. 

  5027.       else
    5028. 

  5028.       {
    5029. 

  5029.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5030. 

  5030.              iX += pData->iColinc)
    5031. 

  5031.         {
    5032. 

  5032.           iFGa8 = *(pDataline+3);      /* get alpha values */
    5033. 

  5033.           iBGa8 = *pScanline;
    5034. 

  5034. 

  5035.           if (iFGa8)                   /* any opacity at all ? */
    5036. 

  5036.           {                            /* fully opaque or background fully transparent ? */
    5037. 

  5037.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    5038. 

  5038.             {                          /* then simply copy the values */
    5039. 

  5039.               *pScanline     = *(pDataline+3);
    5040. 

  5040.               *(pScanline+1) = *(pDataline+2);
    5041. 

  5041.               *(pScanline+2) = *(pDataline+1);
    5042. 

  5042.               *(pScanline+3) = *pDataline;
    5043. 

  5043.             }
    5044. 

  5044.             else
    5045. 

  5045.             {
    5046. 

  5046.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    5047. 

  5047.               {                        /* do simple alpha composing */
    5048. 

  5048.                                        /* alpha itself remains fully opaque !!! */
    5049. 

  5049.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+2), iFGa8, *(pScanline+1));
    5050. 

  5050.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+1), iFGa8, *(pScanline+2));
    5051. 

  5051.                 MNG_COMPOSE8 (*(pScanline+3), *pDataline,     iFGa8, *(pScanline+3));
    5052. 

  5052.               }
    5053. 

  5053.               else
    5054. 

  5054.               {                        /* now blend */
    5055. 

  5055.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    5056. 

  5056.                             *(pScanline+3), *(pScanline+2), *(pScanline+1), iBGa8,
    5057. 

  5057.                             iCr8, iCg8, iCb8, iCa8);
    5058. 

  5058.                                        /* and return the composed values */
    5059. 

  5059.                 *pScanline     = iCa8;
    5060. 

  5060.                 *(pScanline+1) = iCb8;
    5061. 

  5061.                 *(pScanline+2) = iCg8;
    5062. 

  5062.                 *(pScanline+3) = iCr8;
    5063. 

  5063.               }
    5064. 

  5064.             }
    5065. 

  5065.           }
    5066. 

  5066. 

  5067.           pScanline += (pData->iColinc << 2);
    5068. 

  5068.           pDataline += 4;
    5069. 

  5069.         }
    5070. 

  5070.       }
    5071. 

  5071.     }
    5072. 

  5072.   }
    5073. 

  5073. 

  5074.   check_update_region (pData);
    5075. 

  5075. 

  5076. #ifdef MNG_SUPPORT_TRACE
    5077. 

  5077.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_END);
    5078. 

  5078. #endif
    5079. 

  5079. 

  5080.   return MNG_NOERROR;
    5081. 

  5081. }
    5082. 

  5082. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    5083. 

  5083. mng_retcode mng_display_abgr8 (mng_datap pData)
    5084. 

  5084. {
    5085. 

  5085.   mng_uint8p pScanline;
    5086. 

  5086.   mng_uint8p pDataline;
    5087. 

  5087.   mng_int32  iX;
    5088. 

  5088.   mng_uint8  iFGa8, iBGa8, iCa8;
    5089. 

  5089.   mng_uint16 iFGa16, iBGa16, iCa16;
    5090. 

  5090.   mng_uint16 iFGg16;
    5091. 

  5091.   mng_uint16 iBGr16, iBGg16, iBGb16;
    5092. 

  5092.   mng_uint16 iCr16, iCg16, iCb16;
    5093. 

  5093.   mng_uint8  iCr8, iCg8, iCb8;
    5094. 

  5094.   mng_uint8  iBps;
    5095. 

  5095. 

  5096. #ifdef MNG_SUPPORT_TRACE
    5097. 

  5097.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_START);
    5098. 

  5098. #endif
    5099. 

  5099. 

  5100.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    5101. 

  5101.                                        /* viewable row ? */
    5102. 

  5102.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    5103. 

  5103.   {                                    /* address destination row */
    5104. 

  5104.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    5105. 

  5105.                                                    pData->iRow + pData->iDestt -
    5106. 

  5106.                                                    pData->iSourcet);
    5107. 

  5107.                                        /* adjust destination row starting-point */
    5108. 

  5108.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    5109. 

  5109.     pDataline = pData->pRGBArow;       /* address source row */
    5110. 

  5110. 

  5111.     /* adjust source row starting-point */
    5112. 

  5112.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    5113. 

  5113. 

  5114.     if (pData->bIsOpaque)              /* forget about transparency ? */
    5115. 

  5115.     {
    5116. 

  5116.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5117. 

  5117.              iX += pData->iColinc)
    5118. 

  5118.         {                              /* scale down by dropping the LSB */
    5119. 

  5119.           *pScanline     = *(pDataline+3*iBps);
    5120. 

  5120.           *(pScanline+1) = *(pDataline+2*iBps);
    5121. 

  5121.           *(pScanline+2) = *(pDataline+iBps);
    5122. 

  5122.           *(pScanline+3) = *pDataline;
    5123. 

  5123. 

  5124.           pScanline += (pData->iColinc << 2);
    5125. 

  5125.           pDataline += 4*iBps;
    5126. 

  5126.         }
    5127. 

  5127.     }
    5128. 

  5128.     else
    5129. 

  5129.     {
    5130. 

  5130.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5131. 

  5131.       {
    5132. 

  5132.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5133. 

  5133.              iX += pData->iColinc)
    5134. 

  5134.         {                              /* get alpha values */
    5135. 

  5135.           iFGa16 = mng_get_uint16 (pDataline+6);
    5136. 

  5136.           iBGa16 = (mng_uint16)(*pScanline);
    5137. 

  5137.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    5138. 

  5138. 

  5139.           if (iFGa16)                  /* any opacity at all ? */
    5140. 

  5140.           {                            /* fully opaque or background fully transparent ? */
    5141. 

  5141.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    5142. 

  5142.             {                          /* plain copy it */
    5143. 

  5143.               *pScanline     = *(pDataline+6);
    5144. 

  5144.               *(pScanline+1) = *(pDataline+4);
    5145. 

  5145.               *(pScanline+2) = *(pDataline+2);
    5146. 

  5146.               *(pScanline+3) = *pDataline;
    5147. 

  5147.             }
    5148. 

  5148.             else
    5149. 

  5149.             {
    5150. 

  5150.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    5151. 

  5151.               {                        /* get the proper values */
    5152. 

  5152.               int i;
    5153. 

  5153.               for (i=2; i >= 0; i--)
    5154. 

  5154.               {
    5155. 

  5155.                 iFGg16 = mng_get_uint16 (pDataline+i+i);
    5156. 

  5156.                                        /* scale background up */
    5157. 

  5157.                 iBGg16 = (mng_uint16)(*(pScanline+3-i));
    5158. 

  5158.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    5159. 

  5159.                                        /* now compose */
    5160. 

  5160.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    5161. 

  5161.                                        /* and return the composed values */
    5162. 

  5162.                                        /* alpha itself remains fully opaque !!! */
    5163. 

  5163.                 *(pScanline+3-i) = (mng_uint8)(iFGg16 >> 8);
    5164. 

  5164.               }
    5165. 

  5165.               }
    5166. 

  5166.               else
    5167. 

  5167.               {                        /* scale background up */
    5168. 

  5168.                 iBGr16 = (mng_uint16)(*(pScanline+3));
    5169. 

  5169.                 iBGg16 = (mng_uint16)(*(pScanline+2));
    5170. 

  5170.                 iBGb16 = (mng_uint16)(*(pScanline+1));
    5171. 

  5171.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    5172. 

  5172.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    5173. 

  5173.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    5174. 

  5174.                                        /* let's blend */
    5175. 

  5175.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    5176. 

  5176.                              mng_get_uint16 (pDataline+2),
    5177. 

  5177.                              mng_get_uint16 (pDataline+4), iFGa16,
    5178. 

  5178.                              iBGr16, iBGg16, iBGb16, iBGa16,
    5179. 

  5179.                              iCr16,  iCg16,  iCb16,  iCa16);
    5180. 

  5180.                                        /* and return the composed values */
    5181. 

  5181.                 *pScanline     = (mng_uint8)(iCa16 >> 8);
    5182. 

  5182.                 *(pScanline+1) = (mng_uint8)(iCb16 >> 8);
    5183. 

  5183.                 *(pScanline+2) = (mng_uint8)(iCg16 >> 8);
    5184. 

  5184.                 *(pScanline+3) = (mng_uint8)(iCr16 >> 8);
    5185. 

  5185.               }
    5186. 

  5186.             }
    5187. 

  5187.           }
    5188. 

  5188. 

  5189.           pScanline += (pData->iColinc << 2);
    5190. 

  5190.           pDataline += 8;
    5191. 

  5191.         }
    5192. 

  5192.       }
    5193. 

  5193.       else
    5194. 

  5194.       {
    5195. 

  5195.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5196. 

  5196.              iX += pData->iColinc)
    5197. 

  5197.         {
    5198. 

  5198.           iFGa8 = *(pDataline+3);      /* get alpha values */
    5199. 

  5199.           iBGa8 = *pScanline;
    5200. 

  5200. 

  5201.           if (iFGa8)                   /* any opacity at all ? */
    5202. 

  5202.           {                            /* fully opaque or background fully transparent ? */
    5203. 

  5203.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    5204. 

  5204.             {                          /* then simply copy the values */
    5205. 

  5205.               *pScanline     = *(pDataline+3);
    5206. 

  5206.               *(pScanline+1) = *(pDataline+2);
    5207. 

  5207.               *(pScanline+2) = *(pDataline+1);
    5208. 

  5208.               *(pScanline+3) = *pDataline;
    5209. 

  5209.             }
    5210. 

  5210.             else
    5211. 

  5211.             {
    5212. 

  5212.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    5213. 

  5213.               {                        /* do simple alpha composing */
    5214. 

  5214.                                        /* alpha itself remains fully opaque !!! */
    5215. 

  5215.                 int i;
    5216. 

  5216.                 for (i=2; i >= 0; i--)
    5217. 

  5217.                 {
    5218. 

  5218.                 MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+2-i), iFGa8, *(pScanline+i+1));
    5219. 

  5219.                 }
    5220. 

  5220.               }
    5221. 

  5221.               else
    5222. 

  5222.               {                        /* now blend */
    5223. 

  5223.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    5224. 

  5224.                             *(pScanline+3), *(pScanline+2), *(pScanline+1), iBGa8,
    5225. 

  5225.                             iCr8, iCg8, iCb8, iCa8);
    5226. 

  5226.                                        /* and return the composed values */
    5227. 

  5227.                 *pScanline     = iCa8;
    5228. 

  5228.                 *(pScanline+1) = iCb8;
    5229. 

  5229.                 *(pScanline+2) = iCg8;
    5230. 

  5230.                 *(pScanline+3) = iCr8;
    5231. 

  5231.               }
    5232. 

  5232.             }
    5233. 

  5233.           }
    5234. 

  5234. 

  5235.           pScanline += (pData->iColinc << 2);
    5236. 

  5236.           pDataline += 4;
    5237. 

  5237.         }
    5238. 

  5238.       }
    5239. 

  5239.     }
    5240. 

  5240.   }
    5241. 

  5241. 

  5242.   check_update_region (pData);
    5243. 

  5243. 

  5244. #ifdef MNG_SUPPORT_TRACE
    5245. 

  5245.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_END);
    5246. 

  5246. #endif
    5247. 

  5247. 

  5248.   return MNG_NOERROR;
    5249. 

  5249. }
    5250. 

  5250. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    5251. 

  5251. #else /* MNG_NO_16BIT_SUPPORT */
    5252. 

  5252. mng_retcode mng_display_abgr8 (mng_datap pData)
    5253. 

  5253. {
    5254. 

  5254.   mng_uint8p pScanline;
    5255. 

  5255.   mng_uint8p pDataline;
    5256. 

  5256.   mng_int32  iX;
    5257. 

  5257.   mng_uint8  iFGa8, iBGa8, iCa8;
    5258. 

  5258.   mng_uint8  iCr8, iCg8, iCb8;
    5259. 

  5259. 

  5260. #ifdef MNG_SUPPORT_TRACE
    5261. 

  5261.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_START);
    5262. 

  5262. #endif
    5263. 

  5263.                                        /* viewable row ? */
    5264. 

  5264.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    5265. 

  5265.   {                                    /* address destination row */
    5266. 

  5266.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    5267. 

  5267.                                                    pData->iRow + pData->iDestt -
    5268. 

  5268.                                                    pData->iSourcet);
    5269. 

  5269.                                        /* adjust destination row starting-point */
    5270. 

  5270.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    5271. 

  5271.     pDataline = pData->pRGBArow;       /* address source row */
    5272. 

  5272. 

  5273.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    5274. 

  5274. 

  5275.     if (pData->bIsOpaque)              /* forget about transparency ? */
    5276. 

  5276.     {
    5277. 

  5277.       {
    5278. 

  5278.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5279. 

  5279.              iX += pData->iColinc)
    5280. 

  5280.         {                              /* copy the values */
    5281. 

  5281.           *pScanline     = *(pDataline+3);
    5282. 

  5282.           *(pScanline+1) = *(pDataline+2);
    5283. 

  5283.           *(pScanline+2) = *(pDataline+1);
    5284. 

  5284.           *(pScanline+3) = *pDataline;
    5285. 

  5285. 

  5286.           pScanline += (pData->iColinc << 2);
    5287. 

  5287.           pDataline += 4;
    5288. 

  5288.         }
    5289. 

  5289.       }
    5290. 

  5290.     }
    5291. 

  5291.     else
    5292. 

  5292.     {
    5293. 

  5293.       {
    5294. 

  5294.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5295. 

  5295.              iX += pData->iColinc)
    5296. 

  5296.         {
    5297. 

  5297.           iFGa8 = *(pDataline+3);      /* get alpha values */
    5298. 

  5298.           iBGa8 = *pScanline;
    5299. 

  5299. 

  5300.           if (iFGa8)                   /* any opacity at all ? */
    5301. 

  5301.           {                            /* fully opaque or background fully transparent ? */
    5302. 

  5302.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    5303. 

  5303.             {                          /* then simply copy the values */
    5304. 

  5304.               *pScanline     = *(pDataline+3);
    5305. 

  5305.               *(pScanline+1) = *(pDataline+2);
    5306. 

  5306.               *(pScanline+2) = *(pDataline+1);
    5307. 

  5307.               *(pScanline+3) = *pDataline;
    5308. 

  5308.             }
    5309. 

  5309.             else
    5310. 

  5310.             {
    5311. 

  5311.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    5312. 

  5312.               {                        /* do simple alpha composing */
    5313. 

  5313.                                        /* alpha itself remains fully opaque !!! */
    5314. 

  5314. #ifdef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    5315. 

  5315.                 int i;
    5316. 

  5316.                 for (i=2; i >= 0; i--)
    5317. 

  5317.                 {
    5318. 

  5318.                 MNG_COMPOSE8 (*(pScanline+i+1), *(pDataline+2-i), iFGa8, *(pScanline+i+1));
    5319. 

  5319.                 }
    5320. 

  5320. #else
    5321. 

  5321.                 MNG_COMPOSE8 (*(pScanline+1), *(pDataline+2), iFGa8, *(pScanline+1));
    5322. 

  5322.                 MNG_COMPOSE8 (*(pScanline+2), *(pDataline+1), iFGa8, *(pScanline+2));
    5323. 

  5323.                 MNG_COMPOSE8 (*(pScanline+3), *pDataline,     iFGa8, *(pScanline+3));
    5324. 

  5324. #endif
    5325. 

  5325.               }
    5326. 

  5326.               else
    5327. 

  5327.               {                        /* now blend */
    5328. 

  5328.                 MNG_BLEND8 (*pDataline,     *(pDataline+1), *(pDataline+2), iFGa8,
    5329. 

  5329.                             *(pScanline+3), *(pScanline+2), *(pScanline+1), iBGa8,
    5330. 

  5330.                             iCr8, iCg8, iCb8, iCa8);
    5331. 

  5331.                                        /* and return the composed values */
    5332. 

  5332.                 *pScanline     = iCa8;
    5333. 

  5333.                 *(pScanline+1) = iCb8;
    5334. 

  5334.                 *(pScanline+2) = iCg8;
    5335. 

  5335.                 *(pScanline+3) = iCr8;
    5336. 

  5336.               }
    5337. 

  5337.             }
    5338. 

  5338.           }
    5339. 

  5339. 

  5340.           pScanline += (pData->iColinc << 2);
    5341. 

  5341.           pDataline += 4;
    5342. 

  5342.         }
    5343. 

  5343.       }
    5344. 

  5344.     }
    5345. 

  5345.   }
    5346. 

  5346. 

  5347.   check_update_region (pData);
    5348. 

  5348. 

  5349. #ifdef MNG_SUPPORT_TRACE
    5350. 

  5350.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8, MNG_LC_END);
    5351. 

  5351. #endif
    5352. 

  5352. 

  5353.   return MNG_NOERROR;
    5354. 

  5354. }
    5355. 

  5355. #endif /* MNG_NO_16BIT_SUPPORT */
    5356. 

  5356. #endif /* MNG_SKIPCANVAS_ABGR8 */
    5357. 

  5357. 

  5358. /* ************************************************************************** */
    5359. 

  5359. 

  5360. #ifndef MNG_SKIPCANVAS_ABGR8_PM
    5361. 

  5361. #ifndef MNG_NO_16BIT_SUPPORT
    5362. 

  5362. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    5363. 

  5363. mng_retcode mng_display_abgr8_pm (mng_datap pData)
    5364. 

  5364. {
    5365. 

  5365.   mng_uint8p pScanline;
    5366. 

  5366.   mng_uint8p pDataline;
    5367. 

  5367.   mng_int32  iX;
    5368. 

  5368.   mng_uint32 s, t;
    5369. 

  5369. 

  5370. #ifdef MNG_SUPPORT_TRACE
    5371. 

  5371.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
    5372. 

  5372. #endif
    5373. 

  5373.                                        /* viewable row ? */
    5374. 

  5374.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    5375. 

  5375.   {                                    /* address destination row */
    5376. 

  5376.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    5377. 

  5377.                                                    pData->iRow + pData->iDestt -
    5378. 

  5378.                                                    pData->iSourcet);
    5379. 

  5379.                                        /* adjust destination row starting-point */
    5380. 

  5380.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    5381. 

  5381.     pDataline = pData->pRGBArow;       /* address source row */
    5382. 

  5382. 

  5383.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    5384. 

  5384.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    5385. 

  5385.     else
    5386. 

  5386.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    5387. 

  5387. 

  5388.     if (pData->bIsOpaque)              /* forget about transparency ? */
    5389. 

  5389.     {
    5390. 

  5390.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5391. 

  5391.       {
    5392. 

  5392.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5393. 

  5393.              iX += pData->iColinc)
    5394. 

  5394.         {                              /* scale down by dropping the LSB */
    5395. 

  5395. 		  if ((s = pDataline[6]) == 0)
    5396. 

  5396. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    5397. 

  5397. 		  else
    5398. 

  5398. 		  {
    5399. 

  5399. 			if (s == 255)
    5400. 

  5400. 			{
    5401. 

  5401.               pScanline[0] = 255;
    5402. 

  5402. 		      pScanline[1] = pDataline[4];
    5403. 

  5403.               pScanline[2] = pDataline[2];
    5404. 

  5404.               pScanline[3] = pDataline[0];
    5405. 

  5405. 			}
    5406. 

  5406. 			else
    5407. 

  5407. 			{
    5408. 

  5408.               pScanline[0] = (mng_uint8)s;
    5409. 

  5409. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5410. 

  5410.               {
    5411. 

  5411.                 int i;
    5412. 

  5412.                 for (i=2; i >= 0; i--)
    5413. 

  5413.                 {
    5414. 

  5414.                   pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
    5415. 

  5415.                 }
    5416. 

  5416.               }
    5417. 

  5417. #else
    5418. 

  5418.               pScanline[1] = DIV255B8(s * pDataline[4]);
    5419. 

  5419.               pScanline[2] = DIV255B8(s * pDataline[2]);
    5420. 

  5420.               pScanline[3] = DIV255B8(s * pDataline[0]);
    5421. 

  5421. #endif
    5422. 

  5422. 			}
    5423. 

  5423. 		  }
    5424. 

  5424.           pScanline += (pData->iColinc << 2);
    5425. 

  5425.           pDataline += 8;
    5426. 

  5426.         }
    5427. 

  5427.       }
    5428. 

  5428.       else
    5429. 

  5429.       {
    5430. 

  5430.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5431. 

  5431.              iX += pData->iColinc)
    5432. 

  5432.         {                              /* copy the values and premultiply */
    5433. 

  5433. 		  if ((s = pDataline[3]) == 0)
    5434. 

  5434. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    5435. 

  5435. 		  else
    5436. 

  5436. 		  {
    5437. 

  5437. 			if (s == 255)
    5438. 

  5438. 			{
    5439. 

  5439.               pScanline[0] = 255;
    5440. 

  5440. 		      pScanline[1] = pDataline[2];
    5441. 

  5441.               pScanline[2] = pDataline[1];
    5442. 

  5442.               pScanline[3] = pDataline[0];
    5443. 

  5443. 			}
    5444. 

  5444. 			else
    5445. 

  5445. 			{
    5446. 

  5446.               pScanline[0] = (mng_uint8)s;
    5447. 

  5447. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5448. 

  5448.               {
    5449. 

  5449.                 int i;
    5450. 

  5450.                 for (i=2; i >= 0; i--)
    5451. 

  5451.                 {
    5452. 

  5452.                   pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
    5453. 

  5453.                 }
    5454. 

  5454.               }
    5455. 

  5455. #else
    5456. 

  5456.               pScanline[1] = DIV255B8(s * pDataline[2]);
    5457. 

  5457.               pScanline[2] = DIV255B8(s * pDataline[1]);
    5458. 

  5458. 		      pScanline[3] = DIV255B8(s * pDataline[0]);
    5459. 

  5459. #endif
    5460. 

  5460. 			}
    5461. 

  5461. 		  }
    5462. 

  5462. 

  5463.           pScanline += (pData->iColinc << 2);
    5464. 

  5464.           pDataline += 4;
    5465. 

  5465.         }
    5466. 

  5466.       }
    5467. 

  5467.     }
    5468. 

  5468.     else
    5469. 

  5469.     {
    5470. 

  5470.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5471. 

  5471.       {
    5472. 

  5472.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5473. 

  5473.              iX += pData->iColinc)
    5474. 

  5474.         {                              /* get alpha values */
    5475. 

  5475.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    5476. 

  5476.           {                            /* fully opaque or background fully transparent ? */
    5477. 

  5477.             if (s == 255)
    5478. 

  5478.             {                          /* plain copy it */
    5479. 

  5479.               pScanline[0] = 255;
    5480. 

  5480.               pScanline[1] = pDataline[4];
    5481. 

  5481.               pScanline[2] = pDataline[2];
    5482. 

  5482.               pScanline[3] = pDataline[0];
    5483. 

  5483.             }
    5484. 

  5484.             else
    5485. 

  5485.             {                          /* now blend (premultiplied) */
    5486. 

  5486. 			  t = 255 - s;
    5487. 

  5487.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    5488. 

  5488. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5489. 

  5489.               {
    5490. 

  5490.                 int i;
    5491. 

  5491.                 for (i=2; i >= 0; i--)
    5492. 

  5492.                 {
    5493. 

  5493.                   pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
    5494. 

  5494.                      pScanline[i+1]);
    5495. 

  5495.                 }
    5496. 

  5496.               }
    5497. 

  5497. #else
    5498. 

  5498. 			  pScanline[1] = DIV255B8(s * pDataline[4] + t * pScanline[1]);
    5499. 

  5499.               pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    5500. 

  5500.               pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
    5501. 

  5501. #endif
    5502. 

  5502.             }
    5503. 

  5503.           }
    5504. 

  5504. 

  5505.           pScanline += (pData->iColinc << 2);
    5506. 

  5506.           pDataline += 8;
    5507. 

  5507.         }
    5508. 

  5508.       }
    5509. 

  5509.       else
    5510. 

  5510.       {
    5511. 

  5511.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5512. 

  5512.              iX += pData->iColinc)
    5513. 

  5513.         {
    5514. 

  5514.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    5515. 

  5515.           {                            /* fully opaque ? */
    5516. 

  5516.             if (s == 255)
    5517. 

  5517.             {                          /* then simply copy the values */
    5518. 

  5518.               pScanline[0] = 255;
    5519. 

  5519.               pScanline[1] = pDataline[2];
    5520. 

  5520.               pScanline[2] = pDataline[1];
    5521. 

  5521.               pScanline[3] = pDataline[0];
    5522. 

  5522.             }
    5523. 

  5523.             else
    5524. 

  5524.             {                          /* now blend (premultiplied) */
    5525. 

  5525. 			  t = 255 - s;
    5526. 

  5526.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    5527. 

  5527. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5528. 

  5528.               {
    5529. 

  5529.                 int i;
    5530. 

  5530.                 for (i=2; i >= 0; i--)
    5531. 

  5531.                 {
    5532. 

  5532.                   pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
    5533. 

  5533.                      pScanline[i+1]);
    5534. 

  5534.                 }
    5535. 

  5535.               }
    5536. 

  5536. #else
    5537. 

  5537. 			  pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    5538. 

  5538.               pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
    5539. 

  5539.               pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
    5540. 

  5540. #endif
    5541. 

  5541.             }
    5542. 

  5542.           }
    5543. 

  5543. 

  5544.           pScanline += (pData->iColinc << 2);
    5545. 

  5545.           pDataline += 4;
    5546. 

  5546.         }
    5547. 

  5547.       }
    5548. 

  5548.     }
    5549. 

  5549.   }
    5550. 

  5550. 

  5551.   check_update_region (pData);
    5552. 

  5552. 

  5553. #ifdef MNG_SUPPORT_TRACE
    5554. 

  5554.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
    5555. 

  5555. #endif
    5556. 

  5556. 

  5557.   return MNG_NOERROR;
    5558. 

  5558. }
    5559. 

  5559. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    5560. 

  5560. mng_retcode mng_display_abgr8_pm (mng_datap pData)
    5561. 

  5561. {
    5562. 

  5562.   mng_uint8p pScanline;
    5563. 

  5563.   mng_uint8p pDataline;
    5564. 

  5564.   mng_int32  iX;
    5565. 

  5565.   mng_uint32 s, t;
    5566. 

  5566.   mng_uint8  iBps;
    5567. 

  5567. 

  5568. #ifdef MNG_SUPPORT_TRACE
    5569. 

  5569.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
    5570. 

  5570. #endif
    5571. 

  5571. 

  5572.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    5573. 

  5573.                                        /* viewable row ? */
    5574. 

  5574.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    5575. 

  5575.   {                                    /* address destination row */
    5576. 

  5576.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    5577. 

  5577.                                                    pData->iRow + pData->iDestt -
    5578. 

  5578.                                                    pData->iSourcet);
    5579. 

  5579.                                        /* adjust destination row starting-point */
    5580. 

  5580.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    5581. 

  5581.     pDataline = pData->pRGBArow;       /* address source row */
    5582. 

  5582. 

  5583.     /* adjust source row starting-point */
    5584. 

  5584.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    5585. 

  5585. 

  5586.     if (pData->bIsOpaque)              /* forget about transparency ? */
    5587. 

  5587.     {
    5588. 

  5588.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5589. 

  5589.       {
    5590. 

  5590.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5591. 

  5591.              iX += pData->iColinc)
    5592. 

  5592.         {                              /* scale down by dropping the LSB */
    5593. 

  5593. 		  if ((s = pDataline[6]) == 0)
    5594. 

  5594. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    5595. 

  5595. 		  else
    5596. 

  5596. 		  {
    5597. 

  5597. 			if (s == 255)
    5598. 

  5598. 			{
    5599. 

  5599.               pScanline[0] = 255;
    5600. 

  5600. 		      pScanline[1] = pDataline[4];
    5601. 

  5601.               pScanline[2] = pDataline[2];
    5602. 

  5602.               pScanline[3] = pDataline[0];
    5603. 

  5603. 			}
    5604. 

  5604. 			else
    5605. 

  5605. 			{
    5606. 

  5606.               pScanline[0] = (mng_uint8)s;
    5607. 

  5607. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5608. 

  5608.               {
    5609. 

  5609.                 int i;
    5610. 

  5610.                 for (i=2; i >= 0; i--)
    5611. 

  5611.                 {
    5612. 

  5612.                   pScanline[i+1] = DIV255B8(s * pDataline[4-i-i]);
    5613. 

  5613.                 }
    5614. 

  5614.               }
    5615. 

  5615. #else
    5616. 

  5616.               pScanline[1] = DIV255B8(s * pDataline[4]);
    5617. 

  5617.               pScanline[2] = DIV255B8(s * pDataline[2]);
    5618. 

  5618.               pScanline[3] = DIV255B8(s * pDataline[0]);
    5619. 

  5619. #endif
    5620. 

  5620. 			}
    5621. 

  5621. 		  }
    5622. 

  5622.           pScanline += (pData->iColinc << 2);
    5623. 

  5623.           pDataline += 8;
    5624. 

  5624.         }
    5625. 

  5625.       }
    5626. 

  5626.       else
    5627. 

  5627.       {
    5628. 

  5628.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5629. 

  5629.              iX += pData->iColinc)
    5630. 

  5630.         {                              /* copy the values and premultiply */
    5631. 

  5631. 		  if ((s = pDataline[3]) == 0)
    5632. 

  5632. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    5633. 

  5633. 		  else
    5634. 

  5634. 		  {
    5635. 

  5635. 			if (s == 255)
    5636. 

  5636. 			{
    5637. 

  5637.               pScanline[0] = 255;
    5638. 

  5638. 		      pScanline[1] = pDataline[2];
    5639. 

  5639.               pScanline[2] = pDataline[1];
    5640. 

  5640.               pScanline[3] = pDataline[0];
    5641. 

  5641. 			}
    5642. 

  5642. 			else
    5643. 

  5643. 			{
    5644. 

  5644.               pScanline[0] = (mng_uint8)s;
    5645. 

  5645. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5646. 

  5646.               {
    5647. 

  5647.                 int i;
    5648. 

  5648.                 for (i=2; i >= 0; i--)
    5649. 

  5649.                 {
    5650. 

  5650.                   pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
    5651. 

  5651.                 }
    5652. 

  5652.               }
    5653. 

  5653. #else
    5654. 

  5654.               pScanline[1] = DIV255B8(s * pDataline[2]);
    5655. 

  5655.               pScanline[2] = DIV255B8(s * pDataline[1]);
    5656. 

  5656. 		      pScanline[3] = DIV255B8(s * pDataline[0]);
    5657. 

  5657. #endif
    5658. 

  5658. 			}
    5659. 

  5659. 		  }
    5660. 

  5660. 

  5661.           pScanline += (pData->iColinc << 2);
    5662. 

  5662.           pDataline += 4;
    5663. 

  5663.         }
    5664. 

  5664.       }
    5665. 

  5665.     }
    5666. 

  5666.     else
    5667. 

  5667.     {
    5668. 

  5668.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5669. 

  5669.       {
    5670. 

  5670.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5671. 

  5671.              iX += pData->iColinc)
    5672. 

  5672.         {                              /* get alpha values */
    5673. 

  5673.           if ((s = pDataline[6]) != 0)       /* any opacity at all ? */
    5674. 

  5674.           {                            /* fully opaque or background fully transparent ? */
    5675. 

  5675.             if (s == 255)
    5676. 

  5676.             {                          /* plain copy it */
    5677. 

  5677.               pScanline[0] = 255;
    5678. 

  5678.               pScanline[1] = pDataline[4];
    5679. 

  5679.               pScanline[2] = pDataline[2];
    5680. 

  5680.               pScanline[3] = pDataline[0];
    5681. 

  5681.             }
    5682. 

  5682.             else
    5683. 

  5683.             {                          /* now blend (premultiplied) */
    5684. 

  5684. 			  t = 255 - s;
    5685. 

  5685.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    5686. 

  5686. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5687. 

  5687.               {
    5688. 

  5688.                 int i;
    5689. 

  5689.                 for (i=2; i >= 0; i--)
    5690. 

  5690.                 {
    5691. 

  5691.                   pScanline[i+1] = DIV255B8(s * pDataline[4-i-i] + t *
    5692. 

  5692.                      pScanline[i+1]);
    5693. 

  5693.                 }
    5694. 

  5694.               }
    5695. 

  5695. #else
    5696. 

  5696. 			  pScanline[1] = DIV255B8(s * pDataline[4] + t * pScanline[1]);
    5697. 

  5697.               pScanline[2] = DIV255B8(s * pDataline[2] + t * pScanline[2]);
    5698. 

  5698.               pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
    5699. 

  5699. #endif
    5700. 

  5700.             }
    5701. 

  5701.           }
    5702. 

  5702. 

  5703.           pScanline += (pData->iColinc << 2);
    5704. 

  5704.           pDataline += 8;
    5705. 

  5705.         }
    5706. 

  5706.       }
    5707. 

  5707.       else
    5708. 

  5708.       {
    5709. 

  5709.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5710. 

  5710.              iX += pData->iColinc)
    5711. 

  5711.         {
    5712. 

  5712.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    5713. 

  5713.           {                            /* fully opaque ? */
    5714. 

  5714.             if (s == 255)
    5715. 

  5715.             {                          /* then simply copy the values */
    5716. 

  5716.               pScanline[0] = 255;
    5717. 

  5717.               pScanline[1] = pDataline[2];
    5718. 

  5718.               pScanline[2] = pDataline[1];
    5719. 

  5719.               pScanline[3] = pDataline[0];
    5720. 

  5720.             }
    5721. 

  5721.             else
    5722. 

  5722.             {                          /* now blend (premultiplied) */
    5723. 

  5723. 			  t = 255 - s;
    5724. 

  5724.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    5725. 

  5725. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5726. 

  5726.               {
    5727. 

  5727.                 int i;
    5728. 

  5728.                 for (i=2; i >= 0; i--)
    5729. 

  5729.                 {
    5730. 

  5730.                   pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
    5731. 

  5731.                      pScanline[i+1]);
    5732. 

  5732.                 }
    5733. 

  5733.               }
    5734. 

  5734. #else
    5735. 

  5735. 			  pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    5736. 

  5736.               pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
    5737. 

  5737.               pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
    5738. 

  5738. #endif
    5739. 

  5739.             }
    5740. 

  5740.           }
    5741. 

  5741. 

  5742.           pScanline += (pData->iColinc << 2);
    5743. 

  5743.           pDataline += 4;
    5744. 

  5744.         }
    5745. 

  5745.       }
    5746. 

  5746.     }
    5747. 

  5747.   }
    5748. 

  5748. 

  5749.   check_update_region (pData);
    5750. 

  5750. 

  5751. #ifdef MNG_SUPPORT_TRACE
    5752. 

  5752.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
    5753. 

  5753. #endif
    5754. 

  5754. 

  5755.   return MNG_NOERROR;
    5756. 

  5756. }
    5757. 

  5757. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    5758. 

  5758. #else /* MNG_NO_16BIT_SUPPORT */
    5759. 

  5759. mng_retcode mng_display_abgr8_pm (mng_datap pData)
    5760. 

  5760. {
    5761. 

  5761.   mng_uint8p pScanline;
    5762. 

  5762.   mng_uint8p pDataline;
    5763. 

  5763.   mng_int32  iX;
    5764. 

  5764.   mng_uint32 s, t;
    5765. 

  5765. 

  5766. #ifdef MNG_SUPPORT_TRACE
    5767. 

  5767.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_START);
    5768. 

  5768. #endif
    5769. 

  5769.                                        /* viewable row ? */
    5770. 

  5770.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    5771. 

  5771.   {                                    /* address destination row */
    5772. 

  5772.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    5773. 

  5773.                                                    pData->iRow + pData->iDestt -
    5774. 

  5774.                                                    pData->iSourcet);
    5775. 

  5775.                                        /* adjust destination row starting-point */
    5776. 

  5776.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl << 2);
    5777. 

  5777.     pDataline = pData->pRGBArow;       /* address source row */
    5778. 

  5778. 

  5779.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    5780. 

  5780. 

  5781.     if (pData->bIsOpaque)              /* forget about transparency ? */
    5782. 

  5782.     {
    5783. 

  5783.       {
    5784. 

  5784.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5785. 

  5785.              iX += pData->iColinc)
    5786. 

  5786.         {                              /* copy the values and premultiply */
    5787. 

  5787. 		  if ((s = pDataline[3]) == 0)
    5788. 

  5788. 			*(mng_uint32*) pScanline = 0; /* set all components = 0 */
    5789. 

  5789. 		  else
    5790. 

  5790. 		  {
    5791. 

  5791. 			if (s == 255)
    5792. 

  5792. 			{
    5793. 

  5793.               pScanline[0] = 255;
    5794. 

  5794. 		      pScanline[1] = pDataline[2];
    5795. 

  5795.               pScanline[2] = pDataline[1];
    5796. 

  5796.               pScanline[3] = pDataline[0];
    5797. 

  5797. 			}
    5798. 

  5798. 			else
    5799. 

  5799. 			{
    5800. 

  5800.               pScanline[0] = (mng_uint8)s;
    5801. 

  5801. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5802. 

  5802.               {
    5803. 

  5803.                 int i;
    5804. 

  5804.                 for (i=2; i >= 0; i--)
    5805. 

  5805.                 {
    5806. 

  5806.                   pScanline[i+1] = DIV255B8(s * pDataline[2-i]);
    5807. 

  5807.                 }
    5808. 

  5808.               }
    5809. 

  5809. #else
    5810. 

  5810.               pScanline[1] = DIV255B8(s * pDataline[2]);
    5811. 

  5811.               pScanline[2] = DIV255B8(s * pDataline[1]);
    5812. 

  5812. 		      pScanline[3] = DIV255B8(s * pDataline[0]);
    5813. 

  5813. #endif
    5814. 

  5814. 			}
    5815. 

  5815. 		  }
    5816. 

  5816. 

  5817.           pScanline += (pData->iColinc << 2);
    5818. 

  5818.           pDataline += 4;
    5819. 

  5819.         }
    5820. 

  5820.       }
    5821. 

  5821.     }
    5822. 

  5822.     else
    5823. 

  5823.     {
    5824. 

  5824.       {
    5825. 

  5825.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5826. 

  5826.              iX += pData->iColinc)
    5827. 

  5827.         {
    5828. 

  5828.           if ((s = pDataline[3]) != 0)       /* any opacity at all ? */
    5829. 

  5829.           {                            /* fully opaque ? */
    5830. 

  5830.             if (s == 255)
    5831. 

  5831.             {                          /* then simply copy the values */
    5832. 

  5832.               pScanline[0] = 255;
    5833. 

  5833.               pScanline[1] = pDataline[2];
    5834. 

  5834.               pScanline[2] = pDataline[1];
    5835. 

  5835.               pScanline[3] = pDataline[0];
    5836. 

  5836.             }
    5837. 

  5837.             else
    5838. 

  5838.             {                          /* now blend (premultiplied) */
    5839. 

  5839. 			  t = 255 - s;
    5840. 

  5840.               pScanline[0] = (mng_uint8)(255 - DIV255B8(t * (255 - pScanline[0])));
    5841. 

  5841. #ifdef MNG_OPTIMIZE_FOOTPRINT_DIV
    5842. 

  5842.               {
    5843. 

  5843.                 int i;
    5844. 

  5844.                 for (i=2; i >= 0; i--)
    5845. 

  5845.                 {
    5846. 

  5846.                   pScanline[i+1] = DIV255B8(s * pDataline[2-i] + t *
    5847. 

  5847.                      pScanline[i+1]);
    5848. 

  5848.                 }
    5849. 

  5849.               }
    5850. 

  5850. #else
    5851. 

  5851. 			  pScanline[1] = DIV255B8(s * pDataline[2] + t * pScanline[1]);
    5852. 

  5852.               pScanline[2] = DIV255B8(s * pDataline[1] + t * pScanline[2]);
    5853. 

  5853.               pScanline[3] = DIV255B8(s * pDataline[0] + t * pScanline[3]);
    5854. 

  5854. #endif
    5855. 

  5855.             }
    5856. 

  5856.           }
    5857. 

  5857. 

  5858.           pScanline += (pData->iColinc << 2);
    5859. 

  5859.           pDataline += 4;
    5860. 

  5860.         }
    5861. 

  5861.       }
    5862. 

  5862.     }
    5863. 

  5863.   }
    5864. 

  5864. 

  5865.   check_update_region (pData);
    5866. 

  5866. 

  5867. #ifdef MNG_SUPPORT_TRACE
    5868. 

  5868.   MNG_TRACE (pData, MNG_FN_DISPLAY_ABGR8_PM, MNG_LC_END);
    5869. 

  5869. #endif
    5870. 

  5870. 

  5871.   return MNG_NOERROR;
    5872. 

  5872. }
    5873. 

  5873. #endif /* MNG_NO_16BIT_SUPPORT */
    5874. 

  5874. #endif /* MNG_SKIPCANVAS_ABGR8_PM */
    5875. 

  5875. 

  5876. /* ************************************************************************** */
    5877. 

  5877. 

  5878. #ifndef MNG_SKIPCANVAS_BGR565
    5879. 

  5879. #ifndef MNG_NO_16BIT_SUPPORT
    5880. 

  5880. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    5881. 

  5881. mng_retcode mng_display_bgr565 (mng_datap pData)
    5882. 

  5882. {
    5883. 

  5883.   mng_uint8p pScanline;
    5884. 

  5884.   mng_uint8p pDataline;
    5885. 

  5885.   mng_int32  iX;
    5886. 

  5886.   mng_uint16 iA16;
    5887. 

  5887.   mng_uint16 iFGr16, iFGg16, iFGb16;
    5888. 

  5888.   mng_uint16 iBGr16, iBGg16, iBGb16;
    5889. 

  5889.   mng_uint8  iA8;
    5890. 

  5890. 

  5891. #ifdef MNG_SUPPORT_TRACE
    5892. 

  5892.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
    5893. 

  5893. #endif
    5894. 

  5894.                                        /* viewable row ? */
    5895. 

  5895.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    5896. 

  5896.   {                                    /* address destination row */
    5897. 

  5897.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    5898. 

  5898.                                                    pData->iRow + pData->iDestt -
    5899. 

  5899.                                                    pData->iSourcet);
    5900. 

  5900.                                        /* adjust destination row starting-point */
    5901. 

  5901.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    5902. 

  5902.     pDataline = pData->pRGBArow;       /* address source row */
    5903. 

  5903. 

  5904.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    5905. 

  5905.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    5906. 

  5906.     else
    5907. 

  5907.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    5908. 

  5908. 

  5909.     if (pData->bIsOpaque)              /* forget about transparency ? */
    5910. 

  5910.     {
    5911. 

  5911.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5912. 

  5912.       {
    5913. 

  5913.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5914. 

  5914.              iX += pData->iColinc)
    5915. 

  5915.         {                              /* scale down by dropping the LSB */
    5916. 

  5916.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | (   (*(pDataline+2)>>5)       ) );
    5917. 

  5917.           *pScanline     = (mng_uint8)( ( (*(pDataline+4)) >>3) | (   (*(pDataline+2)&0xFC) << 3) );
    5918. 

  5918. 

  5919.           pScanline += (pData->iColinc * 2);
    5920. 

  5920.           pDataline += 8;
    5921. 

  5921.         }
    5922. 

  5922.       }
    5923. 

  5923.       else
    5924. 

  5924.       {
    5925. 

  5925.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5926. 

  5926.              iX += pData->iColinc)
    5927. 

  5927.         {                              /* copy the values */
    5928. 

  5928.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 )  |  ( (*(pDataline+1)>>5   )     ) );
    5929. 

  5929.           *pScanline     = (mng_uint8)( (  *(pDataline+2) >>3 )  |  ( (*(pDataline+1)&0xFC ) << 3) );
    5930. 

  5930. 

  5931. 

  5932.           pScanline += (pData->iColinc * 2);
    5933. 

  5933.           pDataline += 4;
    5934. 

  5934.         }
    5935. 

  5935.       }
    5936. 

  5936.     }
    5937. 

  5937.     else
    5938. 

  5938.     {
    5939. 

  5939.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    5940. 

  5940.       {
    5941. 

  5941. 

  5942.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5943. 

  5943.              iX += pData->iColinc)
    5944. 

  5944.         {
    5945. 

  5945.           iA16 = mng_get_uint16 (pDataline+6);
    5946. 

  5946. 

  5947.           if (iA16)                    /* any opacity at all ? */
    5948. 

  5948.           {
    5949. 

  5949.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    5950. 

  5950.             {                          /* scale down by dropping the LSB */
    5951. 

  5951.               *(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 )  |  (mng_uint8)( (*(pDataline+2)>>5  )     );
    5952. 

  5952.               *pScanline     = (mng_uint8)( (*(pDataline+4)) >>3)  |  (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    5953. 

  5953.             }
    5954. 

  5954.             else
    5955. 

  5955.             {                          /* get the proper values */
    5956. 

  5956.               iFGr16 = mng_get_uint16 (pDataline  );
    5957. 

  5957.               iFGg16 = mng_get_uint16 (pDataline+2);
    5958. 

  5958.               iFGb16 = mng_get_uint16 (pDataline+4);
    5959. 

  5959.                                        /* scale background up */
    5960. 

  5960. 

  5961.               iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    5962. 

  5962.               iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    5963. 

  5963.               iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    5964. 

  5964. 

  5965.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    5966. 

  5966.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    5967. 

  5967.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    5968. 

  5968.                                        /* now compose */
    5969. 

  5969.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    5970. 

  5970.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    5971. 

  5971.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    5972. 

  5972.                                        /* and return the composed values */
    5973. 

  5973.               *(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 )  |  ( (mng_uint8)(iFGg16>>8) >> 5)      );
    5974. 

  5974.               *pScanline     = (mng_uint8) ( ( (iFGb16>>11)       )  |  (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    5975. 

  5975.             }
    5976. 

  5976.           }
    5977. 

  5977. 

  5978.           pScanline += (pData->iColinc * 2);
    5979. 

  5979.           pDataline += 8;
    5980. 

  5980.         }
    5981. 

  5981.       }
    5982. 

  5982.       else
    5983. 

  5983.       {
    5984. 

  5984.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    5985. 

  5985.              iX += pData->iColinc)
    5986. 

  5986.         {
    5987. 

  5987.           iA8 = *(pDataline+3);        /* get alpha value */
    5988. 

  5988. 

  5989.           if (iA8)                     /* any opacity at all ? */
    5990. 

  5990.           {
    5991. 

  5991.             if (iA8 == 0xFF)           /* fully opaque ? */
    5992. 

  5992.             {                          /* then simply copy the values */
    5993. 

  5993.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    5994. 

  5994.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    5995. 

  5995.             }
    5996. 

  5996.             else
    5997. 

  5997.             {                          /* do alpha composing */
    5998. 

  5998.               mng_uint8 iRed, iGreen, iBlue;
    5999. 

  5999. 

  6000.               iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    6001. 

  6001.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    6002. 

  6002.               iBlue  = (mng_uint8) ( (*pScanline << 3) );
    6003. 

  6003. 

  6004.               MNG_COMPOSE8 (iRed,     *pDataline,     iA8, iRed    );
    6005. 

  6005.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    6006. 

  6006.               MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    6007. 

  6007. 

  6008.               *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  |   (iGreen>>5) );
    6009. 

  6009.               *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ( (iGreen & 0xFC) << 3) );
    6010. 

  6010.             }
    6011. 

  6011.           }
    6012. 

  6012. 

  6013.           pScanline += (pData->iColinc * 2);
    6014. 

  6014.           pDataline += 4;
    6015. 

  6015.         }
    6016. 

  6016.       }
    6017. 

  6017.     }
    6018. 

  6018.   }
    6019. 

  6019. 

  6020.   check_update_region (pData);
    6021. 

  6021. 

  6022. #ifdef MNG_SUPPORT_TRACE
    6023. 

  6023.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
    6024. 

  6024. #endif
    6025. 

  6025. 

  6026.   return MNG_NOERROR;
    6027. 

  6027. }
    6028. 

  6028. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    6029. 

  6029. mng_retcode mng_display_bgr565 (mng_datap pData)
    6030. 

  6030. {
    6031. 

  6031.   mng_uint8p pScanline;
    6032. 

  6032.   mng_uint8p pDataline;
    6033. 

  6033.   mng_int32  iX;
    6034. 

  6034.   mng_uint16 iA16;
    6035. 

  6035.   mng_uint16 iFGr16, iFGg16, iFGb16;
    6036. 

  6036.   mng_uint16 iBGr16, iBGg16, iBGb16;
    6037. 

  6037.   mng_uint8  iA8;
    6038. 

  6038.   mng_uint8  iBps;
    6039. 

  6039. 

  6040. #ifdef MNG_SUPPORT_TRACE
    6041. 

  6041.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
    6042. 

  6042. #endif
    6043. 

  6043. 

  6044.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    6045. 

  6045.                                        /* viewable row ? */
    6046. 

  6046.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6047. 

  6047.   {                                    /* address destination row */
    6048. 

  6048.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6049. 

  6049.                                                    pData->iRow + pData->iDestt -
    6050. 

  6050.                                                    pData->iSourcet);
    6051. 

  6051.                                        /* adjust destination row starting-point */
    6052. 

  6052.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    6053. 

  6053.     pDataline = pData->pRGBArow;       /* address source row */
    6054. 

  6054. 

  6055.     /* adjust source row starting-point */
    6056. 

  6056.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    6057. 

  6057. 

  6058.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6059. 

  6059.     {
    6060. 

  6060.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6061. 

  6061.              iX += pData->iColinc)
    6062. 

  6062.         {                              /* scale down by dropping the LSB */
    6063. 

  6063.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) |
    6064. 

  6064.            (   (*(pDataline+iBps)>>5)       ) );
    6065. 

  6065.           *pScanline     = (mng_uint8)( ( (*(pDataline+2*iBps)) >>3) |
    6066. 

  6066.            (   (*(pDataline+iBps)&0xFC) << 3) );
    6067. 

  6067. 

  6068.           pScanline += (pData->iColinc * 2);
    6069. 

  6069.           pDataline += 4*iBps;
    6070. 

  6070.         }
    6071. 

  6071.     }
    6072. 

  6072.     else
    6073. 

  6073.     {
    6074. 

  6074.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6075. 

  6075.       {
    6076. 

  6076. 

  6077.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6078. 

  6078.              iX += pData->iColinc)
    6079. 

  6079.         {
    6080. 

  6080.           iA16 = mng_get_uint16 (pDataline+6);
    6081. 

  6081. 

  6082.           if (iA16)                    /* any opacity at all ? */
    6083. 

  6083.           {
    6084. 

  6084.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    6085. 

  6085.             {                          /* scale down by dropping the LSB */
    6086. 

  6086.               *(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 )  |  (mng_uint8)( (*(pDataline+2)>>5  )     );
    6087. 

  6087.               *pScanline     = (mng_uint8)( (*(pDataline+4)) >>3)  |  (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    6088. 

  6088.             }
    6089. 

  6089.             else
    6090. 

  6090.             {                          /* get the proper values */
    6091. 

  6091.               iFGr16 = mng_get_uint16 (pDataline  );
    6092. 

  6092.               iFGg16 = mng_get_uint16 (pDataline+2);
    6093. 

  6093.               iFGb16 = mng_get_uint16 (pDataline+4);
    6094. 

  6094.                                        /* scale background up */
    6095. 

  6095. 

  6096.               iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    6097. 

  6097.               iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    6098. 

  6098.               iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    6099. 

  6099. 

  6100.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6101. 

  6101.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6102. 

  6102.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6103. 

  6103.                                        /* now compose */
    6104. 

  6104.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    6105. 

  6105.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    6106. 

  6106.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    6107. 

  6107.                                        /* and return the composed values */
    6108. 

  6108.               *(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 )  |  ( (mng_uint8)(iFGg16>>8) >> 5)      );
    6109. 

  6109.               *pScanline     = (mng_uint8) ( ( (iFGb16>>11)       )  |  (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    6110. 

  6110.             }
    6111. 

  6111.           }
    6112. 

  6112. 

  6113.           pScanline += (pData->iColinc * 2);
    6114. 

  6114.           pDataline += 8;
    6115. 

  6115.         }
    6116. 

  6116.       }
    6117. 

  6117.       else
    6118. 

  6118.       {
    6119. 

  6119.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6120. 

  6120.              iX += pData->iColinc)
    6121. 

  6121.         {
    6122. 

  6122.           iA8 = *(pDataline+3);        /* get alpha value */
    6123. 

  6123. 

  6124.           if (iA8)                     /* any opacity at all ? */
    6125. 

  6125.           {
    6126. 

  6126.             if (iA8 == 0xFF)           /* fully opaque ? */
    6127. 

  6127.             {                          /* then simply copy the values */
    6128. 

  6128.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    6129. 

  6129.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    6130. 

  6130.             }
    6131. 

  6131.             else
    6132. 

  6132.             {                          /* do alpha composing */
    6133. 

  6133.               mng_uint8 iRed, iGreen, iBlue;
    6134. 

  6134. 

  6135.               iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    6136. 

  6136.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    6137. 

  6137.               iBlue  = (mng_uint8) ( (*pScanline << 3) );
    6138. 

  6138. 

  6139.               MNG_COMPOSE8 (iRed,     *pDataline,     iA8, iRed    );
    6140. 

  6140.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    6141. 

  6141.               MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    6142. 

  6142. 

  6143.               *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  |   (iGreen>>5) );
    6144. 

  6144.               *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ( (iGreen & 0xFC) << 3) );
    6145. 

  6145.             }
    6146. 

  6146.           }
    6147. 

  6147. 

  6148.           pScanline += (pData->iColinc * 2);
    6149. 

  6149.           pDataline += 4;
    6150. 

  6150.         }
    6151. 

  6151.       }
    6152. 

  6152.     }
    6153. 

  6153.   }
    6154. 

  6154. 

  6155.   check_update_region (pData);
    6156. 

  6156. 

  6157. #ifdef MNG_SUPPORT_TRACE
    6158. 

  6158.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
    6159. 

  6159. #endif
    6160. 

  6160. 

  6161.   return MNG_NOERROR;
    6162. 

  6162. }
    6163. 

  6163. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    6164. 

  6164. #else /* MNG_NO_16BIT_SUPPORT */
    6165. 

  6165. mng_retcode mng_display_bgr565 (mng_datap pData)
    6166. 

  6166. {
    6167. 

  6167.   mng_uint8p pScanline;
    6168. 

  6168.   mng_uint8p pDataline;
    6169. 

  6169.   mng_int32  iX;
    6170. 

  6170.   mng_uint8  iA8;
    6171. 

  6171. 

  6172. #ifdef MNG_SUPPORT_TRACE
    6173. 

  6173.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_START);
    6174. 

  6174. #endif
    6175. 

  6175.                                        /* viewable row ? */
    6176. 

  6176.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6177. 

  6177.   {                                    /* address destination row */
    6178. 

  6178.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6179. 

  6179.                                                    pData->iRow + pData->iDestt -
    6180. 

  6180.                                                    pData->iSourcet);
    6181. 

  6181.                                        /* adjust destination row starting-point */
    6182. 

  6182.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    6183. 

  6183.     pDataline = pData->pRGBArow;       /* address source row */
    6184. 

  6184. 

  6185.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    6186. 

  6186. 

  6187.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6188. 

  6188.     {
    6189. 

  6189.       {
    6190. 

  6190.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6191. 

  6191.              iX += pData->iColinc)
    6192. 

  6192.         {                              /* copy the values */
    6193. 

  6193.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 )  |  ( (*(pDataline+1)>>5   )     ) );
    6194. 

  6194.           *pScanline     = (mng_uint8)( (  *(pDataline+2) >>3 )  |  ( (*(pDataline+1)&0xFC ) << 3) );
    6195. 

  6195. 

  6196. 

  6197.           pScanline += (pData->iColinc * 2);
    6198. 

  6198.           pDataline += 4;
    6199. 

  6199.         }
    6200. 

  6200.       }
    6201. 

  6201.     }
    6202. 

  6202.     else
    6203. 

  6203.     {
    6204. 

  6204.       {
    6205. 

  6205.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6206. 

  6206.              iX += pData->iColinc)
    6207. 

  6207.         {
    6208. 

  6208.           iA8 = *(pDataline+3);        /* get alpha value */
    6209. 

  6209. 

  6210.           if (iA8)                     /* any opacity at all ? */
    6211. 

  6211.           {
    6212. 

  6212.             if (iA8 == 0xFF)           /* fully opaque ? */
    6213. 

  6213.             {                          /* then simply copy the values */
    6214. 

  6214.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    6215. 

  6215.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    6216. 

  6216.             }
    6217. 

  6217.             else
    6218. 

  6218.             {                          /* do alpha composing */
    6219. 

  6219.               mng_uint8 iRed, iGreen, iBlue;
    6220. 

  6220. 

  6221.               iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    6222. 

  6222.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    6223. 

  6223.               iBlue  = (mng_uint8) ( (*pScanline << 3) );
    6224. 

  6224. 

  6225.               MNG_COMPOSE8 (iRed,     *pDataline,     iA8, iRed    );
    6226. 

  6226.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    6227. 

  6227.               MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    6228. 

  6228. 

  6229.               *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  |   (iGreen>>5) );
    6230. 

  6230.               *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ( (iGreen & 0xFC) << 3) );
    6231. 

  6231.             }
    6232. 

  6232.           }
    6233. 

  6233. 

  6234.           pScanline += (pData->iColinc * 2);
    6235. 

  6235.           pDataline += 4;
    6236. 

  6236.         }
    6237. 

  6237.       }
    6238. 

  6238.     }
    6239. 

  6239.   }
    6240. 

  6240. 

  6241.   check_update_region (pData);
    6242. 

  6242. 

  6243. #ifdef MNG_SUPPORT_TRACE
    6244. 

  6244.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565, MNG_LC_END);
    6245. 

  6245. #endif
    6246. 

  6246. 

  6247.   return MNG_NOERROR;
    6248. 

  6248. }
    6249. 

  6249. #endif /* MNG_NO_16BIT_SUPPORT */
    6250. 

  6250. #endif /* MNG_SKIPCANVAS_BGR565 */
    6251. 

  6251. 

  6252. /* ************************************************************************** */
    6253. 

  6253. 

  6254. #ifndef MNG_SKIPCANVAS_RGB565
    6255. 

  6255. #ifndef MNG_NO_16BIT_SUPPORT
    6256. 

  6256. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    6257. 

  6257. mng_retcode mng_display_rgb565 (mng_datap pData)
    6258. 

  6258. {
    6259. 

  6259.   mng_uint8p pScanline;
    6260. 

  6260.   mng_uint8p pDataline;
    6261. 

  6261.   mng_int32  iX;
    6262. 

  6262.   mng_uint16 iA16;
    6263. 

  6263.   mng_uint16 iFGr16, iFGg16, iFGb16;
    6264. 

  6264.   mng_uint16 iBGr16, iBGg16, iBGb16;
    6265. 

  6265.   mng_uint8  iA8;
    6266. 

  6266. 

  6267. #ifdef MNG_SUPPORT_TRACE
    6268. 

  6268.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
    6269. 

  6269. #endif
    6270. 

  6270.                                        /* viewable row ? */
    6271. 

  6271.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6272. 

  6272.   {                                    /* address destination row */
    6273. 

  6273.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6274. 

  6274.                                                    pData->iRow + pData->iDestt -
    6275. 

  6275.                                                    pData->iSourcet);
    6276. 

  6276.                                        /* adjust destination row starting-point */
    6277. 

  6277.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    6278. 

  6278.     pDataline = pData->pRGBArow;       /* address source row */
    6279. 

  6279. 

  6280.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    6281. 

  6281.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    6282. 

  6282.     else
    6283. 

  6283.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    6284. 

  6284. 

  6285.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6286. 

  6286.     {
    6287. 

  6287.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6288. 

  6288.       {
    6289. 

  6289.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6290. 

  6290.              iX += pData->iColinc)
    6291. 

  6291.         {                              /* scale down by dropping the LSB */
    6292. 

  6292.           *(pScanline+1) = (mng_uint8)( ( ( *(pDataline+4)) & 0xF8)  |   (*(pDataline+2) >> 5  )       );
    6293. 

  6293.           *pScanline     = (mng_uint8)( ( ( *(pDataline  )) >> 3  )  |  ((*(pDataline+2) & 0xFC) << 3) );
    6294. 

  6294. 

  6295.           pScanline += (pData->iColinc * 2);
    6296. 

  6296.           pDataline += 8;
    6297. 

  6297.         }
    6298. 

  6298.       }
    6299. 

  6299.       else
    6300. 

  6300.       {
    6301. 

  6301.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6302. 

  6302.              iX += pData->iColinc)
    6303. 

  6303.         {                              /* copy the values */
    6304. 

  6304.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8)  |   (*(pDataline+1) >> 5        ) );
    6305. 

  6305.           *pScanline     = (mng_uint8)( (  *(pDataline  )  >> 3  )  |  ((*(pDataline+1) & 0xFC) << 3) );
    6306. 

  6306. 

  6307.           pScanline += (pData->iColinc * 2);
    6308. 

  6308.           pDataline += 4;
    6309. 

  6309.         }
    6310. 

  6310.       }
    6311. 

  6311.     }
    6312. 

  6312.     else
    6313. 

  6313.     {
    6314. 

  6314.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6315. 

  6315.       {
    6316. 

  6316. 

  6317.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6318. 

  6318.              iX += pData->iColinc)
    6319. 

  6319.         {
    6320. 

  6320.           iA16 = mng_get_uint16 (pDataline+6);
    6321. 

  6321. 

  6322.           if (iA16)                    /* any opacity at all ? */
    6323. 

  6323.           {
    6324. 

  6324.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    6325. 

  6325.             {                          /* scale down by dropping the LSB */
    6326. 

  6326.               *(pScanline+1) = (mng_uint8)( ( (*(pDataline+4)) & 0xF8)  |   (*(pDataline+2)>>5) );
    6327. 

  6327.               *pScanline     = (mng_uint8)( ( (*(pDataline  )) >> 3  )  |  ((*(pDataline+2)&0xFC) << 3) );
    6328. 

  6328.             }
    6329. 

  6329.             else
    6330. 

  6330.             {                          /* get the proper values */
    6331. 

  6331.               iFGr16 = mng_get_uint16 (pDataline  );
    6332. 

  6332.               iFGg16 = mng_get_uint16 (pDataline+2);
    6333. 

  6333.               iFGb16 = mng_get_uint16 (pDataline+4);
    6334. 

  6334. 

  6335. 			                           /* scale background up */
    6336. 

  6336.               iBGr16 = (mng_uint8)(  *(pScanline+1) & 0xF8 );
    6337. 

  6337.               iBGg16 = (mng_uint8)( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0) >> 3 ) );
    6338. 

  6338.               iBGb16 = (mng_uint8)(  *(pScanline  ) << 3   );
    6339. 

  6339. 

  6340.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6341. 

  6341.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6342. 

  6342.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6343. 

  6343.                                        /* now compose */
    6344. 

  6344.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    6345. 

  6345.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    6346. 

  6346.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    6347. 

  6347.                                        /* and return the composed values */
    6348. 

  6348.               *(pScanline+1) = (mng_uint8)( (mng_uint8)((iFGb16 >> 8) &0xF8) |   (   (mng_uint8)(iFGg16 >> 8) >> 5  )        );
    6349. 

  6349.               *pScanline     = (mng_uint8)( (mng_uint8) (iFGr16 >>11)        |   ( ( (mng_uint8)(iFGg16 >> 8) & 0xFC) << 3)  );
    6350. 

  6350.             }
    6351. 

  6351.           }
    6352. 

  6352. 

  6353.           pScanline += (pData->iColinc * 2);
    6354. 

  6354.           pDataline += 8;
    6355. 

  6355.         }
    6356. 

  6356.       }
    6357. 

  6357.       else
    6358. 

  6358.       {
    6359. 

  6359.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6360. 

  6360.              iX += pData->iColinc)
    6361. 

  6361.         {
    6362. 

  6362.           iA8 = *(pDataline+3);        /* get alpha value */
    6363. 

  6363. 

  6364.           if (iA8)                     /* any opacity at all ? */
    6365. 

  6365.           {
    6366. 

  6366.             if (iA8 == 0xFF)           /* fully opaque ? */
    6367. 

  6367.             {                          /* then simply copy the values */
    6368. 

  6368.               *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8)  |  (  *(pDataline+1) >> 5         ) );
    6369. 

  6369.               *pScanline     = (mng_uint8)( ( (*(pDataline  )) >> 3  )  |  ( (*(pDataline+1) & 0xFC) << 3 ) );
    6370. 

  6370.             }
    6371. 

  6371.             else
    6372. 

  6372.             {                          /* do alpha composing */
    6373. 

  6373.               mng_uint8 iRed, iGreen, iBlue;
    6374. 

  6374. 

  6375.               iRed   = (mng_uint8)(   *(pScanline+1) & 0xF8);
    6376. 

  6376.               iGreen = (mng_uint8)( ( *(pScanline+1) << 5  )  |  ( ( (*pScanline)&0xE0)>>3 ) );
    6377. 

  6377.               iBlue  = (mng_uint8)(   *(pScanline  ) << 3 );
    6378. 

  6378. 

  6379.               MNG_COMPOSE8 (iRed,     *(pDataline+2), iA8, iRed    );
    6380. 

  6380.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    6381. 

  6381.               MNG_COMPOSE8 (iBlue,    *(pDataline+0), iA8, iBlue   );
    6382. 

  6382. 

  6383.               *(pScanline+1) = (mng_uint8)( ( iRed & 0xF8)  |  (  iGreen >> 5        ) );
    6384. 

  6384.               *pScanline     = (mng_uint8)( (iBlue >> 3  )  |  ( (iGreen & 0xFC) << 3) );
    6385. 

  6385.             }
    6386. 

  6386.           }
    6387. 

  6387. 

  6388.           pScanline += (pData->iColinc * 2);
    6389. 

  6389.           pDataline += 4;
    6390. 

  6390.         }
    6391. 

  6391.       }
    6392. 

  6392.     }
    6393. 

  6393.   }
    6394. 

  6394. 

  6395.   check_update_region (pData);
    6396. 

  6396. 

  6397. #ifdef MNG_SUPPORT_TRACE
    6398. 

  6398.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
    6399. 

  6399. #endif
    6400. 

  6400. 

  6401.   return MNG_NOERROR;
    6402. 

  6402. }
    6403. 

  6403. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    6404. 

  6404. mng_retcode mng_display_rgb565 (mng_datap pData)
    6405. 

  6405. {
    6406. 

  6406.   mng_uint8p pScanline;
    6407. 

  6407.   mng_uint8p pDataline;
    6408. 

  6408.   mng_int32  iX;
    6409. 

  6409.   mng_uint16 iA16;
    6410. 

  6410.   mng_uint16 iFGr16, iFGg16, iFGb16;
    6411. 

  6411.   mng_uint16 iBGr16, iBGg16, iBGb16;
    6412. 

  6412.   mng_uint8  iA8;
    6413. 

  6413.   mng_uint8  iBps;
    6414. 

  6414. 

  6415. #ifdef MNG_SUPPORT_TRACE
    6416. 

  6416.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
    6417. 

  6417. #endif
    6418. 

  6418. 

  6419.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    6420. 

  6420.                                        /* viewable row ? */
    6421. 

  6421.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6422. 

  6422.   {                                    /* address destination row */
    6423. 

  6423.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6424. 

  6424.                                                    pData->iRow + pData->iDestt -
    6425. 

  6425.                                                    pData->iSourcet);
    6426. 

  6426.                                        /* adjust destination row starting-point */
    6427. 

  6427.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    6428. 

  6428.     pDataline = pData->pRGBArow;       /* address source row */
    6429. 

  6429. 

  6430.     /* adjust source row starting-point */
    6431. 

  6431.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    6432. 

  6432. 

  6433.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6434. 

  6434.     {
    6435. 

  6435.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6436. 

  6436.              iX += pData->iColinc)
    6437. 

  6437.         {                              /* scale down by dropping the LSB */
    6438. 

  6438.           *(pScanline+1) = (mng_uint8)( ( ( *(pDataline+2*iBps)) & 0xF8)  |
    6439. 

  6439.               (*(pDataline+iBps) >> 5  )       );
    6440. 

  6440.           *pScanline     = (mng_uint8)( ( ( *(pDataline  )) >> 3  )  |
    6441. 

  6441.              ((*(pDataline+iBps) & 0xFC) << 3) );
    6442. 

  6442. 

  6443.           pScanline += (pData->iColinc * 2);
    6444. 

  6444.           pDataline += 4*iBps;
    6445. 

  6445.         }
    6446. 

  6446.     }
    6447. 

  6447.     else
    6448. 

  6448.     {
    6449. 

  6449.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6450. 

  6450.       {
    6451. 

  6451. 

  6452.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6453. 

  6453.              iX += pData->iColinc)
    6454. 

  6454.         {
    6455. 

  6455.           iA16 = mng_get_uint16 (pDataline+6);
    6456. 

  6456. 

  6457.           if (iA16)                    /* any opacity at all ? */
    6458. 

  6458.           {
    6459. 

  6459.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    6460. 

  6460.             {                          /* scale down by dropping the LSB */
    6461. 

  6461.               *(pScanline+1) = (mng_uint8)( ( (*(pDataline+4)) & 0xF8)  |   (*(pDataline+2)>>5) );
    6462. 

  6462.               *pScanline     = (mng_uint8)( ( (*(pDataline  )) >> 3  )  |  ((*(pDataline+2)&0xFC) << 3) );
    6463. 

  6463.             }
    6464. 

  6464.             else
    6465. 

  6465.             {                          /* get the proper values */
    6466. 

  6466.               iFGr16 = mng_get_uint16 (pDataline  );
    6467. 

  6467.               iFGg16 = mng_get_uint16 (pDataline+2);
    6468. 

  6468.               iFGb16 = mng_get_uint16 (pDataline+4);
    6469. 

  6469. 

  6470. 			                           /* scale background up */
    6471. 

  6471.               iBGr16 = (mng_uint8)(  *(pScanline+1) & 0xF8 );
    6472. 

  6472.               iBGg16 = (mng_uint8)( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0) >> 3 ) );
    6473. 

  6473.               iBGb16 = (mng_uint8)(  *(pScanline  ) << 3   );
    6474. 

  6474. 

  6475.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6476. 

  6476.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6477. 

  6477.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6478. 

  6478.                                        /* now compose */
    6479. 

  6479.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    6480. 

  6480.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    6481. 

  6481.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    6482. 

  6482.                                        /* and return the composed values */
    6483. 

  6483.               *(pScanline+1) = (mng_uint8)( (mng_uint8)((iFGb16 >> 8) &0xF8) |   (   (mng_uint8)(iFGg16 >> 8) >> 5  )        );
    6484. 

  6484.               *pScanline     = (mng_uint8)( (mng_uint8) (iFGr16 >>11)        |   ( ( (mng_uint8)(iFGg16 >> 8) & 0xFC) << 3)  );
    6485. 

  6485.             }
    6486. 

  6486.           }
    6487. 

  6487. 

  6488.           pScanline += (pData->iColinc * 2);
    6489. 

  6489.           pDataline += 8;
    6490. 

  6490.         }
    6491. 

  6491.       }
    6492. 

  6492.       else
    6493. 

  6493.       {
    6494. 

  6494.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6495. 

  6495.              iX += pData->iColinc)
    6496. 

  6496.         {
    6497. 

  6497.           iA8 = *(pDataline+3);        /* get alpha value */
    6498. 

  6498. 

  6499.           if (iA8)                     /* any opacity at all ? */
    6500. 

  6500.           {
    6501. 

  6501.             if (iA8 == 0xFF)           /* fully opaque ? */
    6502. 

  6502.             {                          /* then simply copy the values */
    6503. 

  6503.               *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8)  |  (  *(pDataline+1) >> 5         ) );
    6504. 

  6504.               *pScanline     = (mng_uint8)( ( (*(pDataline  )) >> 3  )  |  ( (*(pDataline+1) & 0xFC) << 3 ) );
    6505. 

  6505.             }
    6506. 

  6506.             else
    6507. 

  6507.             {                          /* do alpha composing */
    6508. 

  6508.               mng_uint8 iRed, iGreen, iBlue;
    6509. 

  6509. 

  6510.               iRed   = (mng_uint8)(   *(pScanline+1) & 0xF8);
    6511. 

  6511.               iGreen = (mng_uint8)( ( *(pScanline+1) << 5  )  |  ( ( (*pScanline)&0xE0)>>3 ) );
    6512. 

  6512.               iBlue  = (mng_uint8)(   *(pScanline  ) << 3 );
    6513. 

  6513. 

  6514.               MNG_COMPOSE8 (iRed,     *(pDataline+2), iA8, iRed    );
    6515. 

  6515.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    6516. 

  6516.               MNG_COMPOSE8 (iBlue,    *(pDataline+0), iA8, iBlue   );
    6517. 

  6517. 

  6518.               *(pScanline+1) = (mng_uint8)( ( iRed & 0xF8)  |  (  iGreen >> 5        ) );
    6519. 

  6519.               *pScanline     = (mng_uint8)( (iBlue >> 3  )  |  ( (iGreen & 0xFC) << 3) );
    6520. 

  6520.             }
    6521. 

  6521.           }
    6522. 

  6522. 

  6523.           pScanline += (pData->iColinc * 2);
    6524. 

  6524.           pDataline += 4;
    6525. 

  6525.         }
    6526. 

  6526.       }
    6527. 

  6527.     }
    6528. 

  6528.   }
    6529. 

  6529. 

  6530.   check_update_region (pData);
    6531. 

  6531. 

  6532. #ifdef MNG_SUPPORT_TRACE
    6533. 

  6533.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
    6534. 

  6534. #endif
    6535. 

  6535. 

  6536.   return MNG_NOERROR;
    6537. 

  6537. }
    6538. 

  6538. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    6539. 

  6539. #else /* MNG_NO_16BIT_SUPPORT */
    6540. 

  6540. mng_retcode mng_display_rgb565 (mng_datap pData)
    6541. 

  6541. {
    6542. 

  6542.   mng_uint8p pScanline;
    6543. 

  6543.   mng_uint8p pDataline;
    6544. 

  6544.   mng_int32  iX;
    6545. 

  6545.   mng_uint8  iA8;
    6546. 

  6546. 

  6547. #ifdef MNG_SUPPORT_TRACE
    6548. 

  6548.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_START);
    6549. 

  6549. #endif
    6550. 

  6550.                                        /* viewable row ? */
    6551. 

  6551.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6552. 

  6552.   {                                    /* address destination row */
    6553. 

  6553.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6554. 

  6554.                                                    pData->iRow + pData->iDestt -
    6555. 

  6555.                                                    pData->iSourcet);
    6556. 

  6556.                                        /* adjust destination row starting-point */
    6557. 

  6557.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    6558. 

  6558.     pDataline = pData->pRGBArow;       /* address source row */
    6559. 

  6559. 

  6560.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    6561. 

  6561. 

  6562.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6563. 

  6563.     {
    6564. 

  6564.       {
    6565. 

  6565.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6566. 

  6566.              iX += pData->iColinc)
    6567. 

  6567.         {                              /* copy the values */
    6568. 

  6568.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8)  |   (*(pDataline+1) >> 5        ) );
    6569. 

  6569.           *pScanline     = (mng_uint8)( (  *(pDataline  )  >> 3  )  |  ((*(pDataline+1) & 0xFC) << 3) );
    6570. 

  6570. 

  6571.           pScanline += (pData->iColinc * 2);
    6572. 

  6572.           pDataline += 4;
    6573. 

  6573.         }
    6574. 

  6574.       }
    6575. 

  6575.     }
    6576. 

  6576.     else
    6577. 

  6577.     {
    6578. 

  6578.       {
    6579. 

  6579.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6580. 

  6580.              iX += pData->iColinc)
    6581. 

  6581.         {
    6582. 

  6582.           iA8 = *(pDataline+3);        /* get alpha value */
    6583. 

  6583. 

  6584.           if (iA8)                     /* any opacity at all ? */
    6585. 

  6585.           {
    6586. 

  6586.             if (iA8 == 0xFF)           /* fully opaque ? */
    6587. 

  6587.             {                          /* then simply copy the values */
    6588. 

  6588.               *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2)) & 0xF8)  |  (  *(pDataline+1) >> 5         ) );
    6589. 

  6589.               *pScanline     = (mng_uint8)( ( (*(pDataline  )) >> 3  )  |  ( (*(pDataline+1) & 0xFC) << 3 ) );
    6590. 

  6590.             }
    6591. 

  6591.             else
    6592. 

  6592.             {                          /* do alpha composing */
    6593. 

  6593.               mng_uint8 iRed, iGreen, iBlue;
    6594. 

  6594. 

  6595.               iRed   = (mng_uint8)(   *(pScanline+1) & 0xF8);
    6596. 

  6596.               iGreen = (mng_uint8)( ( *(pScanline+1) << 5  )  |  ( ( (*pScanline)&0xE0)>>3 ) );
    6597. 

  6597.               iBlue  = (mng_uint8)(   *(pScanline  ) << 3 );
    6598. 

  6598. 

  6599.               MNG_COMPOSE8 (iRed,     *(pDataline+2), iA8, iRed    );
    6600. 

  6600.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    6601. 

  6601.               MNG_COMPOSE8 (iBlue,    *(pDataline+0), iA8, iBlue   );
    6602. 

  6602. 

  6603.               *(pScanline+1) = (mng_uint8)( ( iRed & 0xF8)  |  (  iGreen >> 5        ) );
    6604. 

  6604.               *pScanline     = (mng_uint8)( (iBlue >> 3  )  |  ( (iGreen & 0xFC) << 3) );
    6605. 

  6605.             }
    6606. 

  6606.           }
    6607. 

  6607. 

  6608.           pScanline += (pData->iColinc * 2);
    6609. 

  6609.           pDataline += 4;
    6610. 

  6610.         }
    6611. 

  6611.       }
    6612. 

  6612.     }
    6613. 

  6613.   }
    6614. 

  6614. 

  6615.   check_update_region (pData);
    6616. 

  6616. 

  6617. #ifdef MNG_SUPPORT_TRACE
    6618. 

  6618.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB565, MNG_LC_END);
    6619. 

  6619. #endif
    6620. 

  6620. 

  6621.   return MNG_NOERROR;
    6622. 

  6622. }
    6623. 

  6623. #endif /* MNG_NO_16BIT_SUPPORT */
    6624. 

  6624. #endif /* MNG_SKIPCANVAS_RGB565 */
    6625. 

  6625. 

  6626. /* ************************************************************************** */
    6627. 

  6627. 

  6628. #ifndef MNG_SKIPCANVAS_BGRA565
    6629. 

  6629. #ifndef MNG_NO_16BIT_SUPPORT
    6630. 

  6630. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    6631. 

  6631. mng_retcode mng_display_bgra565 (mng_datap pData)
    6632. 

  6632. {
    6633. 

  6633.   mng_uint8p pScanline;
    6634. 

  6634.   mng_uint8p pDataline;
    6635. 

  6635.   mng_int32  iX;
    6636. 

  6636.   mng_uint8  iFGa8, iBGa8, iCa8;
    6637. 

  6637.   mng_uint16 iFGa16, iBGa16, iCa16;
    6638. 

  6638.   mng_uint16 iFGr16, iFGg16, iFGb16;
    6639. 

  6639.   mng_uint16 iBGr16, iBGg16, iBGb16;
    6640. 

  6640.   mng_uint16 iCr16, iCg16, iCb16;
    6641. 

  6641.   mng_uint8  iCr8, iCg8, iCb8;
    6642. 

  6642. 

  6643. #ifdef MNG_SUPPORT_TRACE
    6644. 

  6644.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
    6645. 

  6645. #endif
    6646. 

  6646.                                        /* viewable row ? */
    6647. 

  6647.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6648. 

  6648.   {                                    /* address destination row */
    6649. 

  6649.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6650. 

  6650.                                                    pData->iRow + pData->iDestt -
    6651. 

  6651.                                                    pData->iSourcet);
    6652. 

  6652.                                        /* adjust destination row starting-point */
    6653. 

  6653.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
    6654. 

  6654.     pDataline = pData->pRGBArow;       /* address source row */
    6655. 

  6655. 

  6656.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    6657. 

  6657.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    6658. 

  6658.     else
    6659. 

  6659.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    6660. 

  6660. 

  6661.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6662. 

  6662.     {
    6663. 

  6663.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6664. 

  6664.       {
    6665. 

  6665.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6666. 

  6666.              iX += pData->iColinc)
    6667. 

  6667.         {                              /* scale down by dropping the LSB */
    6668. 

  6668.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | (   (*(pDataline+2)>>5)       ) );
    6669. 

  6669.           *pScanline     = (mng_uint8)( ( (*(pDataline+4)) >>3) | (   (*(pDataline+2)&0xFC) << 3) );
    6670. 

  6670.           *(pScanline+2) = *(pDataline+6);
    6671. 

  6671. 

  6672.           pScanline += (pData->iColinc * 3);
    6673. 

  6673.           pDataline += 8;
    6674. 

  6674.         }
    6675. 

  6675.       }
    6676. 

  6676.       else
    6677. 

  6677.       {
    6678. 

  6678.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6679. 

  6679.              iX += pData->iColinc)
    6680. 

  6680.         {                              /* copy the values */
    6681. 

  6681.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 )  |  ( (*(pDataline+1)>>5   )     ) );
    6682. 

  6682.           *pScanline     = (mng_uint8)( (  *(pDataline+2) >>3 )  |  ( (*(pDataline+1)&0xFC ) << 3) );
    6683. 

  6683.           *(pScanline+2) = *(pDataline+3);
    6684. 

  6684. 

  6685.           pScanline += (pData->iColinc * 3);
    6686. 

  6686.           pDataline += 4;
    6687. 

  6687.         }
    6688. 

  6688.       }
    6689. 

  6689.     }
    6690. 

  6690.     else
    6691. 

  6691.     {
    6692. 

  6692.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6693. 

  6693.       {
    6694. 

  6694.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6695. 

  6695.              iX += pData->iColinc)
    6696. 

  6696.         {                              /* get alpha values */
    6697. 

  6697.           iFGa16 = mng_get_uint16 (pDataline+6);
    6698. 

  6698.           iBGa16 = (mng_uint16)(*(pScanline+2));
    6699. 

  6699.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    6700. 

  6700. 

  6701.           if (iFGa16)                  /* any opacity at all ? */
    6702. 

  6702.           {                            /* fully opaque or background fully transparent ? */
    6703. 

  6703.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    6704. 

  6704.             {                          /* plain copy it */
    6705. 

  6705.               *(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 )  |  (mng_uint8)( (*(pDataline+2)>>5  )     );
    6706. 

  6706.               *pScanline     = (mng_uint8)( (*(pDataline+4)) >>3)  |  (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    6707. 

  6707. 			  *(pScanline+2) = *(pDataline+6);
    6708. 

  6708.             }
    6709. 

  6709.             else
    6710. 

  6710.             {
    6711. 

  6711.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    6712. 

  6712.               {                        /* get the proper values */
    6713. 

  6713.                 iFGr16 = mng_get_uint16 (pDataline  );
    6714. 

  6714.                 iFGg16 = mng_get_uint16 (pDataline+2);
    6715. 

  6715.                 iFGb16 = mng_get_uint16 (pDataline+4);
    6716. 

  6716.                                        /* scale background up */
    6717. 

  6717.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    6718. 

  6718.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    6719. 

  6719.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    6720. 

  6720. 

  6721. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6722. 

  6722.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6723. 

  6723.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6724. 

  6724. 

  6725.                                        /* now compose */
    6726. 

  6726.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    6727. 

  6727.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    6728. 

  6728.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    6729. 

  6729.                                        /* and return the composed values */
    6730. 

  6730.                 *(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 )  |  ( (mng_uint8)(iFGg16>>8) >> 5)      );
    6731. 

  6731.                 *pScanline     = (mng_uint8) ( ( (iFGb16>>11)       )  |  (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    6732. 

  6732.               }
    6733. 

  6733.               else
    6734. 

  6734.               {                        /* scale background up */
    6735. 

  6735.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    6736. 

  6736.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    6737. 

  6737.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    6738. 

  6738. 

  6739. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6740. 

  6740.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6741. 

  6741.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6742. 

  6742.                                        /* let's blend */
    6743. 

  6743.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    6744. 

  6744.                              mng_get_uint16 (pDataline+2),
    6745. 

  6745.                              mng_get_uint16 (pDataline+4), iFGa16,
    6746. 

  6746.                              iBGr16, iBGg16, iBGb16, iBGa16,
    6747. 

  6747.                              iCr16,  iCg16,  iCb16,  iCa16);
    6748. 

  6748.                                        /* and return the composed values */
    6749. 

  6749.                 *(pScanline+1) = (mng_uint8) ( ( (iCr16 >>  8) & 0xF8 )  |  ( (mng_uint8)(iCg16 >> 8) >> 5  )       );
    6750. 

  6750.                 *pScanline     = (mng_uint8) ( ( (iCb16 >> 11)        )  |  (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
    6751. 

  6751.                 *(pScanline+2) = (mng_uint8)(iCa16 >> 8);
    6752. 

  6752.               }
    6753. 

  6753.             }
    6754. 

  6754.           }
    6755. 

  6755. 

  6756.           pScanline += (pData->iColinc * 3);
    6757. 

  6757.           pDataline += 8;
    6758. 

  6758.         }
    6759. 

  6759.       }
    6760. 

  6760.       else
    6761. 

  6761.       {
    6762. 

  6762.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6763. 

  6763.              iX += pData->iColinc)
    6764. 

  6764.         {
    6765. 

  6765.           iFGa8 = *(pDataline+3);      /* get alpha values */
    6766. 

  6766.           iBGa8 = *(pScanline+2);
    6767. 

  6767. 

  6768.           if (iFGa8)                   /* any opacity at all ? */
    6769. 

  6769.           {                            /* fully opaque or background fully transparent ? */
    6770. 

  6770.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    6771. 

  6771.             {                          /* then simply copy the values */
    6772. 

  6772.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    6773. 

  6773.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    6774. 

  6774.               *(pScanline+2) = *(pDataline+3);
    6775. 

  6775.             }
    6776. 

  6776.             else
    6777. 

  6777.             {
    6778. 

  6778.               mng_uint8 iRed, iGreen, iBlue;
    6779. 

  6779. 

  6780.               iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    6781. 

  6781.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    6782. 

  6782.               iBlue  = (mng_uint8) ( (*pScanline << 3) );
    6783. 

  6783. 

  6784.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    6785. 

  6785.               {                        /* do alpha composing */
    6786. 

  6786.                 MNG_COMPOSE8 (iRed,   *pDataline,     iFGa8, iRed   );
    6787. 

  6787.                 MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
    6788. 

  6788.                 MNG_COMPOSE8 (iBlue,  *(pDataline+2), iFGa8, iBlue  );
    6789. 

  6789.                                        /* alpha remains fully opaque !!! */
    6790. 

  6790.                 *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  |   (iGreen>>5) );
    6791. 

  6791.                 *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ( (iGreen & 0xFC) << 3) );
    6792. 

  6792.               }
    6793. 

  6793.               else
    6794. 

  6794.               {                        /* now blend */
    6795. 

  6795.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    6796. 

  6796.                             iRed      , iGreen        , iBlue         , iBGa8,
    6797. 

  6797.                             iCr8, iCg8, iCb8, iCa8);
    6798. 

  6798.                                        /* and return the composed values */
    6799. 

  6799. 

  6800. 

  6801.                 *pScanline     = (mng_uint8) ( ( iCb8 >>  3  )  | ( (iCg8 & 0xFC) << 3) );
    6802. 

  6802.                 *(pScanline+1) = (mng_uint8) ( ( iCr8  & 0xF8 )  |   (iCg8>>5) );
    6803. 

  6803. 				*(pScanline+2) = (mng_uint8) iCa8;
    6804. 

  6804.               }
    6805. 

  6805.             }
    6806. 

  6806.           }
    6807. 

  6807. 

  6808.           pScanline += (pData->iColinc *3);
    6809. 

  6809.           pDataline += 4;
    6810. 

  6810.         }
    6811. 

  6811.       }
    6812. 

  6812.     }
    6813. 

  6813.   }
    6814. 

  6814. 

  6815.   check_update_region (pData);
    6816. 

  6816. 

  6817. #ifdef MNG_SUPPORT_TRACE
    6818. 

  6818.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
    6819. 

  6819. #endif
    6820. 

  6820. 

  6821.   return MNG_NOERROR;
    6822. 

  6822. }
    6823. 

  6823. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    6824. 

  6824. mng_retcode mng_display_bgra565 (mng_datap pData)
    6825. 

  6825. {
    6826. 

  6826.   mng_uint8p pScanline;
    6827. 

  6827.   mng_uint8p pDataline;
    6828. 

  6828.   mng_int32  iX;
    6829. 

  6829.   mng_uint8  iFGa8, iBGa8, iCa8;
    6830. 

  6830.   mng_uint16 iFGa16, iBGa16, iCa16;
    6831. 

  6831.   mng_uint16 iFGr16, iFGg16, iFGb16;
    6832. 

  6832.   mng_uint16 iBGr16, iBGg16, iBGb16;
    6833. 

  6833.   mng_uint16 iCr16, iCg16, iCb16;
    6834. 

  6834.   mng_uint8  iCr8, iCg8, iCb8;
    6835. 

  6835.   mng_uint8  iBps;
    6836. 

  6836. 

  6837. #ifdef MNG_SUPPORT_TRACE
    6838. 

  6838.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
    6839. 

  6839. #endif
    6840. 

  6840. 

  6841.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    6842. 

  6842.                                        /* viewable row ? */
    6843. 

  6843.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    6844. 

  6844.   {                                    /* address destination row */
    6845. 

  6845.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    6846. 

  6846.                                                    pData->iRow + pData->iDestt -
    6847. 

  6847.                                                    pData->iSourcet);
    6848. 

  6848.                                        /* adjust destination row starting-point */
    6849. 

  6849.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
    6850. 

  6850.     pDataline = pData->pRGBArow;       /* address source row */
    6851. 

  6851. 

  6852.     /* adjust source row starting-point */
    6853. 

  6853.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    6854. 

  6854. 

  6855.     if (pData->bIsOpaque)              /* forget about transparency ? */
    6856. 

  6856.     {
    6857. 

  6857.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6858. 

  6858.              iX += pData->iColinc)
    6859. 

  6859.         {                              /* scale down by dropping the LSB */
    6860. 

  6860.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) |
    6861. 

  6861.               (   (*(pDataline+iBps)>>5)       ) );
    6862. 

  6862.           *pScanline     = (mng_uint8)( ( (*(pDataline+2*iBps)) >>3) |
    6863. 

  6863.               (   (*(pDataline+iBps)&0xFC) << 3) );
    6864. 

  6864.           *(pScanline+2) = *(pDataline+3*iBps);
    6865. 

  6865. 

  6866.           pScanline += (pData->iColinc * 3);
    6867. 

  6867.           pDataline += 4*iBps;
    6868. 

  6868.         }
    6869. 

  6869.     }
    6870. 

  6870.     else
    6871. 

  6871.     {
    6872. 

  6872.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    6873. 

  6873.       {
    6874. 

  6874.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6875. 

  6875.              iX += pData->iColinc)
    6876. 

  6876.         {                              /* get alpha values */
    6877. 

  6877.           iFGa16 = mng_get_uint16 (pDataline+6);
    6878. 

  6878.           iBGa16 = (mng_uint16)(*(pScanline+2));
    6879. 

  6879.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    6880. 

  6880. 

  6881.           if (iFGa16)                  /* any opacity at all ? */
    6882. 

  6882.           {                            /* fully opaque or background fully transparent ? */
    6883. 

  6883.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    6884. 

  6884.             {                          /* plain copy it */
    6885. 

  6885.               *(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 )  |  (mng_uint8)( (*(pDataline+2)>>5  )     );
    6886. 

  6886.               *pScanline     = (mng_uint8)( (*(pDataline+4)) >>3)  |  (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    6887. 

  6887. 			  *(pScanline+2) = *(pDataline+6);
    6888. 

  6888.             }
    6889. 

  6889.             else
    6890. 

  6890.             {
    6891. 

  6891.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    6892. 

  6892.               {                        /* get the proper values */
    6893. 

  6893.                 iFGr16 = mng_get_uint16 (pDataline  );
    6894. 

  6894.                 iFGg16 = mng_get_uint16 (pDataline+2);
    6895. 

  6895.                 iFGb16 = mng_get_uint16 (pDataline+4);
    6896. 

  6896.                                        /* scale background up */
    6897. 

  6897.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    6898. 

  6898.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    6899. 

  6899.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    6900. 

  6900. 

  6901. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6902. 

  6902.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6903. 

  6903.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6904. 

  6904. 

  6905.                                        /* now compose */
    6906. 

  6906.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    6907. 

  6907.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    6908. 

  6908.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    6909. 

  6909.                                        /* and return the composed values */
    6910. 

  6910.                 *(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 )  |  ( (mng_uint8)(iFGg16>>8) >> 5)      );
    6911. 

  6911.                 *pScanline     = (mng_uint8) ( ( (iFGb16>>11)       )  |  (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    6912. 

  6912.               }
    6913. 

  6913.               else
    6914. 

  6914.               {                        /* scale background up */
    6915. 

  6915.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    6916. 

  6916.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    6917. 

  6917.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    6918. 

  6918. 

  6919. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    6920. 

  6920.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    6921. 

  6921.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    6922. 

  6922.                                        /* let's blend */
    6923. 

  6923.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    6924. 

  6924.                              mng_get_uint16 (pDataline+2),
    6925. 

  6925.                              mng_get_uint16 (pDataline+4), iFGa16,
    6926. 

  6926.                              iBGr16, iBGg16, iBGb16, iBGa16,
    6927. 

  6927.                              iCr16,  iCg16,  iCb16,  iCa16);
    6928. 

  6928.                                        /* and return the composed values */
    6929. 

  6929.                 *(pScanline+1) = (mng_uint8) ( ( (iCr16 >>  8) & 0xF8 )  |  ( (mng_uint8)(iCg16 >> 8) >> 5  )       );
    6930. 

  6930.                 *pScanline     = (mng_uint8) ( ( (iCb16 >> 11)        )  |  (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
    6931. 

  6931.                 *(pScanline+2) = (mng_uint8)(iCa16 >> 8);
    6932. 

  6932.               }
    6933. 

  6933.             }
    6934. 

  6934.           }
    6935. 

  6935. 

  6936.           pScanline += (pData->iColinc * 3);
    6937. 

  6937.           pDataline += 8;
    6938. 

  6938.         }
    6939. 

  6939.       }
    6940. 

  6940.       else
    6941. 

  6941.       {
    6942. 

  6942.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    6943. 

  6943.              iX += pData->iColinc)
    6944. 

  6944.         {
    6945. 

  6945.           iFGa8 = *(pDataline+3);      /* get alpha values */
    6946. 

  6946.           iBGa8 = *(pScanline+2);
    6947. 

  6947. 

  6948.           if (iFGa8)                   /* any opacity at all ? */
    6949. 

  6949.           {                            /* fully opaque or background fully transparent ? */
    6950. 

  6950.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    6951. 

  6951.             {                          /* then simply copy the values */
    6952. 

  6952.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    6953. 

  6953.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    6954. 

  6954.               *(pScanline+2) = *(pDataline+3);
    6955. 

  6955.             }
    6956. 

  6956.             else
    6957. 

  6957.             {
    6958. 

  6958.               mng_uint8 iRed, iGreen, iBlue;
    6959. 

  6959. 

  6960.               iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    6961. 

  6961.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    6962. 

  6962.               iBlue  = (mng_uint8) ( (*pScanline << 3) );
    6963. 

  6963. 

  6964.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    6965. 

  6965.               {                        /* do alpha composing */
    6966. 

  6966.                 MNG_COMPOSE8 (iRed,   *pDataline,     iFGa8, iRed   );
    6967. 

  6967.                 MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
    6968. 

  6968.                 MNG_COMPOSE8 (iBlue,  *(pDataline+2), iFGa8, iBlue  );
    6969. 

  6969.                                        /* alpha remains fully opaque !!! */
    6970. 

  6970.                 *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  |   (iGreen>>5) );
    6971. 

  6971.                 *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ( (iGreen & 0xFC) << 3) );
    6972. 

  6972.               }
    6973. 

  6973.               else
    6974. 

  6974.               {                        /* now blend */
    6975. 

  6975.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    6976. 

  6976.                             iRed      , iGreen        , iBlue         , iBGa8,
    6977. 

  6977.                             iCr8, iCg8, iCb8, iCa8);
    6978. 

  6978.                                        /* and return the composed values */
    6979. 

  6979. 

  6980. 

  6981.                 *pScanline     = (mng_uint8) ( ( iCb8 >>  3  )  | ( (iCg8 & 0xFC) << 3) );
    6982. 

  6982.                 *(pScanline+1) = (mng_uint8) ( ( iCr8  & 0xF8 )  |   (iCg8>>5) );
    6983. 

  6983. 				*(pScanline+2) = (mng_uint8) iCa8;
    6984. 

  6984.               }
    6985. 

  6985.             }
    6986. 

  6986.           }
    6987. 

  6987. 

  6988.           pScanline += (pData->iColinc *3);
    6989. 

  6989.           pDataline += 4;
    6990. 

  6990.         }
    6991. 

  6991.       }
    6992. 

  6992.     }
    6993. 

  6993.   }
    6994. 

  6994. 

  6995.   check_update_region (pData);
    6996. 

  6996. 

  6997. #ifdef MNG_SUPPORT_TRACE
    6998. 

  6998.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
    6999. 

  6999. #endif
    7000. 

  7000. 

  7001.   return MNG_NOERROR;
    7002. 

  7002. }
    7003. 

  7003. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    7004. 

  7004. #else /* MNG_NO_16BIT_SUPPORT */
    7005. 

  7005. mng_retcode mng_display_bgra565 (mng_datap pData)
    7006. 

  7006. {
    7007. 

  7007.   mng_uint8p pScanline;
    7008. 

  7008.   mng_uint8p pDataline;
    7009. 

  7009.   mng_int32  iX;
    7010. 

  7010.   mng_uint8  iFGa8, iBGa8, iCa8;
    7011. 

  7011.   mng_uint8  iCr8, iCg8, iCb8;
    7012. 

  7012. 

  7013. #ifdef MNG_SUPPORT_TRACE
    7014. 

  7014.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_START);
    7015. 

  7015. #endif
    7016. 

  7016.                                        /* viewable row ? */
    7017. 

  7017.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    7018. 

  7018.   {                                    /* address destination row */
    7019. 

  7019.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    7020. 

  7020.                                                    pData->iRow + pData->iDestt -
    7021. 

  7021.                                                    pData->iSourcet);
    7022. 

  7022.                                        /* adjust destination row starting-point */
    7023. 

  7023.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
    7024. 

  7024.     pDataline = pData->pRGBArow;       /* address source row */
    7025. 

  7025. 

  7026.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    7027. 

  7027. 

  7028.     if (pData->bIsOpaque)              /* forget about transparency ? */
    7029. 

  7029.     {
    7030. 

  7030.       {
    7031. 

  7031.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7032. 

  7032.              iX += pData->iColinc)
    7033. 

  7033.         {                              /* copy the values */
    7034. 

  7034.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 )  |  ( (*(pDataline+1)>>5   )     ) );
    7035. 

  7035.           *pScanline     = (mng_uint8)( (  *(pDataline+2) >>3 )  |  ( (*(pDataline+1)&0xFC ) << 3) );
    7036. 

  7036.           *(pScanline+2) = *(pDataline+3);
    7037. 

  7037. 

  7038.           pScanline += (pData->iColinc * 3);
    7039. 

  7039.           pDataline += 4;
    7040. 

  7040.         }
    7041. 

  7041.       }
    7042. 

  7042.     }
    7043. 

  7043.     else
    7044. 

  7044.     {
    7045. 

  7045.       {
    7046. 

  7046.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7047. 

  7047.              iX += pData->iColinc)
    7048. 

  7048.         {
    7049. 

  7049.           iFGa8 = *(pDataline+3);      /* get alpha values */
    7050. 

  7050.           iBGa8 = *(pScanline+2);
    7051. 

  7051. 

  7052.           if (iFGa8)                   /* any opacity at all ? */
    7053. 

  7053.           {                            /* fully opaque or background fully transparent ? */
    7054. 

  7054.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    7055. 

  7055.             {                          /* then simply copy the values */
    7056. 

  7056.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    7057. 

  7057.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    7058. 

  7058.               *(pScanline+2) = *(pDataline+3);
    7059. 

  7059.             }
    7060. 

  7060.             else
    7061. 

  7061.             {
    7062. 

  7062.               mng_uint8 iRed, iGreen, iBlue;
    7063. 

  7063. 

  7064.               iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    7065. 

  7065.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    7066. 

  7066.               iBlue  = (mng_uint8) ( (*pScanline << 3) );
    7067. 

  7067. 

  7068.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    7069. 

  7069.               {                        /* do alpha composing */
    7070. 

  7070.                 MNG_COMPOSE8 (iRed,   *pDataline,     iFGa8, iRed   );
    7071. 

  7071.                 MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
    7072. 

  7072.                 MNG_COMPOSE8 (iBlue,  *(pDataline+2), iFGa8, iBlue  );
    7073. 

  7073.                                        /* alpha remains fully opaque !!! */
    7074. 

  7074.                 *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  |   (iGreen>>5) );
    7075. 

  7075.                 *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ( (iGreen & 0xFC) << 3) );
    7076. 

  7076.               }
    7077. 

  7077.               else
    7078. 

  7078.               {                        /* now blend */
    7079. 

  7079.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    7080. 

  7080.                             iRed      , iGreen        , iBlue         , iBGa8,
    7081. 

  7081.                             iCr8, iCg8, iCb8, iCa8);
    7082. 

  7082.                                        /* and return the composed values */
    7083. 

  7083. 

  7084. 

  7085.                 *pScanline     = (mng_uint8) ( ( iCb8 >>  3  )  | ( (iCg8 & 0xFC) << 3) );
    7086. 

  7086.                 *(pScanline+1) = (mng_uint8) ( ( iCr8  & 0xF8 )  |   (iCg8>>5) );
    7087. 

  7087. 				*(pScanline+2) = (mng_uint8) iCa8;
    7088. 

  7088.               }
    7089. 

  7089.             }
    7090. 

  7090.           }
    7091. 

  7091. 

  7092.           pScanline += (pData->iColinc *3);
    7093. 

  7093.           pDataline += 4;
    7094. 

  7094.         }
    7095. 

  7095.       }
    7096. 

  7096.     }
    7097. 

  7097.   }
    7098. 

  7098. 

  7099.   check_update_region (pData);
    7100. 

  7100. 

  7101. #ifdef MNG_SUPPORT_TRACE
    7102. 

  7102.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGRA565, MNG_LC_END);
    7103. 

  7103. #endif
    7104. 

  7104. 

  7105.   return MNG_NOERROR;
    7106. 

  7106. }
    7107. 

  7107. #endif /* MNG_NO_16BIT_SUPPORT */
    7108. 

  7108. #endif /* MNG_SKIPCANVAS_BGRA565 */
    7109. 

  7109. 

  7110. /* ************************************************************************** */
    7111. 

  7111. 

  7112. #ifndef MNG_SKIPCANVAS_RGBA565
    7113. 

  7113. #ifndef MNG_NO_16BIT_SUPPORT
    7114. 

  7114. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    7115. 

  7115. mng_retcode mng_display_rgba565 (mng_datap pData)
    7116. 

  7116. {
    7117. 

  7117.   mng_uint8p pScanline;
    7118. 

  7118.   mng_uint8p pDataline;
    7119. 

  7119.   mng_int32  iX;
    7120. 

  7120.   mng_uint8  iFGa8, iBGa8, iCa8;
    7121. 

  7121.   mng_uint16 iFGa16, iBGa16, iCa16;
    7122. 

  7122.   mng_uint16 iFGr16, iFGg16, iFGb16;
    7123. 

  7123.   mng_uint16 iBGr16, iBGg16, iBGb16;
    7124. 

  7124.   mng_uint16 iCr16, iCg16, iCb16;
    7125. 

  7125.   mng_uint8  iCr8, iCg8, iCb8;
    7126. 

  7126. 

  7127. #ifdef MNG_SUPPORT_TRACE
    7128. 

  7128.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
    7129. 

  7129. #endif
    7130. 

  7130.                                        /* viewable row ? */
    7131. 

  7131.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    7132. 

  7132.   {                                    /* address destination row */
    7133. 

  7133.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    7134. 

  7134.                                                    pData->iRow + pData->iDestt -
    7135. 

  7135.                                                    pData->iSourcet);
    7136. 

  7136.                                        /* adjust destination row starting-point */
    7137. 

  7137.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
    7138. 

  7138.     pDataline = pData->pRGBArow;       /* address source row */
    7139. 

  7139. 

  7140.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    7141. 

  7141.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    7142. 

  7142.     else
    7143. 

  7143.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    7144. 

  7144. 

  7145.     if (pData->bIsOpaque)              /* forget about transparency ? */
    7146. 

  7146.     {
    7147. 

  7147.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    7148. 

  7148.       {
    7149. 

  7149.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7150. 

  7150.              iX += pData->iColinc)
    7151. 

  7151.         {                              /* scale down by dropping the LSB */
    7152. 

  7152.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline+4))&0xF8 ) | (   (*(pDataline+2)>>5)       ) );
    7153. 

  7153.           *pScanline     = (mng_uint8)( ( (*(pDataline)) >>3) | (   (*(pDataline+2)&0xFC) << 3) );
    7154. 

  7154.           *(pScanline+2) = *(pDataline+6);
    7155. 

  7155. 

  7156.           pScanline += (pData->iColinc * 3);
    7157. 

  7157.           pDataline += 8;
    7158. 

  7158.         }
    7159. 

  7159.       }
    7160. 

  7160.       else
    7161. 

  7161.       {
    7162. 

  7162.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7163. 

  7163.              iX += pData->iColinc)
    7164. 

  7164.         {                              /* copy the values */
    7165. 

  7165.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2))&0xF8 )  |  ( (*(pDataline+1)>>5   )     ) );
    7166. 

  7166.           *pScanline     = (mng_uint8)( (  *(pDataline) >>3 )  |  ( (*(pDataline+1)&0xFC ) << 3) );
    7167. 

  7167.           *(pScanline+2) = *(pDataline+3);
    7168. 

  7168. 

  7169.           pScanline += (pData->iColinc * 3);
    7170. 

  7170.           pDataline += 4;
    7171. 

  7171.         }
    7172. 

  7172.       }
    7173. 

  7173.     }
    7174. 

  7174.     else
    7175. 

  7175.     {
    7176. 

  7176.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    7177. 

  7177.       {
    7178. 

  7178.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7179. 

  7179.              iX += pData->iColinc)
    7180. 

  7180.         {                              /* get alpha values */
    7181. 

  7181.           iFGa16 = mng_get_uint16 (pDataline+6);
    7182. 

  7182.           iBGa16 = (mng_uint16)(*(pScanline+2));
    7183. 

  7183.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    7184. 

  7184. 

  7185.           if (iFGa16)                  /* any opacity at all ? */
    7186. 

  7186.           {                            /* fully opaque or background fully transparent ? */
    7187. 

  7187.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    7188. 

  7188.             {                          /* plain copy it */
    7189. 

  7189.               *(pScanline+1) = (mng_uint8)( (*(pDataline+4))&0xF8 )  |  (mng_uint8)( (*(pDataline+2)>>5  )     );
    7190. 

  7190.               *pScanline     = (mng_uint8)( (*(pDataline)) >>3)  |  (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    7191. 

  7191. 			  *(pScanline+2) = *(pDataline+6);
    7192. 

  7192.             }
    7193. 

  7193.             else
    7194. 

  7194.             {
    7195. 

  7195.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    7196. 

  7196.               {                        /* get the proper values */
    7197. 

  7197.                 iFGr16 = mng_get_uint16 (pDataline  );
    7198. 

  7198.                 iFGg16 = mng_get_uint16 (pDataline+2);
    7199. 

  7199.                 iFGb16 = mng_get_uint16 (pDataline+4);
    7200. 

  7200.                                        /* scale background up */
    7201. 

  7201.                 iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7202. 

  7202.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    7203. 

  7203.                 iBGb16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7204. 

  7204. 

  7205. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7206. 

  7206.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7207. 

  7207.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7208. 

  7208. 

  7209.                                        /* now compose */
    7210. 

  7210.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    7211. 

  7211.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    7212. 

  7212.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    7213. 

  7213.                                        /* and return the composed values */
    7214. 

  7214.                 *(pScanline+1) = (mng_uint8) ( ( (iFGb16 >> 8)&0xF8 )  |  ( (mng_uint8)(iFGg16>>8) >> 5)      );
    7215. 

  7215.                 *pScanline     = (mng_uint8) ( ( (iFGr16>>11)       )  |  (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    7216. 

  7216.               }
    7217. 

  7217.               else
    7218. 

  7218.               {                        /* scale background up */
    7219. 

  7219.                 iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7220. 

  7220.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    7221. 

  7221.                 iBGb16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7222. 

  7222. 

  7223. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7224. 

  7224.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7225. 

  7225.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7226. 

  7226.                                        /* let's blend */
    7227. 

  7227.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    7228. 

  7228.                              mng_get_uint16 (pDataline+2),
    7229. 

  7229.                              mng_get_uint16 (pDataline+4), iFGa16,
    7230. 

  7230.                              iBGr16, iBGg16, iBGb16, iBGa16,
    7231. 

  7231.                              iCr16,  iCg16,  iCb16,  iCa16);
    7232. 

  7232.                                        /* and return the composed values */
    7233. 

  7233.                 *(pScanline+1) = (mng_uint8) ( ( (iCb16 >>  8) & 0xF8 )  |  ( (mng_uint8)(iCg16 >> 8) >> 5  )       );
    7234. 

  7234.                 *pScanline     = (mng_uint8) ( ( (iCr16 >> 11)        )  |  (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
    7235. 

  7235.                 *(pScanline+2) = (mng_uint8)(iCa16 >> 8);
    7236. 

  7236.               }
    7237. 

  7237.             }
    7238. 

  7238.           }
    7239. 

  7239. 

  7240.           pScanline += (pData->iColinc * 3);
    7241. 

  7241.           pDataline += 8;
    7242. 

  7242.         }
    7243. 

  7243.       }
    7244. 

  7244.       else
    7245. 

  7245.       {
    7246. 

  7246.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7247. 

  7247.              iX += pData->iColinc)
    7248. 

  7248.         {
    7249. 

  7249.           iFGa8 = *(pDataline+3);      /* get alpha values */
    7250. 

  7250.           iBGa8 = *(pScanline+2);
    7251. 

  7251. 

  7252.           if (iFGa8)                   /* any opacity at all ? */
    7253. 

  7253.           {                            /* fully opaque or background fully transparent ? */
    7254. 

  7254.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    7255. 

  7255.             {                          /* then simply copy the values */
    7256. 

  7256.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline+2)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    7257. 

  7257.               *pScanline     = (mng_uint8)( ( ((*(pDataline))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    7258. 

  7258.               *(pScanline+2) = *(pDataline+3);
    7259. 

  7259.             }
    7260. 

  7260.             else
    7261. 

  7261.             {
    7262. 

  7262.               mng_uint8 iRed, iGreen, iBlue;
    7263. 

  7263. 

  7264.               iBlue   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    7265. 

  7265.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    7266. 

  7266.               iRed  = (mng_uint8) ( (*pScanline << 3) );
    7267. 

  7267. 

  7268.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    7269. 

  7269.               {                        /* do alpha composing */
    7270. 

  7270.                 MNG_COMPOSE8 (iRed,   *pDataline,     iFGa8, iRed   );
    7271. 

  7271.                 MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
    7272. 

  7272.                 MNG_COMPOSE8 (iBlue,  *(pDataline+2), iFGa8, iBlue  );
    7273. 

  7273.                                        /* alpha remains fully opaque !!! */
    7274. 

  7274.                 *(pScanline+1) = (mng_uint8) ( ( iBlue  & 0xF8 )  |   (iGreen>>5) );
    7275. 

  7275.                 *pScanline     = (mng_uint8) ( ( iRed >>  3  )  | ( (iGreen & 0xFC) << 3) );
    7276. 

  7276.               }
    7277. 

  7277.               else
    7278. 

  7278.               {                        /* now blend */
    7279. 

  7279.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    7280. 

  7280.                             iRed      , iGreen        , iBlue         , iBGa8,
    7281. 

  7281.                             iCr8, iCg8, iCb8, iCa8);
    7282. 

  7282.                                        /* and return the composed values */
    7283. 

  7283. 

  7284. 

  7285.                 *pScanline     = (mng_uint8) ( ( iCr8 >>  3  )  | ( (iCg8 & 0xFC) << 3) );
    7286. 

  7286.                 *(pScanline+1) = (mng_uint8) ( ( iCb8  & 0xF8 )  |   (iCg8>>5) );
    7287. 

  7287. 				*(pScanline+2) = (mng_uint8) iCa8;
    7288. 

  7288.               }
    7289. 

  7289.             }
    7290. 

  7290.           }
    7291. 

  7291. 

  7292.           pScanline += (pData->iColinc *3);
    7293. 

  7293.           pDataline += 4;
    7294. 

  7294.         }
    7295. 

  7295.       }
    7296. 

  7296.     }
    7297. 

  7297.   }
    7298. 

  7298. 

  7299.   check_update_region (pData);
    7300. 

  7300. 

  7301. #ifdef MNG_SUPPORT_TRACE
    7302. 

  7302.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
    7303. 

  7303. #endif
    7304. 

  7304. 

  7305.   return MNG_NOERROR;
    7306. 

  7306. }
    7307. 

  7307. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    7308. 

  7308. mng_retcode mng_display_rgba565 (mng_datap pData)
    7309. 

  7309. {
    7310. 

  7310.   mng_uint8p pScanline;
    7311. 

  7311.   mng_uint8p pDataline;
    7312. 

  7312.   mng_int32  iX;
    7313. 

  7313.   mng_uint8  iFGa8, iBGa8, iCa8;
    7314. 

  7314.   mng_uint16 iFGa16, iBGa16, iCa16;
    7315. 

  7315.   mng_uint16 iFGr16, iFGg16, iFGb16;
    7316. 

  7316.   mng_uint16 iBGr16, iBGg16, iBGb16;
    7317. 

  7317.   mng_uint16 iCr16, iCg16, iCb16;
    7318. 

  7318.   mng_uint8  iCr8, iCg8, iCb8;
    7319. 

  7319.   mng_uint8  iBps;
    7320. 

  7320. 

  7321. #ifdef MNG_SUPPORT_TRACE
    7322. 

  7322.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
    7323. 

  7323. #endif
    7324. 

  7324. 

  7325.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    7326. 

  7326.                                        /* viewable row ? */
    7327. 

  7327.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    7328. 

  7328.   {                                    /* address destination row */
    7329. 

  7329.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    7330. 

  7330.                                                    pData->iRow + pData->iDestt -
    7331. 

  7331.                                                    pData->iSourcet);
    7332. 

  7332.                                        /* adjust destination row starting-point */
    7333. 

  7333.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
    7334. 

  7334.     pDataline = pData->pRGBArow;       /* address source row */
    7335. 

  7335. 

  7336.     /* adjust source row starting-point */
    7337. 

  7337.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    7338. 

  7338. 

  7339.     if (pData->bIsOpaque)              /* forget about transparency ? */
    7340. 

  7340.     {
    7341. 

  7341.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7342. 

  7342.              iX += pData->iColinc)
    7343. 

  7343.         {                              /* scale down by dropping the LSB */
    7344. 

  7344.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2*iBps))&0xF8 ) |
    7345. 

  7345.              (   (*(pDataline+iBps)>>5)       ) );
    7346. 

  7346.           *pScanline     = (mng_uint8)( ( (*(pDataline)) >>3) |
    7347. 

  7347.              (   (*(pDataline+iBps)&0xFC) << 3) );
    7348. 

  7348.           *(pScanline+2) = *(pDataline+3*iBps);
    7349. 

  7349. 

  7350.           pScanline += (pData->iColinc * 3);
    7351. 

  7351.           pDataline += 4*iBps;
    7352. 

  7352.         }
    7353. 

  7353.     }
    7354. 

  7354.     else
    7355. 

  7355.     {
    7356. 

  7356.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    7357. 

  7357.       {
    7358. 

  7358.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7359. 

  7359.              iX += pData->iColinc)
    7360. 

  7360.         {                              /* get alpha values */
    7361. 

  7361.           iFGa16 = mng_get_uint16 (pDataline+6);
    7362. 

  7362.           iBGa16 = (mng_uint16)(*(pScanline+2));
    7363. 

  7363.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    7364. 

  7364. 

  7365.           if (iFGa16)                  /* any opacity at all ? */
    7366. 

  7366.           {                            /* fully opaque or background fully transparent ? */
    7367. 

  7367.             if ((iFGa16 == 0xFFFF) || (iBGa16 == 0))
    7368. 

  7368.             {                          /* plain copy it */
    7369. 

  7369.               *(pScanline+1) = (mng_uint8)( (*(pDataline+4))&0xF8 )  |  (mng_uint8)( (*(pDataline+2)>>5  )     );
    7370. 

  7370.               *pScanline     = (mng_uint8)( (*(pDataline)) >>3)  |  (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    7371. 

  7371. 			  *(pScanline+2) = *(pDataline+6);
    7372. 

  7372.             }
    7373. 

  7373.             else
    7374. 

  7374.             {
    7375. 

  7375.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    7376. 

  7376.               {                        /* get the proper values */
    7377. 

  7377.                 iFGr16 = mng_get_uint16 (pDataline  );
    7378. 

  7378.                 iFGg16 = mng_get_uint16 (pDataline+2);
    7379. 

  7379.                 iFGb16 = mng_get_uint16 (pDataline+4);
    7380. 

  7380.                                        /* scale background up */
    7381. 

  7381.                 iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7382. 

  7382.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    7383. 

  7383.                 iBGb16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7384. 

  7384. 

  7385. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7386. 

  7386.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7387. 

  7387.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7388. 

  7388. 

  7389.                                        /* now compose */
    7390. 

  7390.                 MNG_COMPOSE16(iFGr16, iFGr16, iFGa16, iBGr16);
    7391. 

  7391.                 MNG_COMPOSE16(iFGg16, iFGg16, iFGa16, iBGg16);
    7392. 

  7392.                 MNG_COMPOSE16(iFGb16, iFGb16, iFGa16, iBGb16);
    7393. 

  7393.                                        /* and return the composed values */
    7394. 

  7394.                 *(pScanline+1) = (mng_uint8) ( ( (iFGb16 >> 8)&0xF8 )  |  ( (mng_uint8)(iFGg16>>8) >> 5)      );
    7395. 

  7395.                 *pScanline     = (mng_uint8) ( ( (iFGr16>>11)       )  |  (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    7396. 

  7396.               }
    7397. 

  7397.               else
    7398. 

  7398.               {                        /* scale background up */
    7399. 

  7399.                 iBGr16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7400. 

  7400.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  |  (((*(pScanline  )) & 0xE0) >>3 ) );
    7401. 

  7401.                 iBGb16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7402. 

  7402. 

  7403. 				iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7404. 

  7404.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7405. 

  7405.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7406. 

  7406.                                        /* let's blend */
    7407. 

  7407.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    7408. 

  7408.                              mng_get_uint16 (pDataline+2),
    7409. 

  7409.                              mng_get_uint16 (pDataline+4), iFGa16,
    7410. 

  7410.                              iBGr16, iBGg16, iBGb16, iBGa16,
    7411. 

  7411.                              iCr16,  iCg16,  iCb16,  iCa16);
    7412. 

  7412.                                        /* and return the composed values */
    7413. 

  7413.                 *(pScanline+1) = (mng_uint8) ( ( (iCb16 >>  8) & 0xF8 )  |  ( (mng_uint8)(iCg16 >> 8) >> 5  )       );
    7414. 

  7414.                 *pScanline     = (mng_uint8) ( ( (iCr16 >> 11)        )  |  (((mng_uint8)(iCg16 >> 8) & 0xFC) << 3) );
    7415. 

  7415.                 *(pScanline+2) = (mng_uint8)(iCa16 >> 8);
    7416. 

  7416.               }
    7417. 

  7417.             }
    7418. 

  7418.           }
    7419. 

  7419. 

  7420.           pScanline += (pData->iColinc * 3);
    7421. 

  7421.           pDataline += 8;
    7422. 

  7422.         }
    7423. 

  7423.       }
    7424. 

  7424.       else
    7425. 

  7425.       {
    7426. 

  7426.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7427. 

  7427.              iX += pData->iColinc)
    7428. 

  7428.         {
    7429. 

  7429.           iFGa8 = *(pDataline+3);      /* get alpha values */
    7430. 

  7430.           iBGa8 = *(pScanline+2);
    7431. 

  7431. 

  7432.           if (iFGa8)                   /* any opacity at all ? */
    7433. 

  7433.           {                            /* fully opaque or background fully transparent ? */
    7434. 

  7434.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    7435. 

  7435.             {                          /* then simply copy the values */
    7436. 

  7436.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline+2)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    7437. 

  7437.               *pScanline     = (mng_uint8)( ( ((*(pDataline))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    7438. 

  7438.               *(pScanline+2) = *(pDataline+3);
    7439. 

  7439.             }
    7440. 

  7440.             else
    7441. 

  7441.             {
    7442. 

  7442.               mng_uint8 iRed, iGreen, iBlue;
    7443. 

  7443. 

  7444.               iBlue   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    7445. 

  7445.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    7446. 

  7446.               iRed  = (mng_uint8) ( (*pScanline << 3) );
    7447. 

  7447. 

  7448.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    7449. 

  7449.               {                        /* do alpha composing */
    7450. 

  7450.                 MNG_COMPOSE8 (iRed,   *pDataline,     iFGa8, iRed   );
    7451. 

  7451.                 MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
    7452. 

  7452.                 MNG_COMPOSE8 (iBlue,  *(pDataline+2), iFGa8, iBlue  );
    7453. 

  7453.                                        /* alpha remains fully opaque !!! */
    7454. 

  7454.                 *(pScanline+1) = (mng_uint8) ( ( iBlue  & 0xF8 )  |   (iGreen>>5) );
    7455. 

  7455.                 *pScanline     = (mng_uint8) ( ( iRed >>  3  )  | ( (iGreen & 0xFC) << 3) );
    7456. 

  7456.               }
    7457. 

  7457.               else
    7458. 

  7458.               {                        /* now blend */
    7459. 

  7459.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    7460. 

  7460.                             iRed      , iGreen        , iBlue         , iBGa8,
    7461. 

  7461.                             iCr8, iCg8, iCb8, iCa8);
    7462. 

  7462.                                        /* and return the composed values */
    7463. 

  7463. 

  7464. 

  7465.                 *pScanline     = (mng_uint8) ( ( iCr8 >>  3  )  | ( (iCg8 & 0xFC) << 3) );
    7466. 

  7466.                 *(pScanline+1) = (mng_uint8) ( ( iCb8  & 0xF8 )  |   (iCg8>>5) );
    7467. 

  7467. 				*(pScanline+2) = (mng_uint8) iCa8;
    7468. 

  7468.               }
    7469. 

  7469.             }
    7470. 

  7470.           }
    7471. 

  7471. 

  7472.           pScanline += (pData->iColinc *3);
    7473. 

  7473.           pDataline += 4;
    7474. 

  7474.         }
    7475. 

  7475.       }
    7476. 

  7476.     }
    7477. 

  7477.   }
    7478. 

  7478. 

  7479.   check_update_region (pData);
    7480. 

  7480. 

  7481. #ifdef MNG_SUPPORT_TRACE
    7482. 

  7482.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
    7483. 

  7483. #endif
    7484. 

  7484. 

  7485.   return MNG_NOERROR;
    7486. 

  7486. }
    7487. 

  7487. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    7488. 

  7488. #else /* MNG_NO_16BIT_SUPPORT */
    7489. 

  7489. mng_retcode mng_display_rgba565 (mng_datap pData)
    7490. 

  7490. {
    7491. 

  7491.   mng_uint8p pScanline;
    7492. 

  7492.   mng_uint8p pDataline;
    7493. 

  7493.   mng_int32  iX;
    7494. 

  7494.   mng_uint8  iFGa8, iBGa8, iCa8;
    7495. 

  7495.   mng_uint8  iCr8, iCg8, iCb8;
    7496. 

  7496. 

  7497. #ifdef MNG_SUPPORT_TRACE
    7498. 

  7498.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_START);
    7499. 

  7499. #endif
    7500. 

  7500.                                        /* viewable row ? */
    7501. 

  7501.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    7502. 

  7502.   {                                    /* address destination row */
    7503. 

  7503.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    7504. 

  7504.                                                    pData->iRow + pData->iDestt -
    7505. 

  7505.                                                    pData->iSourcet);
    7506. 

  7506.                                        /* adjust destination row starting-point */
    7507. 

  7507.     pScanline = pScanline + (pData->iCol << 2) + (pData->iDestl * 3);
    7508. 

  7508.     pDataline = pData->pRGBArow;       /* address source row */
    7509. 

  7509. 

  7510.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    7511. 

  7511. 

  7512.     if (pData->bIsOpaque)              /* forget about transparency ? */
    7513. 

  7513.     {
    7514. 

  7514.       {
    7515. 

  7515.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7516. 

  7516.              iX += pData->iColinc)
    7517. 

  7517.         {                              /* copy the values */
    7518. 

  7518.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline+2))&0xF8 )  |  ( (*(pDataline+1)>>5   )     ) );
    7519. 

  7519.           *pScanline     = (mng_uint8)( (  *(pDataline) >>3 )  |  ( (*(pDataline+1)&0xFC ) << 3) );
    7520. 

  7520.           *(pScanline+2) = *(pDataline+3);
    7521. 

  7521. 

  7522.           pScanline += (pData->iColinc * 3);
    7523. 

  7523.           pDataline += 4;
    7524. 

  7524.         }
    7525. 

  7525.       }
    7526. 

  7526.     }
    7527. 

  7527.     else
    7528. 

  7528.     {
    7529. 

  7529.       {
    7530. 

  7530.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7531. 

  7531.              iX += pData->iColinc)
    7532. 

  7532.         {
    7533. 

  7533.           iFGa8 = *(pDataline+3);      /* get alpha values */
    7534. 

  7534.           iBGa8 = *(pScanline+2);
    7535. 

  7535. 

  7536.           if (iFGa8)                   /* any opacity at all ? */
    7537. 

  7537.           {                            /* fully opaque or background fully transparent ? */
    7538. 

  7538.             if ((iFGa8 == 0xFF) || (iBGa8 == 0))
    7539. 

  7539.             {                          /* then simply copy the values */
    7540. 

  7540.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline+2)) &0xF8 )  |   (*(pDataline+1) >>5 )       );
    7541. 

  7541.               *pScanline     = (mng_uint8)( ( ((*(pDataline))>>3) )  |  ((*(pDataline+1)&0xFC) << 3) );
    7542. 

  7542.               *(pScanline+2) = *(pDataline+3);
    7543. 

  7543.             }
    7544. 

  7544.             else
    7545. 

  7545.             {
    7546. 

  7546.               mng_uint8 iRed, iGreen, iBlue;
    7547. 

  7547. 

  7548.               iBlue   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    7549. 

  7549.               iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  ( ((*pScanline) & 0xE0)>>3 ) );
    7550. 

  7550.               iRed  = (mng_uint8) ( (*pScanline << 3) );
    7551. 

  7551. 

  7552.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    7553. 

  7553.               {                        /* do alpha composing */
    7554. 

  7554.                 MNG_COMPOSE8 (iRed,   *pDataline,     iFGa8, iRed   );
    7555. 

  7555.                 MNG_COMPOSE8 (iGreen, *(pDataline+1), iFGa8, iGreen );
    7556. 

  7556.                 MNG_COMPOSE8 (iBlue,  *(pDataline+2), iFGa8, iBlue  );
    7557. 

  7557.                                        /* alpha remains fully opaque !!! */
    7558. 

  7558.                 *(pScanline+1) = (mng_uint8) ( ( iBlue  & 0xF8 )  |   (iGreen>>5) );
    7559. 

  7559.                 *pScanline     = (mng_uint8) ( ( iRed >>  3  )  | ( (iGreen & 0xFC) << 3) );
    7560. 

  7560.               }
    7561. 

  7561.               else
    7562. 

  7562.               {                        /* now blend */
    7563. 

  7563.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iFGa8,
    7564. 

  7564.                             iRed      , iGreen        , iBlue         , iBGa8,
    7565. 

  7565.                             iCr8, iCg8, iCb8, iCa8);
    7566. 

  7566.                                        /* and return the composed values */
    7567. 

  7567. 

  7568. 

  7569.                 *pScanline     = (mng_uint8) ( ( iCr8 >>  3  )  | ( (iCg8 & 0xFC) << 3) );
    7570. 

  7570.                 *(pScanline+1) = (mng_uint8) ( ( iCb8  & 0xF8 )  |   (iCg8>>5) );
    7571. 

  7571. 				*(pScanline+2) = (mng_uint8) iCa8;
    7572. 

  7572.               }
    7573. 

  7573.             }
    7574. 

  7574.           }
    7575. 

  7575. 

  7576.           pScanline += (pData->iColinc *3);
    7577. 

  7577.           pDataline += 4;
    7578. 

  7578.         }
    7579. 

  7579.       }
    7580. 

  7580.     }
    7581. 

  7581.   }
    7582. 

  7582. 

  7583.   check_update_region (pData);
    7584. 

  7584. 

  7585. #ifdef MNG_SUPPORT_TRACE
    7586. 

  7586.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGBA565, MNG_LC_END);
    7587. 

  7587. #endif
    7588. 

  7588. 

  7589.   return MNG_NOERROR;
    7590. 

  7590. }
    7591. 

  7591. #endif /* MNG_NO_16BIT_SUPPORT */
    7592. 

  7592. #endif /* MNG_SKIPCANVAS_RGBA565 */
    7593. 

  7593. 

  7594. /* ************************************************************************** */
    7595. 

  7595. 

  7596. #ifndef MNG_SKIPCANVAS_BGR565_A8
    7597. 

  7597. #ifndef MNG_NO_16BIT_SUPPORT
    7598. 

  7598. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    7599. 

  7599. mng_retcode mng_display_bgr565_a8 (mng_datap pData)
    7600. 

  7600. {
    7601. 

  7601.   mng_uint8p pScanline;
    7602. 

  7602.   mng_uint8p pAlphaline;
    7603. 

  7603.   mng_uint8p pDataline;
    7604. 

  7604.   mng_int32  iX;
    7605. 

  7605.   mng_uint16 iA16;
    7606. 

  7606.   mng_uint16 iFGr16, iFGg16, iFGb16;
    7607. 

  7607.   mng_uint16 iBGr16, iBGg16, iBGb16, iBGa16;
    7608. 

  7608.   mng_uint16 iCr16,  iCg16,  iCb16,  iCa16;
    7609. 

  7609.   mng_uint8  iA8, iBGa8, iCa8;
    7610. 

  7610.   mng_uint8  iCr8, iCg8, iCb8;
    7611. 

  7611. 

  7612. #ifdef MNG_SUPPORT_TRACE
    7613. 

  7613.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
    7614. 

  7614. #endif
    7615. 

  7615.                                        /* viewable row ? */
    7616. 

  7616.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    7617. 

  7617.   {                                    /* address destination row */
    7618. 

  7618.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    7619. 

  7619.                                                    pData->iRow + pData->iDestt -
    7620. 

  7620.                                                    pData->iSourcet);
    7621. 

  7621.     pAlphaline = (mng_uint8p)pData->fGetalphaline  (((mng_handle)pData),
    7622. 

  7622.                                                     pData->iRow + pData->iDestt -
    7623. 

  7623.                                                     pData->iSourcet);
    7624. 

  7624.                                        /* adjust destination row
    7625. 

  7625. starting-point */
    7626. 

  7626.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    7627. 

  7627.     pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
    7628. 

  7628.     pDataline = pData->pRGBArow;       /* address source row */
    7629. 

  7629. 

  7630.     if (pData->bIsRGBA16)       /* adjust source row starting-point */
    7631. 

  7631.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    7632. 

  7632.     else
    7633. 

  7633.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    7634. 

  7634. 

  7635.     if (pData->bIsOpaque)              /* forget about transparency ? */
    7636. 

  7636.     {
    7637. 

  7637.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    7638. 

  7638.       {
    7639. 

  7639.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7640. 

  7640.              iX += pData->iColinc)
    7641. 

  7641.         {                              /* scale down by dropping the LSB */
    7642. 

  7642.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) | ((*(pDataline+2)>>5)       ) );
    7643. 

  7643.           *pScanline     = (mng_uint8)( ( (*(pDataline+4)) >>3) | ((*(pDataline+2)&0xFC) << 3) );
    7644. 

  7644.           *pAlphaline    = (mng_uint8)(*(pDataline+6));
    7645. 

  7645. 

  7646.           pScanline += (pData->iColinc * 2);
    7647. 

  7647.           pAlphaline += pData->iColinc;
    7648. 

  7648.           pDataline += 8;
    7649. 

  7649.         }
    7650. 

  7650.       }
    7651. 

  7651.       else
    7652. 

  7652.       {
    7653. 

  7653.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7654. 

  7654.              iX += pData->iColinc)
    7655. 

  7655.         {                              /* copy the values */
    7656. 

  7656.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 )  |  ((*(pDataline+1)>>5   )     ) );
    7657. 

  7657.           *pScanline     = (mng_uint8)( (  *(pDataline+2) >>3 )  |  ((*(pDataline+1)&0xFC ) << 3) );
    7658. 

  7658.           *pAlphaline    = (mng_uint8)(*(pDataline+3));
    7659. 

  7659. 

  7660.           pScanline += (pData->iColinc * 2);
    7661. 

  7661.           pAlphaline += pData->iColinc;
    7662. 

  7662.           pDataline += 4;
    7663. 

  7663.         }
    7664. 

  7664.       }
    7665. 

  7665.     }
    7666. 

  7666.     else /* Not fully opaque */
    7667. 

  7667.     {
    7668. 

  7668.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    7669. 

  7669.       {
    7670. 

  7670. 

  7671.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7672. 

  7672.              iX += pData->iColinc)
    7673. 

  7673.         {
    7674. 

  7674.           iA16 = mng_get_uint16 (pDataline+6);
    7675. 

  7675.           iBGa16 = (mng_uint16)(*pAlphaline);
    7676. 

  7676.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    7677. 

  7677. 

  7678.           if (iA16)                    /* any opacity at all ? */
    7679. 

  7679.           {
    7680. 

  7680.             if ((iA16 == 0xFFFF) || (iBGa16 == 0))       /* fully opaque or background fully transparent ? */
    7681. 

  7681.             {                          /* scale down by dropping the LSB */
    7682. 

  7682.               *(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 )  | (mng_uint8)( (*(pDataline+2)>>5  )     );
    7683. 

  7683.               *pScanline     = (mng_uint8)( (*(pDataline+4)) >>3)  | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    7684. 

  7684.               *pAlphaline    = *(pDataline+6);
    7685. 

  7685.             }
    7686. 

  7686.             else
    7687. 

  7687.             {
    7688. 

  7688.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    7689. 

  7689.               {
    7690. 

  7690.                                         /* get the proper values */
    7691. 

  7691.                 iFGr16 = mng_get_uint16 (pDataline  );
    7692. 

  7692.                 iFGg16 = mng_get_uint16 (pDataline+2);
    7693. 

  7693.                 iFGb16 = mng_get_uint16 (pDataline+4);
    7694. 

  7694.                                          /* scale background up */
    7695. 

  7695. 

  7696.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7697. 

  7697.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  | (((*(pScanline  )) & 0xE0) >>3 ) );
    7698. 

  7698.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7699. 

  7699. 

  7700.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7701. 

  7701.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7702. 

  7702.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7703. 

  7703.                                          /* now compose */
    7704. 

  7704.                 MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    7705. 

  7705.                 MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    7706. 

  7706.                 MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    7707. 

  7707.                                          /* and return the composed values */
    7708. 

  7708.                 *(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 )  | ( (mng_uint8)(iFGg16>>8) >> 5)       );
    7709. 

  7709.                 *pScanline     = (mng_uint8) ( ( (iFGb16>>11)       )  | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    7710. 

  7710.                 *pAlphaline    = (mng_uint8)(iA16>>8);
    7711. 

  7711.               }
    7712. 

  7712.               else /* background is not fully opaque */
    7713. 

  7713.               {                         /* scale background up */
    7714. 

  7714.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7715. 

  7715.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  | (((*(pScanline  )) & 0xE0) >>3 ) );
    7716. 

  7716.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7717. 

  7717. 

  7718.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7719. 

  7719.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7720. 

  7720.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7721. 

  7721.                                        /* let's blend */
    7722. 

  7722.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    7723. 

  7723.                              mng_get_uint16 (pDataline+2),
    7724. 

  7724.                              mng_get_uint16 (pDataline+4), iA16,
    7725. 

  7725.                              iBGr16, iBGg16, iBGb16, iBGa16,
    7726. 

  7726.                              iCr16,  iCg16,  iCb16,  iCa16);
    7727. 

  7727.                                        /* and return the composed values */
    7728. 

  7728.                 *(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8)&0xF8 )  | ( (mng_uint8)(iCg16>>8) >> 5)       );
    7729. 

  7729.                 *pScanline     = (mng_uint8) ( ( (iCb16>>11)       )  | (((mng_uint8)(iCg16>>8)&0xFC) << 3) );
    7730. 

  7730.                 *pAlphaline    = (mng_uint8)(iCa16 >> 8);
    7731. 

  7731.               }
    7732. 

  7732.             }
    7733. 

  7733.           }
    7734. 

  7734. 

  7735.           pScanline += (pData->iColinc * 2);
    7736. 

  7736.           pAlphaline += pData->iColinc;
    7737. 

  7737.           pDataline += 8;
    7738. 

  7738.         }
    7739. 

  7739.       }
    7740. 

  7740.       else
    7741. 

  7741.       {
    7742. 

  7742.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7743. 

  7743. iX += pData->iColinc)
    7744. 

  7744.         {
    7745. 

  7745.           iA8 = *(pDataline+3);        /* get alpha value */
    7746. 

  7746.           iBGa8 = *pAlphaline;
    7747. 

  7747. 

  7748.           if (iA8)                     /* any opacity at all ? */
    7749. 

  7749.           {                            /* fully opaque or background fully transparent ? */
    7750. 

  7750.             if ((iA8 == 0xFF) || (iBGa8 == 0))
    7751. 

  7751.             {                          /* then simply copy the values */
    7752. 

  7752.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  | (*(pDataline+1) >>5 )        );
    7753. 

  7753.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  | ((*(pDataline+1)&0xFC) << 3) );
    7754. 

  7754.               *pAlphaline    = *(pDataline+3);
    7755. 

  7755.             }
    7756. 

  7756.             else
    7757. 

  7757.             {
    7758. 

  7758.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    7759. 

  7759.               {
    7760. 

  7760.                 /* do alpha composing */
    7761. 

  7761.                 mng_uint8 iRed, iGreen, iBlue;
    7762. 

  7762. 

  7763.                 iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    7764. 

  7764.                 iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  (((*pScanline) & 0xE0)>>3 ) );
    7765. 

  7765.                 iBlue  = (mng_uint8) ( (*pScanline << 3) );
    7766. 

  7766. 

  7767.                 MNG_COMPOSE8 (iRed,     *pDataline,     iA8, iRed    );
    7768. 

  7768.                 MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    7769. 

  7769.                 MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    7770. 

  7770. 

  7771.                 *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  | (iGreen>>5) );
    7772. 

  7772.                 *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ((iGreen & 0xFC) << 3) );
    7773. 

  7773.                 *pAlphaline    = iA8;
    7774. 

  7774.               }
    7775. 

  7775.               else /* background not fully opaque */
    7776. 

  7776.               {
    7777. 

  7777.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
    7778. 

  7778.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    7779. 

  7779.                             iCr8, iCg8, iCb8, iCa8);
    7780. 

  7780.                                        /* and return the composed values */
    7781. 

  7781.                 *(pScanline+1) = (mng_uint8) ( ( iCr8  & 0xF8 )  | (iCg8>>5) );
    7782. 

  7782.                 *pScanline     = (mng_uint8) ( ( iCb8 >>  3  )  | ((iCg8 & 0xFC) << 3) );
    7783. 

  7783.                 *pAlphaline    = iCa8;
    7784. 

  7784.               }
    7785. 

  7785.             }
    7786. 

  7786.           }
    7787. 

  7787. 

  7788.           pScanline += (pData->iColinc * 2);
    7789. 

  7789.           pAlphaline += pData->iColinc;
    7790. 

  7790.           pDataline += 4;
    7791. 

  7791.         }
    7792. 

  7792.       }
    7793. 

  7793.     }
    7794. 

  7794.   }
    7795. 

  7795. 

  7796.   check_update_region (pData);
    7797. 

  7797. 

  7798. #ifdef MNG_SUPPORT_TRACE
    7799. 

  7799.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
    7800. 

  7800. #endif
    7801. 

  7801. 

  7802.   return MNG_NOERROR;
    7803. 

  7803. }
    7804. 

  7804. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    7805. 

  7805. mng_retcode mng_display_bgr565_a8 (mng_datap pData)
    7806. 

  7806. {
    7807. 

  7807.   mng_uint8p pScanline;
    7808. 

  7808.   mng_uint8p pAlphaline;
    7809. 

  7809.   mng_uint8p pDataline;
    7810. 

  7810.   mng_int32  iX;
    7811. 

  7811.   mng_uint16 iA16;
    7812. 

  7812.   mng_uint16 iFGr16, iFGg16, iFGb16;
    7813. 

  7813.   mng_uint16 iBGr16, iBGg16, iBGb16, iBGa16;
    7814. 

  7814.   mng_uint16 iCr16,  iCg16,  iCb16,  iCa16;
    7815. 

  7815.   mng_uint8  iA8, iBGa8, iCa8;
    7816. 

  7816.   mng_uint8  iCr8, iCg8, iCb8;
    7817. 

  7817.   mng_uint8  iBps;
    7818. 

  7818. 

  7819. 

  7820. #ifdef MNG_SUPPORT_TRACE
    7821. 

  7821.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
    7822. 

  7822. #endif
    7823. 

  7823. 

  7824.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    7825. 

  7825.                                        /* viewable row ? */
    7826. 

  7826.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    7827. 

  7827.   {                                    /* address destination row */
    7828. 

  7828.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    7829. 

  7829.                                                    pData->iRow + pData->iDestt -
    7830. 

  7830.                                                    pData->iSourcet);
    7831. 

  7831.     pAlphaline = (mng_uint8p)pData->fGetalphaline  (((mng_handle)pData),
    7832. 

  7832.                                                     pData->iRow + pData->iDestt -
    7833. 

  7833.                                                     pData->iSourcet);
    7834. 

  7834.                                        /* adjust destination row
    7835. 

  7835. starting-point */
    7836. 

  7836.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    7837. 

  7837.     pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
    7838. 

  7838.     pDataline = pData->pRGBArow;       /* address source row */
    7839. 

  7839. 

  7840.     /* adjust source row starting-point */
    7841. 

  7841.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    7842. 

  7842. 

  7843.     if (pData->bIsOpaque)              /* forget about transparency ? */
    7844. 

  7844.     {
    7845. 

  7845.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7846. 

  7846.              iX += pData->iColinc)
    7847. 

  7847.         {                              /* scale down by dropping the LSB */
    7848. 

  7848.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 ) |
    7849. 

  7849.               ((*(pDataline+iBps)>>5)       ) );
    7850. 

  7850.           *pScanline     = (mng_uint8)( ( (*(pDataline+2*iBps)) >>3) |
    7851. 

  7851.               ((*(pDataline+iBps)&0xFC) << 3) );
    7852. 

  7852.           *pAlphaline    = (mng_uint8)(*(pDataline+6));
    7853. 

  7853. 

  7854.           pScanline += (pData->iColinc * 2);
    7855. 

  7855.           pAlphaline += pData->iColinc;
    7856. 

  7856.           pDataline += 8;
    7857. 

  7857.         }
    7858. 

  7858.     }
    7859. 

  7859.     else /* Not fully opaque */
    7860. 

  7860.     {
    7861. 

  7861.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    7862. 

  7862.       {
    7863. 

  7863. 

  7864.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7865. 

  7865.              iX += pData->iColinc)
    7866. 

  7866.         {
    7867. 

  7867.           iA16 = mng_get_uint16 (pDataline+6);
    7868. 

  7868.           iBGa16 = (mng_uint16)(*pAlphaline);
    7869. 

  7869.           iBGa16 = (mng_uint16)(iBGa16 << 8) | iBGa16;
    7870. 

  7870. 

  7871.           if (iA16)                    /* any opacity at all ? */
    7872. 

  7872.           {
    7873. 

  7873.             if ((iA16 == 0xFFFF) || (iBGa16 == 0))       /* fully opaque or background fully transparent ? */
    7874. 

  7874.             {                          /* scale down by dropping the LSB */
    7875. 

  7875.               *(pScanline+1) = (mng_uint8)( (*(pDataline))&0xF8 )  | (mng_uint8)( (*(pDataline+2)>>5  )     );
    7876. 

  7876.               *pScanline     = (mng_uint8)( (*(pDataline+4)) >>3)  | (mng_uint8)( (*(pDataline+2)&0xFC) << 3);
    7877. 

  7877.               *pAlphaline    = *(pDataline+6);
    7878. 

  7878.             }
    7879. 

  7879.             else
    7880. 

  7880.             {
    7881. 

  7881.               if (iBGa16 == 0xFFFF)    /* background fully opaque ? */
    7882. 

  7882.               {
    7883. 

  7883.                                         /* get the proper values */
    7884. 

  7884.                 iFGr16 = mng_get_uint16 (pDataline  );
    7885. 

  7885.                 iFGg16 = mng_get_uint16 (pDataline+2);
    7886. 

  7886.                 iFGb16 = mng_get_uint16 (pDataline+4);
    7887. 

  7887.                                          /* scale background up */
    7888. 

  7888. 

  7889.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7890. 

  7890.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  | (((*(pScanline  )) & 0xE0) >>3 ) );
    7891. 

  7891.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7892. 

  7892. 

  7893.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7894. 

  7894.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7895. 

  7895.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7896. 

  7896.                                          /* now compose */
    7897. 

  7897.                 MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    7898. 

  7898.                 MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    7899. 

  7899.                 MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    7900. 

  7900.                                          /* and return the composed values */
    7901. 

  7901.                 *(pScanline+1) = (mng_uint8) ( ( (iFGr16 >> 8)&0xF8 )  | ( (mng_uint8)(iFGg16>>8) >> 5)       );
    7902. 

  7902.                 *pScanline     = (mng_uint8) ( ( (iFGb16>>11)       )  | (((mng_uint8)(iFGg16>>8)&0xFC) << 3) );
    7903. 

  7903.                 *pAlphaline    = (mng_uint8)(iA16>>8);
    7904. 

  7904.               }
    7905. 

  7905.               else /* background is not fully opaque */
    7906. 

  7906.               {                         /* scale background up */
    7907. 

  7907.                 iBGb16 = (mng_uint16)( (*(pScanline+1)) & 0xF8 );
    7908. 

  7908.                 iBGg16 = (mng_uint16)( (*(pScanline+1) << 5)  | (((*(pScanline  )) & 0xE0) >>3 ) );
    7909. 

  7909.                 iBGr16 = (mng_uint16)( (*(pScanline  )) << 3   );
    7910. 

  7910. 

  7911.                 iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    7912. 

  7912.                 iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    7913. 

  7913.                 iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    7914. 

  7914.                                        /* let's blend */
    7915. 

  7915.                 MNG_BLEND16 (mng_get_uint16 (pDataline  ),
    7916. 

  7916.                              mng_get_uint16 (pDataline+2),
    7917. 

  7917.                              mng_get_uint16 (pDataline+4), iA16,
    7918. 

  7918.                              iBGr16, iBGg16, iBGb16, iBGa16,
    7919. 

  7919.                              iCr16,  iCg16,  iCb16,  iCa16);
    7920. 

  7920.                                        /* and return the composed values */
    7921. 

  7921.                 *(pScanline+1) = (mng_uint8) ( ( (iCr16 >> 8)&0xF8 )  | ( (mng_uint8)(iCg16>>8) >> 5)       );
    7922. 

  7922.                 *pScanline     = (mng_uint8) ( ( (iCb16>>11)       )  | (((mng_uint8)(iCg16>>8)&0xFC) << 3) );
    7923. 

  7923.                 *pAlphaline    = (mng_uint8)(iCa16 >> 8);
    7924. 

  7924.               }
    7925. 

  7925.             }
    7926. 

  7926.           }
    7927. 

  7927. 

  7928.           pScanline += (pData->iColinc * 2);
    7929. 

  7929.           pAlphaline += pData->iColinc;
    7930. 

  7930.           pDataline += 8;
    7931. 

  7931.         }
    7932. 

  7932.       }
    7933. 

  7933.       else
    7934. 

  7934.       {
    7935. 

  7935.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    7936. 

  7936. iX += pData->iColinc)
    7937. 

  7937.         {
    7938. 

  7938.           iA8 = *(pDataline+3);        /* get alpha value */
    7939. 

  7939.           iBGa8 = *pAlphaline;
    7940. 

  7940. 

  7941.           if (iA8)                     /* any opacity at all ? */
    7942. 

  7942.           {                            /* fully opaque or background fully transparent ? */
    7943. 

  7943.             if ((iA8 == 0xFF) || (iBGa8 == 0))
    7944. 

  7944.             {                          /* then simply copy the values */
    7945. 

  7945.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  | (*(pDataline+1) >>5 )        );
    7946. 

  7946.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  | ((*(pDataline+1)&0xFC) << 3) );
    7947. 

  7947.               *pAlphaline    = *(pDataline+3);
    7948. 

  7948.             }
    7949. 

  7949.             else
    7950. 

  7950.             {
    7951. 

  7951.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    7952. 

  7952.               {
    7953. 

  7953.                 /* do alpha composing */
    7954. 

  7954.                 mng_uint8 iRed, iGreen, iBlue;
    7955. 

  7955. 

  7956.                 iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    7957. 

  7957.                 iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  (((*pScanline) & 0xE0)>>3 ) );
    7958. 

  7958.                 iBlue  = (mng_uint8) ( (*pScanline << 3) );
    7959. 

  7959. 

  7960.                 MNG_COMPOSE8 (iRed,     *pDataline,     iA8, iRed    );
    7961. 

  7961.                 MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    7962. 

  7962.                 MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    7963. 

  7963. 

  7964.                 *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  | (iGreen>>5) );
    7965. 

  7965.                 *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ((iGreen & 0xFC) << 3) );
    7966. 

  7966.                 *pAlphaline    = iA8;
    7967. 

  7967.               }
    7968. 

  7968.               else /* background not fully opaque */
    7969. 

  7969.               {
    7970. 

  7970.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
    7971. 

  7971.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    7972. 

  7972.                             iCr8, iCg8, iCb8, iCa8);
    7973. 

  7973.                                        /* and return the composed values */
    7974. 

  7974.                 *(pScanline+1) = (mng_uint8) ( ( iCr8  & 0xF8 )  | (iCg8>>5) );
    7975. 

  7975.                 *pScanline     = (mng_uint8) ( ( iCb8 >>  3  )  | ((iCg8 & 0xFC) << 3) );
    7976. 

  7976.                 *pAlphaline    = iCa8;
    7977. 

  7977.               }
    7978. 

  7978.             }
    7979. 

  7979.           }
    7980. 

  7980. 

  7981.           pScanline += (pData->iColinc * 2);
    7982. 

  7982.           pAlphaline += pData->iColinc;
    7983. 

  7983.           pDataline += 4;
    7984. 

  7984.         }
    7985. 

  7985.       }
    7986. 

  7986.     }
    7987. 

  7987.   }
    7988. 

  7988. 

  7989.   check_update_region (pData);
    7990. 

  7990. 

  7991. #ifdef MNG_SUPPORT_TRACE
    7992. 

  7992.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
    7993. 

  7993. #endif
    7994. 

  7994. 

  7995.   return MNG_NOERROR;
    7996. 

  7996. }
    7997. 

  7997. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    7998. 

  7998. #else /* MNG_NO_16BIT_SUPPORT */
    7999. 

  7999. mng_retcode mng_display_bgr565_a8 (mng_datap pData)
    8000. 

  8000. {
    8001. 

  8001.   mng_uint8p pScanline;
    8002. 

  8002.   mng_uint8p pAlphaline;
    8003. 

  8003.   mng_uint8p pDataline;
    8004. 

  8004.   mng_int32  iX;
    8005. 

  8005.   mng_uint8  iA8, iBGa8, iCa8;
    8006. 

  8006.   mng_uint8  iCr8, iCg8, iCb8;
    8007. 

  8007. 

  8008. 

  8009. #ifdef MNG_SUPPORT_TRACE
    8010. 

  8010.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_START);
    8011. 

  8011. #endif
    8012. 

  8012.                                        /* viewable row ? */
    8013. 

  8013.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8014. 

  8014.   {                                    /* address destination row */
    8015. 

  8015.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8016. 

  8016.                                                    pData->iRow + pData->iDestt -
    8017. 

  8017.                                                    pData->iSourcet);
    8018. 

  8018.     pAlphaline = (mng_uint8p)pData->fGetalphaline  (((mng_handle)pData),
    8019. 

  8019.                                                     pData->iRow + pData->iDestt -
    8020. 

  8020.                                                     pData->iSourcet);
    8021. 

  8021.                                        /* adjust destination row
    8022. 

  8022. starting-point */
    8023. 

  8023.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8024. 

  8024.     pAlphaline = pAlphaline + pData->iCol + pData->iDestl;
    8025. 

  8025.     pDataline = pData->pRGBArow;       /* address source row */
    8026. 

  8026. 

  8027.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    8028. 

  8028. 

  8029.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8030. 

  8030.     {
    8031. 

  8031.       {
    8032. 

  8032.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8033. 

  8033.              iX += pData->iColinc)
    8034. 

  8034.         {                              /* copy the values */
    8035. 

  8035.           *(pScanline+1) = (mng_uint8)( ( (*(pDataline))&0xF8 )  |  ((*(pDataline+1)>>5   )     ) );
    8036. 

  8036.           *pScanline     = (mng_uint8)( (  *(pDataline+2) >>3 )  |  ((*(pDataline+1)&0xFC ) << 3) );
    8037. 

  8037.           *pAlphaline    = (mng_uint8)(*(pDataline+3));
    8038. 

  8038. 

  8039.           pScanline += (pData->iColinc * 2);
    8040. 

  8040.           pAlphaline += pData->iColinc;
    8041. 

  8041.           pDataline += 4;
    8042. 

  8042.         }
    8043. 

  8043.       }
    8044. 

  8044.     }
    8045. 

  8045.     else /* Not fully opaque */
    8046. 

  8046.     {
    8047. 

  8047.       {
    8048. 

  8048.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8049. 

  8049. iX += pData->iColinc)
    8050. 

  8050.         {
    8051. 

  8051.           iA8 = *(pDataline+3);        /* get alpha value */
    8052. 

  8052.           iBGa8 = *pAlphaline;
    8053. 

  8053. 

  8054.           if (iA8)                     /* any opacity at all ? */
    8055. 

  8055.           {                            /* fully opaque or background fully transparent ? */
    8056. 

  8056.             if ((iA8 == 0xFF) || (iBGa8 == 0))
    8057. 

  8057.             {                          /* then simply copy the values */
    8058. 

  8058.               *(pScanline+1) = (mng_uint8)( (  (*(pDataline)) &0xF8 )  | (*(pDataline+1) >>5 )        );
    8059. 

  8059.               *pScanline     = (mng_uint8)( ( ((*(pDataline+2))>>3) )  | ((*(pDataline+1)&0xFC) << 3) );
    8060. 

  8060.               *pAlphaline    = *(pDataline+3);
    8061. 

  8061.             }
    8062. 

  8062.             else
    8063. 

  8063.             {
    8064. 

  8064.               if (iBGa8 == 0xFF)       /* background fully opaque ? */
    8065. 

  8065.               {
    8066. 

  8066.                 /* do alpha composing */
    8067. 

  8067.                 mng_uint8 iRed, iGreen, iBlue;
    8068. 

  8068. 

  8069.                 iRed   = (mng_uint8) (  *(pScanline+1) & 0xF8 );
    8070. 

  8070.                 iGreen = (mng_uint8) ( (*(pScanline+1) << 5)  |  (((*pScanline) & 0xE0)>>3 ) );
    8071. 

  8071.                 iBlue  = (mng_uint8) ( (*pScanline << 3) );
    8072. 

  8072. 

  8073.                 MNG_COMPOSE8 (iRed,     *pDataline,     iA8, iRed    );
    8074. 

  8074.                 MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8075. 

  8075.                 MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    8076. 

  8076. 

  8077.                 *(pScanline+1) = (mng_uint8) ( ( iRed  & 0xF8 )  | (iGreen>>5) );
    8078. 

  8078.                 *pScanline     = (mng_uint8) ( ( iBlue >>  3  )  | ((iGreen & 0xFC) << 3) );
    8079. 

  8079.                 *pAlphaline    = iA8;
    8080. 

  8080.               }
    8081. 

  8081.               else /* background not fully opaque */
    8082. 

  8082.               {
    8083. 

  8083.                 MNG_BLEND8 (*pDataline, *(pDataline+1), *(pDataline+2), iA8,
    8084. 

  8084.                             *pScanline, *(pScanline+1), *(pScanline+2), iBGa8,
    8085. 

  8085.                             iCr8, iCg8, iCb8, iCa8);
    8086. 

  8086.                                        /* and return the composed values */
    8087. 

  8087.                 *(pScanline+1) = (mng_uint8) ( ( iCr8  & 0xF8 )  | (iCg8>>5) );
    8088. 

  8088.                 *pScanline     = (mng_uint8) ( ( iCb8 >>  3  )  | ((iCg8 & 0xFC) << 3) );
    8089. 

  8089.                 *pAlphaline    = iCa8;
    8090. 

  8090.               }
    8091. 

  8091.             }
    8092. 

  8092.           }
    8093. 

  8093. 

  8094.           pScanline += (pData->iColinc * 2);
    8095. 

  8095.           pAlphaline += pData->iColinc;
    8096. 

  8096.           pDataline += 4;
    8097. 

  8097.         }
    8098. 

  8098.       }
    8099. 

  8099.     }
    8100. 

  8100.   }
    8101. 

  8101. 

  8102.   check_update_region (pData);
    8103. 

  8103. 

  8104. #ifdef MNG_SUPPORT_TRACE
    8105. 

  8105.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR565_A8, MNG_LC_END);
    8106. 

  8106. #endif
    8107. 

  8107. 

  8108.   return MNG_NOERROR;
    8109. 

  8109. }
    8110. 

  8110. #endif /* MNG_NO_16BIT_SUPPORT */
    8111. 

  8111. #endif /* MNG_SKIPCANVAS_BGR565_A8 */
    8112. 

  8112. 

  8113. /* ************************************************************************** */
    8114. 

  8114. 

  8115. #ifndef MNG_SKIPCANVAS_RGB555
    8116. 

  8116. #ifndef MNG_NO_16BIT_SUPPORT
    8117. 

  8117. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    8118. 

  8118. mng_retcode mng_display_rgb555 (mng_datap pData)
    8119. 

  8119. {
    8120. 

  8120.   mng_uint8p pScanline;
    8121. 

  8121.   mng_uint8p pDataline;
    8122. 

  8122.   mng_int32  iX;
    8123. 

  8123.   mng_uint16 iA16;
    8124. 

  8124.   mng_uint16 iFGr16, iFGg16, iFGb16;
    8125. 

  8125.   mng_uint16 iBGr16, iBGg16, iBGb16;
    8126. 

  8126.   mng_uint8  iA8;
    8127. 

  8127. 

  8128. #ifdef MNG_SUPPORT_TRACE
    8129. 

  8129.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
    8130. 

  8130. #endif
    8131. 

  8131.                                        /* viewable row ? */
    8132. 

  8132.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8133. 

  8133.   {                                    /* address destination row */
    8134. 

  8134.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8135. 

  8135.                                                    pData->iRow + pData->iDestt -
    8136. 

  8136.                                                    pData->iSourcet);
    8137. 

  8137.                                        /* adjust destination row starting-point */
    8138. 

  8138.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8139. 

  8139.     pDataline = pData->pRGBArow;       /* address source row */
    8140. 

  8140. 

  8141.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    8142. 

  8142.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    8143. 

  8143.     else
    8144. 

  8144.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    8145. 

  8145. 

  8146.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8147. 

  8147.     {
    8148. 

  8148.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    8149. 

  8149.       {
    8150. 

  8150.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8151. 

  8151.              iX += pData->iColinc)
    8152. 

  8152.         {                              /* scale down by dropping the LSB */
    8153. 

  8153.           *(pScanline+1) = (mng_uint8)( ((*(pDataline+4) & 0xF8) >> 1 ) |  (*(pDataline+2)         >> 6 ) );
    8154. 

  8154.           *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
    8155. 

  8155. 

  8156.           pScanline += (pData->iColinc * 2);
    8157. 

  8157.           pDataline += 8;
    8158. 

  8158.         }
    8159. 

  8159.       }
    8160. 

  8160.       else
    8161. 

  8161.       {
    8162. 

  8162.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8163. 

  8163.              iX += pData->iColinc)
    8164. 

  8164.         {                              /* copy the values */
    8165. 

  8165.           *(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8166. 

  8166.           *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8167. 

  8167. 

  8168.           pScanline += (pData->iColinc * 2);
    8169. 

  8169.           pDataline += 4;
    8170. 

  8170.         }
    8171. 

  8171.       }
    8172. 

  8172.     }
    8173. 

  8173.     else
    8174. 

  8174.     {
    8175. 

  8175.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    8176. 

  8176.       {
    8177. 

  8177. 

  8178.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8179. 

  8179.              iX += pData->iColinc)
    8180. 

  8180.         {
    8181. 

  8181.           iA16 = mng_get_uint16 (pDataline+6);
    8182. 

  8182. 

  8183.           if (iA16)                    /* any opacity at all ? */
    8184. 

  8184.           {
    8185. 

  8185.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    8186. 

  8186.             {                          /* scale down by dropping the LSB */
    8187. 

  8187.               *(pScanline+1) = (mng_uint8)( ((*(pDataline+4) & 0xF8) >> 1 ) |  (*(pDataline+2)         >> 6 ) );
    8188. 

  8188.               *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
    8189. 

  8189.             }
    8190. 

  8190.             else
    8191. 

  8191.             {                          /* get the proper values */
    8192. 

  8192.               iFGr16 = mng_get_uint16 (pDataline  );
    8193. 

  8193.               iFGg16 = mng_get_uint16 (pDataline+2);
    8194. 

  8194.               iFGb16 = mng_get_uint16 (pDataline+4);
    8195. 

  8195. 

  8196. 			                           /* scale background up */
    8197. 

  8197.               iBGr16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8198. 

  8198.               iBGg16 = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8199. 

  8199.               iBGb16 = (mng_uint8)(  *(pScanline  )         << 3 );
    8200. 

  8200. 

  8201.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    8202. 

  8202.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    8203. 

  8203.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    8204. 

  8204.                                        /* now compose */
    8205. 

  8205.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    8206. 

  8206.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    8207. 

  8207.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    8208. 

  8208.                                        /* and return the composed values */
    8209. 

  8209.               *(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGb16 >> 8) & 0xF8) >> 1 ) | (   (mng_uint8)(iFGg16 >> 8)         >> 6 ) );
    8210. 

  8210.               *pScanline     = (mng_uint8)( (mng_uint8) ((iFGr16 >>11)         >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
    8211. 

  8211.             }
    8212. 

  8212.           }
    8213. 

  8213. 

  8214.           pScanline += (pData->iColinc * 2);
    8215. 

  8215.           pDataline += 8;
    8216. 

  8216.         }
    8217. 

  8217.       }
    8218. 

  8218.       else
    8219. 

  8219.       {
    8220. 

  8220.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8221. 

  8221.              iX += pData->iColinc)
    8222. 

  8222.         {
    8223. 

  8223.           iA8 = *(pDataline+3);        /* get alpha value */
    8224. 

  8224. 

  8225.           if (iA8)                     /* any opacity at all ? */
    8226. 

  8226.           {
    8227. 

  8227.             if (iA8 == 0xFF)           /* fully opaque ? */
    8228. 

  8228.             {                          /* then simply copy the values */
    8229. 

  8229.               *(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8230. 

  8230.               *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8231. 

  8231.             }
    8232. 

  8232.             else
    8233. 

  8233.             {                          /* do alpha composing */
    8234. 

  8234.               mng_uint8 iRed, iGreen, iBlue;
    8235. 

  8235. 

  8236.               iRed   = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8237. 

  8237.               iGreen = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8238. 

  8238.               iBlue  = (mng_uint8)(  *(pScanline  )         << 3 );
    8239. 

  8239. 

  8240.               MNG_COMPOSE8 (iRed,     *(pDataline+2), iA8, iRed    );
    8241. 

  8241.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8242. 

  8242.               MNG_COMPOSE8 (iBlue,    *(pDataline+0), iA8, iBlue   );
    8243. 

  8243. 

  8244.               *(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 )  |  (  iGreen         >> 6 ) );
    8245. 

  8245.               *pScanline     = (mng_uint8)(   (iBlue        >> 3 )  |  ( (iGreen & 0xF8) << 2 ) );
    8246. 

  8246.             }
    8247. 

  8247.           }
    8248. 

  8248. 

  8249.           pScanline += (pData->iColinc * 2);
    8250. 

  8250.           pDataline += 4;
    8251. 

  8251.         }
    8252. 

  8252.       }
    8253. 

  8253.     }
    8254. 

  8254.   }
    8255. 

  8255. 

  8256.   check_update_region (pData);
    8257. 

  8257. 

  8258. #ifdef MNG_SUPPORT_TRACE
    8259. 

  8259.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
    8260. 

  8260. #endif
    8261. 

  8261. 

  8262.   return MNG_NOERROR;
    8263. 

  8263. }
    8264. 

  8264. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    8265. 

  8265. mng_retcode mng_display_rgb555 (mng_datap pData)
    8266. 

  8266. {
    8267. 

  8267.   mng_uint8p pScanline;
    8268. 

  8268.   mng_uint8p pDataline;
    8269. 

  8269.   mng_int32  iX;
    8270. 

  8270.   mng_uint16 iA16;
    8271. 

  8271.   mng_uint16 iFGr16, iFGg16, iFGb16;
    8272. 

  8272.   mng_uint16 iBGr16, iBGg16, iBGb16;
    8273. 

  8273.   mng_uint8  iA8;
    8274. 

  8274.   mng_uint8  iBps;
    8275. 

  8275. 

  8276. #ifdef MNG_SUPPORT_TRACE
    8277. 

  8277.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
    8278. 

  8278. #endif
    8279. 

  8279. 

  8280.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    8281. 

  8281.                                        /* viewable row ? */
    8282. 

  8282.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8283. 

  8283.   {                                    /* address destination row */
    8284. 

  8284.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8285. 

  8285.                                                    pData->iRow + pData->iDestt -
    8286. 

  8286.                                                    pData->iSourcet);
    8287. 

  8287.                                        /* adjust destination row starting-point */
    8288. 

  8288.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8289. 

  8289.     pDataline = pData->pRGBArow;       /* address source row */
    8290. 

  8290. 

  8291.     /* adjust source row starting-point */
    8292. 

  8292.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    8293. 

  8293. 

  8294.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8295. 

  8295.     {
    8296. 

  8296.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8297. 

  8297.              iX += pData->iColinc)
    8298. 

  8298.         {                              /* scale down by dropping the LSB */
    8299. 

  8299.           *(pScanline+1) = (mng_uint8)( ((*(pDataline+2*iBps) & 0xF8) >> 1 ) |  (*(pDataline+iBps)         >> 6 ) );
    8300. 

  8300.           *pScanline     = (mng_uint8)( ( *(pDataline       )         >> 3 ) | ((*(pDataline+iBps) & 0xF8) << 2 ) );
    8301. 

  8301. 

  8302.           pScanline += (pData->iColinc * 2);
    8303. 

  8303.           pDataline += 4*iBps;
    8304. 

  8304.         }
    8305. 

  8305.     }
    8306. 

  8306.     else
    8307. 

  8307.     {
    8308. 

  8308.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    8309. 

  8309.       {
    8310. 

  8310. 

  8311.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8312. 

  8312.              iX += pData->iColinc)
    8313. 

  8313.         {
    8314. 

  8314.           iA16 = mng_get_uint16 (pDataline+6);
    8315. 

  8315. 

  8316.           if (iA16)                    /* any opacity at all ? */
    8317. 

  8317.           {
    8318. 

  8318.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    8319. 

  8319.             {                          /* scale down by dropping the LSB */
    8320. 

  8320.               *(pScanline+1) = (mng_uint8)( ((*(pDataline+4) & 0xF8) >> 1 ) |  (*(pDataline+2)         >> 6 ) );
    8321. 

  8321.               *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
    8322. 

  8322.             }
    8323. 

  8323.             else
    8324. 

  8324.             {                          /* get the proper values */
    8325. 

  8325.               iFGr16 = mng_get_uint16 (pDataline  );
    8326. 

  8326.               iFGg16 = mng_get_uint16 (pDataline+2);
    8327. 

  8327.               iFGb16 = mng_get_uint16 (pDataline+4);
    8328. 

  8328. 

  8329. 			                           /* scale background up */
    8330. 

  8330.               iBGr16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8331. 

  8331.               iBGg16 = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8332. 

  8332.               iBGb16 = (mng_uint8)(  *(pScanline  )         << 3 );
    8333. 

  8333. 

  8334.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    8335. 

  8335.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    8336. 

  8336.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    8337. 

  8337.                                        /* now compose */
    8338. 

  8338.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    8339. 

  8339.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    8340. 

  8340.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    8341. 

  8341.                                        /* and return the composed values */
    8342. 

  8342.               *(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGb16 >> 8) & 0xF8) >> 1 ) | (   (mng_uint8)(iFGg16 >> 8)         >> 6 ) );
    8343. 

  8343.               *pScanline     = (mng_uint8)( (mng_uint8) ((iFGr16 >>11)         >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
    8344. 

  8344.             }
    8345. 

  8345.           }
    8346. 

  8346. 

  8347.           pScanline += (pData->iColinc * 2);
    8348. 

  8348.           pDataline += 8;
    8349. 

  8349.         }
    8350. 

  8350.       }
    8351. 

  8351.       else
    8352. 

  8352.       {
    8353. 

  8353.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8354. 

  8354.              iX += pData->iColinc)
    8355. 

  8355.         {
    8356. 

  8356.           iA8 = *(pDataline+3);        /* get alpha value */
    8357. 

  8357. 

  8358.           if (iA8)                     /* any opacity at all ? */
    8359. 

  8359.           {
    8360. 

  8360.             if (iA8 == 0xFF)           /* fully opaque ? */
    8361. 

  8361.             {                          /* then simply copy the values */
    8362. 

  8362.               *(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8363. 

  8363.               *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8364. 

  8364.             }
    8365. 

  8365.             else
    8366. 

  8366.             {                          /* do alpha composing */
    8367. 

  8367.               mng_uint8 iRed, iGreen, iBlue;
    8368. 

  8368. 

  8369.               iRed   = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8370. 

  8370.               iGreen = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8371. 

  8371.               iBlue  = (mng_uint8)(  *(pScanline  )         << 3 );
    8372. 

  8372. 

  8373.               MNG_COMPOSE8 (iRed,     *(pDataline+2), iA8, iRed    );
    8374. 

  8374.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8375. 

  8375.               MNG_COMPOSE8 (iBlue,    *(pDataline+0), iA8, iBlue   );
    8376. 

  8376. 

  8377.               *(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 )  |  (  iGreen         >> 6 ) );
    8378. 

  8378.               *pScanline     = (mng_uint8)(   (iBlue        >> 3 )  |  ( (iGreen & 0xF8) << 2 ) );
    8379. 

  8379.             }
    8380. 

  8380.           }
    8381. 

  8381. 

  8382.           pScanline += (pData->iColinc * 2);
    8383. 

  8383.           pDataline += 4;
    8384. 

  8384.         }
    8385. 

  8385.       }
    8386. 

  8386.     }
    8387. 

  8387.   }
    8388. 

  8388. 

  8389.   check_update_region (pData);
    8390. 

  8390. 

  8391. #ifdef MNG_SUPPORT_TRACE
    8392. 

  8392.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
    8393. 

  8393. #endif
    8394. 

  8394. 

  8395.   return MNG_NOERROR;
    8396. 

  8396. }
    8397. 

  8397. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    8398. 

  8398. #else /* MNG_NO_16BIT_SUPPORT */
    8399. 

  8399. mng_retcode mng_display_rgb555 (mng_datap pData)
    8400. 

  8400. {
    8401. 

  8401.   mng_uint8p pScanline;
    8402. 

  8402.   mng_uint8p pDataline;
    8403. 

  8403.   mng_int32  iX;
    8404. 

  8404.   mng_uint8  iA8;
    8405. 

  8405. 

  8406. #ifdef MNG_SUPPORT_TRACE
    8407. 

  8407.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_START);
    8408. 

  8408. #endif
    8409. 

  8409.                                        /* viewable row ? */
    8410. 

  8410.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8411. 

  8411.   {                                    /* address destination row */
    8412. 

  8412.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8413. 

  8413.                                                    pData->iRow + pData->iDestt -
    8414. 

  8414.                                                    pData->iSourcet);
    8415. 

  8415.                                        /* adjust destination row starting-point */
    8416. 

  8416.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8417. 

  8417.     pDataline = pData->pRGBArow;       /* address source row */
    8418. 

  8418. 

  8419.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    8420. 

  8420. 

  8421.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8422. 

  8422.     {
    8423. 

  8423.       {
    8424. 

  8424.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8425. 

  8425.              iX += pData->iColinc)
    8426. 

  8426.         {                              /* copy the values */
    8427. 

  8427.           *(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8428. 

  8428.           *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8429. 

  8429. 

  8430.           pScanline += (pData->iColinc * 2);
    8431. 

  8431.           pDataline += 4;
    8432. 

  8432.         }
    8433. 

  8433.       }
    8434. 

  8434.     }
    8435. 

  8435.     else
    8436. 

  8436.     {
    8437. 

  8437.       {
    8438. 

  8438.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8439. 

  8439.              iX += pData->iColinc)
    8440. 

  8440.         {
    8441. 

  8441.           iA8 = *(pDataline+3);        /* get alpha value */
    8442. 

  8442. 

  8443.           if (iA8)                     /* any opacity at all ? */
    8444. 

  8444.           {
    8445. 

  8445.             if (iA8 == 0xFF)           /* fully opaque ? */
    8446. 

  8446.             {                          /* then simply copy the values */
    8447. 

  8447.               *(pScanline+1) = (mng_uint8)( ((*(pDataline+2) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8448. 

  8448.               *pScanline     = (mng_uint8)( ( *(pDataline  )         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8449. 

  8449.             }
    8450. 

  8450.             else
    8451. 

  8451.             {                          /* do alpha composing */
    8452. 

  8452.               mng_uint8 iRed, iGreen, iBlue;
    8453. 

  8453. 

  8454.               iRed   = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8455. 

  8455.               iGreen = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8456. 

  8456.               iBlue  = (mng_uint8)(  *(pScanline  )         << 3 );
    8457. 

  8457. 

  8458.               MNG_COMPOSE8 (iRed,     *(pDataline+2), iA8, iRed    );
    8459. 

  8459.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8460. 

  8460.               MNG_COMPOSE8 (iBlue,    *(pDataline+0), iA8, iBlue   );
    8461. 

  8461. 

  8462.               *(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 )  |  (  iGreen         >> 6 ) );
    8463. 

  8463.               *pScanline     = (mng_uint8)(   (iBlue        >> 3 )  |  ( (iGreen & 0xF8) << 2 ) );
    8464. 

  8464.             }
    8465. 

  8465.           }
    8466. 

  8466. 

  8467.           pScanline += (pData->iColinc * 2);
    8468. 

  8468.           pDataline += 4;
    8469. 

  8469.         }
    8470. 

  8470.       }
    8471. 

  8471.     }
    8472. 

  8472.   }
    8473. 

  8473. 

  8474.   check_update_region (pData);
    8475. 

  8475. 

  8476. #ifdef MNG_SUPPORT_TRACE
    8477. 

  8477.   MNG_TRACE (pData, MNG_FN_DISPLAY_RGB555, MNG_LC_END);
    8478. 

  8478. #endif
    8479. 

  8479. 

  8480.   return MNG_NOERROR;
    8481. 

  8481. }
    8482. 

  8482. #endif /* MNG_NO_16BIT_SUPPORT */
    8483. 

  8483. #endif /* MNG_SKIPCANVAS_RGB555 */
    8484. 

  8484. 

  8485. /* ************************************************************************** */
    8486. 

  8486. 

  8487. #ifndef MNG_SKIPCANVAS_BGR555
    8488. 

  8488. #ifndef MNG_NO_16BIT_SUPPORT
    8489. 

  8489. #ifndef MNG_OPTIMIZE_FOOTPRINT_COMPOSE
    8490. 

  8490. mng_retcode mng_display_bgr555 (mng_datap pData)
    8491. 

  8491. {
    8492. 

  8492.   mng_uint8p pScanline;
    8493. 

  8493.   mng_uint8p pDataline;
    8494. 

  8494.   mng_int32  iX;
    8495. 

  8495.   mng_uint16 iA16;
    8496. 

  8496.   mng_uint16 iFGr16, iFGg16, iFGb16;
    8497. 

  8497.   mng_uint16 iBGr16, iBGg16, iBGb16;
    8498. 

  8498.   mng_uint8  iA8;
    8499. 

  8499. 

  8500. #ifdef MNG_SUPPORT_TRACE
    8501. 

  8501.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
    8502. 

  8502. #endif
    8503. 

  8503.                                        /* viewable row ? */
    8504. 

  8504.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8505. 

  8505.   {                                    /* address destination row */
    8506. 

  8506.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8507. 

  8507.                                                    pData->iRow + pData->iDestt -
    8508. 

  8508.                                                    pData->iSourcet);
    8509. 

  8509.                                        /* adjust destination row starting-point */
    8510. 

  8510.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8511. 

  8511.     pDataline = pData->pRGBArow;       /* address source row */
    8512. 

  8512. 

  8513.     if (pData->bIsRGBA16)              /* adjust source row starting-point */
    8514. 

  8514.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 3);
    8515. 

  8515.     else
    8516. 

  8516.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    8517. 

  8517. 

  8518.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8519. 

  8519.     {
    8520. 

  8520.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    8521. 

  8521.       {
    8522. 

  8522.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8523. 

  8523.              iX += pData->iColinc)
    8524. 

  8524.         {                              /* scale down by dropping the LSB */
    8525. 

  8525.           *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+2)         >> 6 ) );
    8526. 

  8526.           *pScanline     = (mng_uint8)( ( *(pDataline+4)         >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
    8527. 

  8527. 

  8528.           pScanline += (pData->iColinc * 2);
    8529. 

  8529.           pDataline += 8;
    8530. 

  8530.         }
    8531. 

  8531.       }
    8532. 

  8532.       else
    8533. 

  8533.       {
    8534. 

  8534.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8535. 

  8535.              iX += pData->iColinc)
    8536. 

  8536.         {                              /* copy the values */
    8537. 

  8537.           *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8538. 

  8538.           *pScanline     = (mng_uint8)( ( *(pDataline+2)         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8539. 

  8539. 

  8540.           pScanline += (pData->iColinc * 2);
    8541. 

  8541.           pDataline += 4;
    8542. 

  8542.         }
    8543. 

  8543.       }
    8544. 

  8544.     }
    8545. 

  8545.     else
    8546. 

  8546.     {
    8547. 

  8547.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    8548. 

  8548.       {
    8549. 

  8549. 

  8550.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8551. 

  8551.              iX += pData->iColinc)
    8552. 

  8552.         {
    8553. 

  8553.           iA16 = mng_get_uint16 (pDataline+6);
    8554. 

  8554. 

  8555.           if (iA16)                    /* any opacity at all ? */
    8556. 

  8556.           {
    8557. 

  8557.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    8558. 

  8558.             {                          /* scale down by dropping the LSB */
    8559. 

  8559.               *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+2)         >> 6 ) );
    8560. 

  8560.               *pScanline     = (mng_uint8)( ( *(pDataline+4)         >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
    8561. 

  8561.             }
    8562. 

  8562.             else
    8563. 

  8563.             {                          /* get the proper values */
    8564. 

  8564.               iFGr16 = mng_get_uint16 (pDataline  );
    8565. 

  8565.               iFGg16 = mng_get_uint16 (pDataline+2);
    8566. 

  8566.               iFGb16 = mng_get_uint16 (pDataline+4);
    8567. 

  8567. 

  8568. 			                           /* scale background up */
    8569. 

  8569.               iBGb16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8570. 

  8570.               iBGg16 = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8571. 

  8571.               iBGr16 = (mng_uint8)(  *(pScanline  )         << 3 );
    8572. 

  8572. 

  8573.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    8574. 

  8574.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    8575. 

  8575.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    8576. 

  8576.                                        /* now compose */
    8577. 

  8577.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    8578. 

  8578.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    8579. 

  8579.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    8580. 

  8580.                                        /* and return the composed values */
    8581. 

  8581.               *(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGr16 >> 8) & 0xF8) >> 1 ) | (   (mng_uint8)(iFGg16 >> 8)         >> 6 ) );
    8582. 

  8582.               *pScanline     = (mng_uint8)( (mng_uint8) ((iFGb16 >>11)         >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
    8583. 

  8583.             }
    8584. 

  8584.           }
    8585. 

  8585. 

  8586.           pScanline += (pData->iColinc * 2);
    8587. 

  8587.           pDataline += 8;
    8588. 

  8588.         }
    8589. 

  8589.       }
    8590. 

  8590.       else
    8591. 

  8591.       {
    8592. 

  8592.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8593. 

  8593.              iX += pData->iColinc)
    8594. 

  8594.         {
    8595. 

  8595.           iA8 = *(pDataline+3);        /* get alpha value */
    8596. 

  8596. 

  8597.           if (iA8)                     /* any opacity at all ? */
    8598. 

  8598.           {
    8599. 

  8599.             if (iA8 == 0xFF)           /* fully opaque ? */
    8600. 

  8600.             {                          /* then simply copy the values */
    8601. 

  8601.               *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8602. 

  8602.               *pScanline     = (mng_uint8)( ( *(pDataline+2)         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8603. 

  8603.             }
    8604. 

  8604.             else
    8605. 

  8605.             {                          /* do alpha composing */
    8606. 

  8606.               mng_uint8 iRed, iGreen, iBlue;
    8607. 

  8607. 

  8608.               iRed   = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8609. 

  8609.               iGreen = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8610. 

  8610.               iBlue  = (mng_uint8)(  *(pScanline  )         << 3 );
    8611. 

  8611. 

  8612.               MNG_COMPOSE8 (iRed,     *(pDataline+0), iA8, iRed    );
    8613. 

  8613.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8614. 

  8614.               MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    8615. 

  8615. 

  8616.               *(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 )  |  (  iGreen         >> 6 ) );
    8617. 

  8617.               *pScanline     = (mng_uint8)(   (iBlue        >> 3 )  |  ( (iGreen & 0xF8) << 2 ) );
    8618. 

  8618.             }
    8619. 

  8619.           }
    8620. 

  8620. 

  8621.           pScanline += (pData->iColinc * 2);
    8622. 

  8622.           pDataline += 4;
    8623. 

  8623.         }
    8624. 

  8624.       }
    8625. 

  8625.     }
    8626. 

  8626.   }
    8627. 

  8627. 

  8628.   check_update_region (pData);
    8629. 

  8629. 

  8630. #ifdef MNG_SUPPORT_TRACE
    8631. 

  8631.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
    8632. 

  8632. #endif
    8633. 

  8633. 

  8634.   return MNG_NOERROR;
    8635. 

  8635. }
    8636. 

  8636. #else /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    8637. 

  8637. mng_retcode mng_display_bgr555 (mng_datap pData)
    8638. 

  8638. {
    8639. 

  8639.   mng_uint8p pScanline;
    8640. 

  8640.   mng_uint8p pDataline;
    8641. 

  8641.   mng_int32  iX;
    8642. 

  8642.   mng_uint16 iA16;
    8643. 

  8643.   mng_uint16 iFGr16, iFGg16, iFGb16;
    8644. 

  8644.   mng_uint16 iBGr16, iBGg16, iBGb16;
    8645. 

  8645.   mng_uint8  iA8;
    8646. 

  8646.   mng_uint8  iBps;
    8647. 

  8647. 

  8648. #ifdef MNG_SUPPORT_TRACE
    8649. 

  8649.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
    8650. 

  8650. #endif
    8651. 

  8651. 

  8652.   iBps=(mng_uint8)(pData->bIsRGBA16 ? 2:1);
    8653. 

  8653.                                        /* viewable row ? */
    8654. 

  8654.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8655. 

  8655.   {                                    /* address destination row */
    8656. 

  8656.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8657. 

  8657.                                                    pData->iRow + pData->iDestt -
    8658. 

  8658.                                                    pData->iSourcet);
    8659. 

  8659.                                        /* adjust destination row starting-point */
    8660. 

  8660.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8661. 

  8661.     pDataline = pData->pRGBArow;       /* address source row */
    8662. 

  8662. 

  8663.     /* adjust source row starting-point */
    8664. 

  8664.     pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << (iBps+1));
    8665. 

  8665. 

  8666.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8667. 

  8667.     {
    8668. 

  8668.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8669. 

  8669.              iX += pData->iColinc)
    8670. 

  8670.         {                              /* scale down by dropping the LSB */
    8671. 

  8671.           *(pScanline+1) = (mng_uint8)( ((*(pDataline       ) & 0xF8) >> 1 ) |  (*(pDataline+iBps)         >> 6 ) );
    8672. 

  8672.           *pScanline     = (mng_uint8)( ( *(pDataline+2*iBps)         >> 3 ) | ((*(pDataline+iBps) & 0xF8) << 2 ) );
    8673. 

  8673. 

  8674.           pScanline += (pData->iColinc * 2);
    8675. 

  8675.           pDataline += 4*iBps;
    8676. 

  8676.         }
    8677. 

  8677.     }
    8678. 

  8678.     else
    8679. 

  8679.     {
    8680. 

  8680.       if (pData->bIsRGBA16)            /* 16-bit input row ? */
    8681. 

  8681.       {
    8682. 

  8682. 

  8683.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8684. 

  8684.              iX += pData->iColinc)
    8685. 

  8685.         {
    8686. 

  8686.           iA16 = mng_get_uint16 (pDataline+6);
    8687. 

  8687. 

  8688.           if (iA16)                    /* any opacity at all ? */
    8689. 

  8689.           {
    8690. 

  8690.             if (iA16 == 0xFFFF)        /* fully opaque ? */
    8691. 

  8691.             {                          /* scale down by dropping the LSB */
    8692. 

  8692.               *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+2)         >> 6 ) );
    8693. 

  8693.               *pScanline     = (mng_uint8)( ( *(pDataline+4)         >> 3 ) | ((*(pDataline+2) & 0xF8) << 2 ) );
    8694. 

  8694.             }
    8695. 

  8695.             else
    8696. 

  8696.             {                          /* get the proper values */
    8697. 

  8697.               iFGr16 = mng_get_uint16 (pDataline  );
    8698. 

  8698.               iFGg16 = mng_get_uint16 (pDataline+2);
    8699. 

  8699.               iFGb16 = mng_get_uint16 (pDataline+4);
    8700. 

  8700. 

  8701. 			                           /* scale background up */
    8702. 

  8702.               iBGb16 = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8703. 

  8703.               iBGg16 = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8704. 

  8704.               iBGr16 = (mng_uint8)(  *(pScanline  )         << 3 );
    8705. 

  8705. 

  8706.               iBGr16 = (mng_uint16)((mng_uint32)iBGr16 << 8) | iBGr16;
    8707. 

  8707.               iBGg16 = (mng_uint16)((mng_uint32)iBGg16 << 8) | iBGg16;
    8708. 

  8708.               iBGb16 = (mng_uint16)((mng_uint32)iBGb16 << 8) | iBGb16;
    8709. 

  8709.                                        /* now compose */
    8710. 

  8710.               MNG_COMPOSE16(iFGr16, iFGr16, iA16, iBGr16);
    8711. 

  8711.               MNG_COMPOSE16(iFGg16, iFGg16, iA16, iBGg16);
    8712. 

  8712.               MNG_COMPOSE16(iFGb16, iFGb16, iA16, iBGb16);
    8713. 

  8713.                                        /* and return the composed values */
    8714. 

  8714.               *(pScanline+1) = (mng_uint8)( (mng_uint8)(((iFGr16 >> 8) & 0xF8) >> 1 ) | (   (mng_uint8)(iFGg16 >> 8)         >> 6 ) );
    8715. 

  8715.               *pScanline     = (mng_uint8)( (mng_uint8) ((iFGb16 >>11)         >> 3 ) | ( ( (mng_uint8)(iFGg16 >> 8) & 0xF8) << 2 ) );
    8716. 

  8716.             }
    8717. 

  8717.           }
    8718. 

  8718. 

  8719.           pScanline += (pData->iColinc * 2);
    8720. 

  8720.           pDataline += 8;
    8721. 

  8721.         }
    8722. 

  8722.       }
    8723. 

  8723.       else
    8724. 

  8724.       {
    8725. 

  8725.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8726. 

  8726.              iX += pData->iColinc)
    8727. 

  8727.         {
    8728. 

  8728.           iA8 = *(pDataline+3);        /* get alpha value */
    8729. 

  8729. 

  8730.           if (iA8)                     /* any opacity at all ? */
    8731. 

  8731.           {
    8732. 

  8732.             if (iA8 == 0xFF)           /* fully opaque ? */
    8733. 

  8733.             {                          /* then simply copy the values */
    8734. 

  8734.               *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8735. 

  8735.               *pScanline     = (mng_uint8)( ( *(pDataline+2)         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8736. 

  8736.             }
    8737. 

  8737.             else
    8738. 

  8738.             {                          /* do alpha composing */
    8739. 

  8739.               mng_uint8 iRed, iGreen, iBlue;
    8740. 

  8740. 

  8741.               iRed   = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8742. 

  8742.               iGreen = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8743. 

  8743.               iBlue  = (mng_uint8)(  *(pScanline  )         << 3 );
    8744. 

  8744. 

  8745.               MNG_COMPOSE8 (iRed,     *(pDataline+0), iA8, iRed    );
    8746. 

  8746.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8747. 

  8747.               MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    8748. 

  8748. 

  8749.               *(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 )  |  (  iGreen         >> 6 ) );
    8750. 

  8750.               *pScanline     = (mng_uint8)(   (iBlue        >> 3 )  |  ( (iGreen & 0xF8) << 2 ) );
    8751. 

  8751.             }
    8752. 

  8752.           }
    8753. 

  8753. 

  8754.           pScanline += (pData->iColinc * 2);
    8755. 

  8755.           pDataline += 4;
    8756. 

  8756.         }
    8757. 

  8757.       }
    8758. 

  8758.     }
    8759. 

  8759.   }
    8760. 

  8760. 

  8761.   check_update_region (pData);
    8762. 

  8762. 

  8763. #ifdef MNG_SUPPORT_TRACE
    8764. 

  8764.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
    8765. 

  8765. #endif
    8766. 

  8766. 

  8767.   return MNG_NOERROR;
    8768. 

  8768. }
    8769. 

  8769. #endif /* MNG_OPTIMIZE_FOOTPRINT_COMPOSE */
    8770. 

  8770. #else /* MNG_NO_16BIT_SUPPORT */
    8771. 

  8771. mng_retcode mng_display_bgr555 (mng_datap pData)
    8772. 

  8772. {
    8773. 

  8773.   mng_uint8p pScanline;
    8774. 

  8774.   mng_uint8p pDataline;
    8775. 

  8775.   mng_int32  iX;
    8776. 

  8776.   mng_uint8  iA8;
    8777. 

  8777. 

  8778. #ifdef MNG_SUPPORT_TRACE
    8779. 

  8779.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_START);
    8780. 

  8780. #endif
    8781. 

  8781.                                        /* viewable row ? */
    8782. 

  8782.   if ((pData->iRow >= pData->iSourcet) && (pData->iRow < pData->iSourceb))
    8783. 

  8783.   {                                    /* address destination row */
    8784. 

  8784.     pScanline = (mng_uint8p)pData->fGetcanvasline (((mng_handle)pData),
    8785. 

  8785.                                                    pData->iRow + pData->iDestt -
    8786. 

  8786.                                                    pData->iSourcet);
    8787. 

  8787.                                        /* adjust destination row starting-point */
    8788. 

  8788.     pScanline = pScanline + (pData->iCol * 2) + (pData->iDestl * 2);
    8789. 

  8789.     pDataline = pData->pRGBArow;       /* address source row */
    8790. 

  8790. 

  8791.       pDataline = pDataline + ((pData->iSourcel / pData->iColinc) << 2);
    8792. 

  8792. 

  8793.     if (pData->bIsOpaque)              /* forget about transparency ? */
    8794. 

  8794.     {
    8795. 

  8795.       {
    8796. 

  8796.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8797. 

  8797.              iX += pData->iColinc)
    8798. 

  8798.         {                              /* copy the values */
    8799. 

  8799.           *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8800. 

  8800.           *pScanline     = (mng_uint8)( ( *(pDataline+2)         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8801. 

  8801. 

  8802.           pScanline += (pData->iColinc * 2);
    8803. 

  8803.           pDataline += 4;
    8804. 

  8804.         }
    8805. 

  8805.       }
    8806. 

  8806.     }
    8807. 

  8807.     else
    8808. 

  8808.     {
    8809. 

  8809.       {
    8810. 

  8810.         for (iX = pData->iSourcel + pData->iCol; iX < pData->iSourcer;
    8811. 

  8811.              iX += pData->iColinc)
    8812. 

  8812.         {
    8813. 

  8813.           iA8 = *(pDataline+3);        /* get alpha value */
    8814. 

  8814. 

  8815.           if (iA8)                     /* any opacity at all ? */
    8816. 

  8816.           {
    8817. 

  8817.             if (iA8 == 0xFF)           /* fully opaque ? */
    8818. 

  8818.             {                          /* then simply copy the values */
    8819. 

  8819.               *(pScanline+1) = (mng_uint8)( ((*(pDataline  ) & 0xF8) >> 1 ) |  (*(pDataline+1)         >> 6 ) );
    8820. 

  8820.               *pScanline     = (mng_uint8)( ( *(pDataline+2)         >> 3 ) | ((*(pDataline+1) & 0xF8) << 2 ) );
    8821. 

  8821.             }
    8822. 

  8822.             else
    8823. 

  8823.             {                          /* do alpha composing */
    8824. 

  8824.               mng_uint8 iRed, iGreen, iBlue;
    8825. 

  8825. 

  8826.               iRed   = (mng_uint8)( (*(pScanline+1) & 0xF8) << 1 );
    8827. 

  8827.               iGreen = (mng_uint8)( (*(pScanline+1)         << 6 )  |  ( ((*pScanline) & 0xE0) >> 2 ) );
    8828. 

  8828.               iBlue  = (mng_uint8)(  *(pScanline  )         << 3 );
    8829. 

  8829. 

  8830.               MNG_COMPOSE8 (iRed,     *(pDataline+0), iA8, iRed    );
    8831. 

  8831.               MNG_COMPOSE8 (iGreen,   *(pDataline+1), iA8, iGreen  );
    8832. 

  8832.               MNG_COMPOSE8 (iBlue,    *(pDataline+2), iA8, iBlue   );
    8833. 

  8833. 

  8834.               *(pScanline+1) = (mng_uint8)( ( (iRed & 0xF8) >> 1 )  |  (  iGreen         >> 6 ) );
    8835. 

  8835.               *pScanline     = (mng_uint8)(   (iBlue        >> 3 )  |  ( (iGreen & 0xF8) << 2 ) );
    8836. 

  8836.             }
    8837. 

  8837.           }
    8838. 

  8838. 

  8839.           pScanline += (pData->iColinc * 2);
    8840. 

  8840.           pDataline += 4;
    8841. 

  8841.         }
    8842. 

  8842.       }
    8843. 

  8843.     }
    8844. 

  8844.   }
    8845. 

  8845. 

  8846.   check_update_region (pData);
    8847. 

  8847. 

  8848. #ifdef MNG_SUPPORT_TRACE
    8849. 

  8849.   MNG_TRACE (pData, MNG_FN_DISPLAY_BGR555, MNG_LC_END);
    8850. 

  8850. #endif
    8851. 

  8851. 

  8852.   return MNG_NOERROR;
    8853. 

  8853. }
    8854. 

  8854. #endif /* MNG_NO_16BIT_SUPPORT */
    8855. 

  8855. #endif /* MNG_SKIPCANVAS_BGR555 */
    8856. 

  8856. 

  8857. 

  8858. #ifndef MNG_SKIPCHUNK_BACK
    8859. 

  8859. /* ************************************************************************** */
    8860. 

  8860. /* *                                                                        * */
    8861. 

  8861. /* * Background restore routines - restore the background with info from    * */
    8862. 

  8862. /* * the BACK and/or bKGD chunk or the app's background canvas              * */
    8863. 

  8863. /* *                                                                        * */
    8864. 

  8864. /* ************************************************************************** */
    8865. 

  8865. 

  8866. mng_retcode mng_restore_bkgd_backimage (mng_datap pData)
    8867. 

  8867. {
    8868. 

  8868.                                        /* save some stuff */
    8869. 

  8869.   mng_uint8p  pRGBArow    = pData->pRGBArow;
    8870. 

  8870.   mng_int32   iRow        = pData->iRow;
    8871. 

  8871.   mng_int32   iRowsamples = pData->iRowsamples;
    8872. 

  8872. 

  8873.   mng_retcode iRetcode;                /* work variables */
    8874. 

  8874.   mng_uint8p  pTemp;
    8875. 

  8875.   mng_uint8p  pWork       = pRGBArow;
    8876. 

  8876.   mng_uint32  iX;
    8877. 

  8877.   mng_int32   iZ;
    8878. 

  8878. 

  8879. #ifdef MNG_SUPPORT_TRACE
    8880. 

  8880.   MNG_TRACE (pData, MNG_FN_RESTORE_BACKIMAGE, MNG_LC_START);
    8881. 

  8881. #endif
    8882. 

  8882.                                        /* determine row to retrieve */
    8883. 

  8883.   pData->iRow        = pData->iDestt + iRow + pData->iBackimgoffsy;
    8884. 

  8884. 

  8885.   while (pData->iRow >= (mng_int32)pData->iBackimgheight)
    8886. 

  8886.     pData->iRow -= (mng_int32)pData->iBackimgheight;
    8887. 

  8887.                                        /* set width to that of background image */
    8888. 

  8888.   pData->iRowsamples = pData->iBackimgwidth;
    8889. 

  8889.                                        /* retrieve into alternate buffer ! */
    8890. 

  8890.   pData->pRGBArow    = pData->pPrevrow;
    8891. 

  8891.                                        /* get it then */
    8892. 

  8892.   iRetcode = ((mng_retrieverow)pData->fRetrieverow) (pData);
    8893. 

  8893. 

  8894.   if (iRetcode)                        /* on error; bail out */
    8895. 

  8895.     return iRetcode;
    8896. 

  8896.                                        /* we got the full row; but now need to
    8897. 

  8897.                                           paste it into the proper location */
    8898. 

  8898.   iX = pData->iDestl - pData->iBackimgoffsx;
    8899. 

  8899. 

  8900.   while (iX >= pData->iBackimgwidth)
    8901. 

  8901.     iX -= pData->iBackimgwidth;
    8902. 

  8902. 

  8903. #ifndef MNG_NO_16BIT_SUPPORT
    8904. 

  8904.   if (pData->bIsRGBA16)                /* 16-bit buffer ? */
    8905. 

  8905.   {
    8906. 

  8906.     pTemp = pData->pPrevrow + (iX << 3);
    8907. 

  8907. 

  8908.     for (iZ = (pData->iDestr - pData->iDestl); iZ > 0; iZ--)
    8909. 

  8909.     {
    8910. 

  8910.       MNG_COPY (pWork, pTemp, 8);
    8911. 

  8911. 

  8912.       pWork += 8;
    8913. 

  8913.       pTemp += 8;
    8914. 

  8914.       iX++;
    8915. 

  8915.                                        /* reached end of bkgd-image line ? */
    8916. 

  8916.       if (iX >= pData->iBackimgwidth)
    8917. 

  8917.       {
    8918. 

  8918.         iX    = 0;
    8919. 

  8919.         pTemp = pData->pPrevrow;
    8920. 

  8920.       }
    8921. 

  8921.     }
    8922. 

  8922.   }
    8923. 

  8923.   else
    8924. 

  8924. #endif
    8925. 

  8925.   {
    8926. 

  8926.     pTemp = pData->pPrevrow + (iX << 2);
    8927. 

  8927. 

  8928.     for (iZ = (pData->iDestr - pData->iDestl); iZ > 0; iZ--)
    8929. 

  8929.     {
    8930. 

  8930.       MNG_COPY (pWork, pTemp, 4);
    8931. 

  8931. 

  8932.       pWork += 4;
    8933. 

  8933.       pTemp += 4;
    8934. 

  8934.       iX++;
    8935. 

  8935.                                        /* reached end of bkgd-image line ? */
    8936. 

  8936.       if (iX >= pData->iBackimgwidth)
    8937. 

  8937.       {
    8938. 

  8938.         iX    = 0;
    8939. 

  8939.         pTemp = pData->pPrevrow;
    8940. 

  8940.       }
    8941. 

  8941.     }
    8942. 

  8942.   }
    8943. 

  8943. 

  8944.   pData->pRGBArow    = pRGBArow;       /* restore original values */
    8945. 

  8945.   pData->iRow        = iRow;
    8946. 

  8946.   pData->iRowsamples = iRowsamples;
    8947. 

  8947. 

  8948. #ifdef MNG_SUPPORT_TRACE
    8949. 

  8949.   MNG_TRACE (pData, MNG_FN_RESTORE_BACKIMAGE, MNG_LC_END);
    8950. 

  8950. #endif
    8951. 

  8951. 

  8952.   return MNG_NOERROR;
    8953. 

  8953. }
    8954. 

  8954. #endif
    8955. 

  8955. 

  8956. /* ************************************************************************** */
    8957. 

  8957. 

  8958. mng_retcode mng_restore_bkgd_backcolor (mng_datap pData)
    8959. 

  8959. {
    8960. 

  8960.   mng_int32   iX;
    8961. 

  8961.   mng_uint32p pWork32 = (mng_uint32p)pData->pRGBArow;
    8962. 

  8962.   mng_uint32  iWrite;
    8963. 

  8963. 

  8964. #ifdef MNG_SUPPORT_TRACE
    8965. 

  8965.   MNG_TRACE (pData, MNG_FN_RESTORE_BACKCOLOR, MNG_LC_START);
    8966. 

  8966. #endif
    8967. 

  8967. 

  8968. #ifdef MNG_BIGENDIAN_SUPPORTED
    8969. 

  8969.   /* fast way for big endian */
    8970. 

  8970.   iWrite = (((mng_uint8)(pData->iBACKred   >> 8)) << 24) |
    8971. 

  8971. 		   (((mng_uint8)(pData->iBACKgreen >> 8)) << 16) |
    8972. 

  8972. 		   (((mng_uint8)(pData->iBACKblue  >> 8)) <<  8) |
    8973. 

  8973.            ( 0xFF                                      );
    8974. 

  8974. #elif defined(MNG_LITTLEENDIAN_SUPPORTED)
    8975. 

  8975.   /* fast way for little endian */
    8976. 

  8976.   iWrite = ( 0xFF                                 << 24) |
    8977. 

  8977.            (((mng_uint8)(pData->iBACKblue  >> 8)) << 16) |
    8978. 

  8978. 		   (((mng_uint8)(pData->iBACKgreen >> 8)) <<  8) |
    8979. 

  8979. 		   (((mng_uint8)(pData->iBACKred   >> 8))      );
    8980. 

  8980. #else
    8981. 

  8981.   /* generic way, works on all platforms */
    8982. 

  8982.   /* put the data in memory in the correct order */
    8983. 

  8983.   {
    8984. 

  8984.     mng_uint8 aBytes[4];
    8985. 

  8985.     aBytes[0] = (mng_uint8)(pData->iBACKred   >> 8);
    8986. 

  8986.     aBytes[1] = (mng_uint8)(pData->iBACKgreen >> 8);
    8987. 

  8987.     aBytes[2] = (mng_uint8)(pData->iBACKblue  >> 8);
    8988. 

  8988.     aBytes[3] = 0xFF;
    8989. 

  8989.     /* load that data into a register */
    8990. 

  8990.     iWrite = *(mng_uint32*) aBytes;
    8991. 

  8991.   }
    8992. 

  8992. #endif
    8993. 

  8993.                                        /* ok; drop the background-color in there */
    8994. 

  8994.   for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    8995. 

  8995.     *pWork32++ = iWrite;
    8996. 

  8996. 

  8997. #ifdef MNG_SUPPORT_TRACE
    8998. 

  8998.   MNG_TRACE (pData, MNG_FN_RESTORE_BACKCOLOR, MNG_LC_END);
    8999. 

  8999. #endif
    9000. 

  9000. 

  9001.   return MNG_NOERROR;
    9002. 

  9002. }
    9003. 

  9003. 

  9004. /* ************************************************************************** */
    9005. 

  9005. 

  9006. #ifndef MNG_SKIPCHUNK_bKGD
    9007. 

  9007. mng_retcode mng_restore_bkgd_bkgd (mng_datap pData)
    9008. 

  9008. {
    9009. 

  9009.   mng_int32      iX;
    9010. 

  9010.   mng_uint8p     pWork   = pData->pRGBArow;
    9011. 

  9011.   mng_imagep     pImage  = (mng_imagep)pData->pCurrentobj;
    9012. 

  9012.   mng_imagedatap pBuf    = pImage->pImgbuf;
    9013. 

  9013.   mng_uint8      iRed    = 0;
    9014. 

  9014.   mng_uint8      iGreen  = 0;
    9015. 

  9015.   mng_uint8      iBlue   = 0;
    9016. 

  9016.   mng_uint32p    pWork32 = (mng_uint32p)pWork;
    9017. 

  9017.   mng_uint32     iWrite;
    9018. 

  9018. 

  9019. #ifdef MNG_SUPPORT_TRACE
    9020. 

  9020.   MNG_TRACE (pData, MNG_FN_RESTORE_BKGD, MNG_LC_START);
    9021. 

  9021. #endif
    9022. 

  9022. 

  9023.   switch (pBuf->iColortype)
    9024. 

  9024.   {
    9025. 

  9025.     case 0 : ;                         /* gray types */
    9026. 

  9026.     case 4 : {
    9027. 

  9027.                mng_uint8 iGray;
    9028. 

  9028. 

  9029. #ifndef MNG_NO_16BIT_SUPPORT
    9030. 

  9030.                if (pBuf->iBitdepth > 8)
    9031. 

  9031.                  iGray = (mng_uint8)(pBuf->iBKGDgray >> 8);
    9032. 

  9032.                else
    9033. 

  9033. #endif
    9034. 

  9034.                {
    9035. 

  9035. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    9036. 

  9036.                  /* LBR scaling */
    9037. 

  9037.                  mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1};
    9038. 

  9038.                  iGray = (mng_uint8)(multiplier[pBuf->iBitdepth] * pBuf->iBKGDgray);
    9039. 

  9039. #else
    9040. 

  9040.                  iGray = (mng_uint8)pBuf->iBKGDgray;
    9041. 

  9041. #endif
    9042. 

  9042.                }
    9043. 

  9043. 

  9044.                iRed   = iGray;
    9045. 

  9045.                iGreen = iGray;
    9046. 

  9046.                iBlue  = iGray;
    9047. 

  9047. 

  9048.                break;
    9049. 

  9049.              }
    9050. 

  9050. 

  9051.     case 3 : {                         /* indexed type */
    9052. 

  9052.                iRed   = pBuf->aPLTEentries [pBuf->iBKGDindex].iRed;
    9053. 

  9053.                iGreen = pBuf->aPLTEentries [pBuf->iBKGDindex].iGreen;
    9054. 

  9054.                iBlue  = pBuf->aPLTEentries [pBuf->iBKGDindex].iBlue;
    9055. 

  9055. 

  9056.                break;
    9057. 

  9057.              }
    9058. 

  9058. 

  9059.     case 2 : ;                         /* rgb types */
    9060. 

  9060.     case 6 : {
    9061. 

  9061. #ifndef MNG_NO_16BIT_SUPPORT
    9062. 

  9062.                if (pBuf->iBitdepth > 8)
    9063. 

  9063.                {
    9064. 

  9064.                  iRed   = (mng_uint8)(pBuf->iBKGDred   >> 8);
    9065. 

  9065.                  iGreen = (mng_uint8)(pBuf->iBKGDgreen >> 8);
    9066. 

  9066.                  iBlue  = (mng_uint8)(pBuf->iBKGDblue  >> 8);
    9067. 

  9067.                }
    9068. 

  9068.                else
    9069. 

  9069. #endif
    9070. 

  9070.                {
    9071. 

  9071.                  iRed   = (mng_uint8)(pBuf->iBKGDred  );
    9072. 

  9072.                  iGreen = (mng_uint8)(pBuf->iBKGDgreen);
    9073. 

  9073.                  iBlue  = (mng_uint8)(pBuf->iBKGDblue );
    9074. 

  9074.                }
    9075. 

  9075. 

  9076.                break;
    9077. 

  9077.              }
    9078. 

  9078.   }
    9079. 

  9079. 

  9080. #ifdef MNG_BIGENDIAN_SUPPORTED
    9081. 

  9081.   /* fast way for big endian */
    9082. 

  9082.   iWrite = (iRed   << 24) |
    9083. 

  9083. 		   (iGreen << 16) |
    9084. 

  9084. 		   (iBlue  <<  8);
    9085. 

  9085. #elif defined(MNG_LITTLEENDIAN_SUPPORTED)
    9086. 

  9086.   /* fast way for little endian */
    9087. 

  9087.   iWrite = (iBlue  << 16) |
    9088. 

  9088. 		   (iGreen <<  8) |
    9089. 

  9089. 		   (iRed        );
    9090. 

  9090. #else
    9091. 

  9091.   /* generic way, works on all platforms */
    9092. 

  9092.   /* put the data in memory in the correct order */
    9093. 

  9093.   {
    9094. 

  9094.     mng_uint8 aBytes[4];
    9095. 

  9095.     aBytes[0] = (mng_uint8)(iRed);
    9096. 

  9096.     aBytes[1] = (mng_uint8)(iGreen);
    9097. 

  9097.     aBytes[2] = (mng_uint8)(iBlue);
    9098. 

  9098.     aBytes[3] = 0x00;
    9099. 

  9099.     /* load that data into a register */
    9100. 

  9100.     iWrite = *(mng_uint32*) aBytes;
    9101. 

  9101.   }
    9102. 

  9102. #endif
    9103. 

  9103.                                        /* ok; drop it in there */
    9104. 

  9104.   for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9105. 

  9105.     *pWork32++ = iWrite;
    9106. 

  9106. 

  9107. #ifdef MNG_SUPPORT_TRACE
    9108. 

  9108.   MNG_TRACE (pData, MNG_FN_RESTORE_BKGD, MNG_LC_END);
    9109. 

  9109. #endif
    9110. 

  9110. 

  9111.   return MNG_NOERROR;
    9112. 

  9112. }
    9113. 

  9113. #endif
    9114. 

  9114. 

  9115. /* ************************************************************************** */
    9116. 

  9116. 

  9117. mng_retcode mng_restore_bkgd_bgcolor (mng_datap pData)
    9118. 

  9118. {
    9119. 

  9119.   mng_int32   iX;
    9120. 

  9120.   mng_uint32p pWork32 = (mng_uint32p)pData->pRGBArow;
    9121. 

  9121.   mng_uint32  iWrite;
    9122. 

  9122. 

  9123. #ifdef MNG_SUPPORT_TRACE
    9124. 

  9124.   MNG_TRACE (pData, MNG_FN_RESTORE_BGCOLOR, MNG_LC_START);
    9125. 

  9125. #endif
    9126. 

  9126. 

  9127. #ifdef MNG_BIGENDIAN_SUPPORTED
    9128. 

  9128.   /* fast way for big endian */
    9129. 

  9129.   iWrite = (((mng_uint8)(pData->iBGred   >> 8)) << 24) |
    9130. 

  9130. 		   (((mng_uint8)(pData->iBGgreen >> 8)) << 16) |
    9131. 

  9131. 		   (((mng_uint8)(pData->iBGblue  >> 8)) <<  8);
    9132. 

  9132. #elif defined(MNG_LITTLEENDIAN_SUPPORTED)
    9133. 

  9133.   /* fast way for little endian */
    9134. 

  9134.   iWrite = (((mng_uint8)(pData->iBGblue  >> 8)) << 16) |
    9135. 

  9135. 		   (((mng_uint8)(pData->iBGgreen >> 8)) <<  8) |
    9136. 

  9136. 		   (((mng_uint8)(pData->iBGred   >> 8))      );
    9137. 

  9137. #else
    9138. 

  9138.   /* generic way, works on all platforms */
    9139. 

  9139.   /* put the data in memory in the correct order */
    9140. 

  9140.   {
    9141. 

  9141.     mng_uint8 aBytes[4];
    9142. 

  9142.     aBytes[0] = (mng_uint8)(pData->iBGred   >> 8);
    9143. 

  9143.     aBytes[1] = (mng_uint8)(pData->iBGgreen >> 8);
    9144. 

  9144.     aBytes[2] = (mng_uint8)(pData->iBGblue  >> 8);
    9145. 

  9145.     aBytes[3] = 0x00;
    9146. 

  9146.     /* load that data into a register */
    9147. 

  9147.     iWrite = *(mng_uint32*) aBytes;
    9148. 

  9148.   }
    9149. 

  9149. #endif
    9150. 

  9150.                                        /* ok; drop the background-color in there */
    9151. 

  9151.   for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9152. 

  9152.     *pWork32++ = iWrite;
    9153. 

  9153. 

  9154. #ifdef MNG_SUPPORT_TRACE
    9155. 

  9155.   MNG_TRACE (pData, MNG_FN_RESTORE_BGCOLOR, MNG_LC_END);
    9156. 

  9156. #endif
    9157. 

  9157. 

  9158.   return MNG_NOERROR;
    9159. 

  9159. }
    9160. 

  9160. 

  9161. /* ************************************************************************** */
    9162. 

  9162. 

  9163. #ifndef MNG_SKIPCANVAS_RGB8
    9164. 

  9164. mng_retcode mng_restore_bkgd_rgb8 (mng_datap pData)
    9165. 

  9165. {
    9166. 

  9166.   mng_int32  iX;
    9167. 

  9167.   mng_uint8p pBkgd;
    9168. 

  9168.   mng_uint8p pWork = pData->pRGBArow;
    9169. 

  9169. 

  9170. #ifdef MNG_SUPPORT_TRACE
    9171. 

  9171.   MNG_TRACE (pData, MNG_FN_RESTORE_RGB8, MNG_LC_START);
    9172. 

  9172. #endif
    9173. 

  9173. 

  9174.   if (pData->fGetbkgdline)             /* can we access the background ? */
    9175. 

  9175.   {                                    /* point to the right pixel then */
    9176. 

  9176.     pBkgd = (mng_uint8p)pData->fGetbkgdline ((mng_handle)pData,
    9177. 

  9177.                                              pData->iRow + pData->iDestt) +
    9178. 

  9178.             (3 * pData->iDestl);
    9179. 

  9179. 

  9180.     for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9181. 

  9181.     {
    9182. 

  9182.       *pWork     = *pBkgd;             /* ok; copy the pixel */
    9183. 

  9183.       *(pWork+1) = *(pBkgd+1);
    9184. 

  9184.       *(pWork+2) = *(pBkgd+2);
    9185. 

  9185.       *(pWork+3) = 0x00;               /* transparant for alpha-canvasses */
    9186. 

  9186. 

  9187.       pWork += 4;
    9188. 

  9188.       pBkgd += 3;
    9189. 

  9189.     }
    9190. 

  9190.   }
    9191. 

  9191. 

  9192. #ifdef MNG_SUPPORT_TRACE
    9193. 

  9193.   MNG_TRACE (pData, MNG_FN_RESTORE_RGB8, MNG_LC_END);
    9194. 

  9194. #endif
    9195. 

  9195. 

  9196.   return MNG_NOERROR;
    9197. 

  9197. }
    9198. 

  9198. #endif /* MNG_SKIPCANVAS_RGB8 */
    9199. 

  9199. 

  9200. /* ************************************************************************** */
    9201. 

  9201. 

  9202. #ifndef MNG_SKIPCANVAS_BGR8
    9203. 

  9203. mng_retcode mng_restore_bkgd_bgr8 (mng_datap pData)
    9204. 

  9204. {
    9205. 

  9205.   mng_int32  iX;
    9206. 

  9206.   mng_uint8p pBkgd;
    9207. 

  9207.   mng_uint8p pWork = pData->pRGBArow;
    9208. 

  9208. 

  9209. #ifdef MNG_SUPPORT_TRACE
    9210. 

  9210.   MNG_TRACE (pData, MNG_FN_RESTORE_BGR8, MNG_LC_START);
    9211. 

  9211. #endif
    9212. 

  9212. 

  9213.   if (pData->fGetbkgdline)             /* can we access the background ? */
    9214. 

  9214.   {                                    /* point to the right pixel then */
    9215. 

  9215.     pBkgd = (mng_uint8p)pData->fGetbkgdline ((mng_handle)pData,
    9216. 

  9216.                                              pData->iRow + pData->iDestt) +
    9217. 

  9217.             (3 * pData->iDestl);
    9218. 

  9218. 

  9219.     for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9220. 

  9220.     {
    9221. 

  9221.       *pWork     = *(pBkgd+2);         /* ok; copy the pixel */
    9222. 

  9222.       *(pWork+1) = *(pBkgd+1);
    9223. 

  9223.       *(pWork+2) = *pBkgd;
    9224. 

  9224.       *(pWork+3) = 0x00;               /* transparant for alpha-canvasses */
    9225. 

  9225. 

  9226.       pWork += 4;
    9227. 

  9227.       pBkgd += 3;
    9228. 

  9228.     }
    9229. 

  9229.   }
    9230. 

  9230. 

  9231. #ifdef MNG_SUPPORT_TRACE
    9232. 

  9232.   MNG_TRACE (pData, MNG_FN_RESTORE_BGR8, MNG_LC_END);
    9233. 

  9233. #endif
    9234. 

  9234. 

  9235.   return MNG_NOERROR;
    9236. 

  9236. }
    9237. 

  9237. #endif /* MNG_SKIPCANVAS_BGR8 */
    9238. 

  9238. 

  9239. /* ************************************************************************** */
    9240. 

  9240. 

  9241. #ifndef MNG_SKIPCANVAS_BGRX8
    9242. 

  9242. mng_retcode mng_restore_bkgd_bgrx8 (mng_datap pData)
    9243. 

  9243. {
    9244. 

  9244.   mng_int32  iX;
    9245. 

  9245.   mng_uint8p pBkgd;
    9246. 

  9246.   mng_uint8p pWork = pData->pRGBArow;
    9247. 

  9247. 

  9248. #ifdef MNG_SUPPORT_TRACE
    9249. 

  9249.   MNG_TRACE (pData, MNG_FN_RESTORE_BGRX8, MNG_LC_START);
    9250. 

  9250. #endif
    9251. 

  9251. 

  9252.   if (pData->fGetbkgdline)             /* can we access the background ? */
    9253. 

  9253.   {                                    /* point to the right pixel then */
    9254. 

  9254.     pBkgd = (mng_uint8p)pData->fGetbkgdline ((mng_handle)pData,
    9255. 

  9255.                                              pData->iRow + pData->iDestt) +
    9256. 

  9256.             (3 * pData->iDestl);
    9257. 

  9257. 

  9258.     for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9259. 

  9259.     {
    9260. 

  9260.       *pWork     = *(pBkgd+2);         /* ok; copy the pixel */
    9261. 

  9261.       *(pWork+1) = *(pBkgd+1);
    9262. 

  9262.       *(pWork+2) = *pBkgd;
    9263. 

  9263.       *(pWork+3) = 0x00;               /* transparant for alpha-canvasses */
    9264. 

  9264. 

  9265.       pWork += 4;
    9266. 

  9266.       pBkgd += 4;
    9267. 

  9267.     }
    9268. 

  9268.   }
    9269. 

  9269. 

  9270. #ifdef MNG_SUPPORT_TRACE
    9271. 

  9271.   MNG_TRACE (pData, MNG_FN_RESTORE_BGRX8, MNG_LC_END);
    9272. 

  9272. #endif
    9273. 

  9273. 

  9274.   return MNG_NOERROR;
    9275. 

  9275. }
    9276. 

  9276. #endif /* MNG_SKIPCANVAS_BGRX8 */
    9277. 

  9277. 

  9278. /* ************************************************************************** */
    9279. 

  9279. 

  9280. #ifndef MNG_SKIPCANVAS_BGR565
    9281. 

  9281. mng_retcode mng_restore_bkgd_bgr565 (mng_datap pData)
    9282. 

  9282. {
    9283. 

  9283.   mng_int32  iX;
    9284. 

  9284.   mng_uint8p pBkgd;
    9285. 

  9285.   mng_uint8p pWork = pData->pRGBArow;
    9286. 

  9286. 

  9287. #ifdef MNG_SUPPORT_TRACE
    9288. 

  9288.   MNG_TRACE (pData, MNG_FN_RESTORE_BGR565, MNG_LC_START);
    9289. 

  9289. #endif
    9290. 

  9290. 

  9291.   if (pData->fGetbkgdline)             /* can we access the background ? */
    9292. 

  9292.   {                                    /* point to the right pixel then */
    9293. 

  9293.     pBkgd = (mng_uint8p)pData->fGetbkgdline ((mng_handle)pData,
    9294. 

  9294.                                              pData->iRow + pData->iDestt) +
    9295. 

  9295.             (3 * pData->iDestl);
    9296. 

  9296. 

  9297.     for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9298. 

  9298.     {
    9299. 

  9299.       *pWork     = (mng_uint8)(  *(pBkgd+1) & 0xF8);             /* ok; copy the pixel */
    9300. 

  9300.       *(pWork+1) = (mng_uint8)( (*(pBkgd+1) << 5 )  |  ( ((*pBkgd)&0xE0)>>3 ) );
    9301. 

  9301.       *(pWork+2) = (mng_uint8)(  *(pBkgd) << 3 );
    9302. 

  9302.       *(pWork+3) = 0x00;               /* transparant for alpha-canvasses */
    9303. 

  9303. 

  9304.       pWork += 4;
    9305. 

  9305.       pBkgd += 2;
    9306. 

  9306.     }
    9307. 

  9307.   }
    9308. 

  9308. 

  9309. #ifdef MNG_SUPPORT_TRACE
    9310. 

  9310.   MNG_TRACE (pData, MNG_FN_RESTORE_BGR565, MNG_LC_END);
    9311. 

  9311. #endif
    9312. 

  9312. 

  9313.   return MNG_NOERROR;
    9314. 

  9314. }
    9315. 

  9315. #endif /* MNG_SKIPCANVAS_BGR565 */
    9316. 

  9316. 

  9317. /* ************************************************************************** */
    9318. 

  9318. 

  9319. #ifndef MNG_SKIPCANVAS_RGB565
    9320. 

  9320. mng_retcode mng_restore_bkgd_rgb565 (mng_datap pData)
    9321. 

  9321. {
    9322. 

  9322.   mng_int32  iX;
    9323. 

  9323.   mng_uint8p pBkgd;
    9324. 

  9324.   mng_uint8p pWork = pData->pRGBArow;
    9325. 

  9325. 

  9326. #ifdef MNG_SUPPORT_TRACE
    9327. 

  9327.   MNG_TRACE (pData, MNG_FN_RESTORE_RGB565, MNG_LC_START);
    9328. 

  9328. #endif
    9329. 

  9329. 

  9330.   if (pData->fGetbkgdline)             /* can we access the background ? */
    9331. 

  9331.   {                                    /* point to the right pixel then */
    9332. 

  9332.     pBkgd = (mng_uint8p)pData->fGetbkgdline ((mng_handle)pData,
    9333. 

  9333.                                              pData->iRow + pData->iDestt) +
    9334. 

  9334.             (3 * pData->iDestl);
    9335. 

  9335. 

  9336.     for (iX = (pData->iSourcer - pData->iSourcel); iX > 0; iX--)
    9337. 

  9337.     {
    9338. 

  9338.       *pWork     = (mng_uint8)(  *(pBkgd)&0xF8);             /* ok; copy the pixel */
    9339. 

  9339.       *(pWork+1) = (mng_uint8)( (*(pBkgd+1) << 5)  |  ( ((*pBkgd)&0xE0)>>3 ) );
    9340. 

  9340.       *(pWork+2) = (mng_uint8)(  *(pBkgd+1) << 3);
    9341. 

  9341.       *(pWork+3) = 0x00;               /* transparant for alpha-canvasses */
    9342. 

  9342. 

  9343.       pWork += 4;
    9344. 

  9344.       pBkgd += 2;
    9345. 

  9345.     }
    9346. 

  9346.   }
    9347. 

  9347. 

  9348. #ifdef MNG_SUPPORT_TRACE
    9349. 

  9349.   MNG_TRACE (pData, MNG_FN_RESTORE_RGB565, MNG_LC_END);
    9350. 

  9350. #endif
    9351. 

  9351. 

  9352.   return MNG_NOERROR;
    9353. 

  9353. }
    9354. 

  9354. #endif /* MNG_SKIPCANVAS_RBB565 */
    9355. 

  9355. 

  9356. 

  9357. /* ************************************************************************** */
    9358. 

  9358. /* *                                                                        * */
    9359. 

  9359. /* * Row retrieval routines - retrieve processed & uncompressed row-data    * */
    9360. 

  9360. /* * from the current "object"                                              * */
    9361. 

  9361. /* *                                                                        * */
    9362. 

  9362. /* ************************************************************************** */
    9363. 

  9363. 

  9364. /* TODO: a serious optimization is to retrieve only those pixels that will
    9365. 

  9365.          actually be displayed; this would require changes in
    9366. 

  9366.          the "display_image" routine (in mng_display.c) &
    9367. 

  9367.          all the "retrieve_xxx" routines below &
    9368. 

  9368.          the "display_xxx" routines above !!!!!
    9369. 

  9369.          NOTE that "correct_xxx" routines would not require modification */
    9370. 

  9370. 

  9371. mng_retcode mng_retrieve_g8 (mng_datap pData)
    9372. 

  9372. {
    9373. 

  9373.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9374. 

  9374.   mng_uint8p     pWorkrow;
    9375. 

  9375.   mng_uint8p     pRGBArow;
    9376. 

  9376.   mng_int32      iX;
    9377. 

  9377.   mng_uint8      iG;
    9378. 

  9378. 

  9379. #ifdef MNG_SUPPORT_TRACE
    9380. 

  9380.   MNG_TRACE (pData, MNG_FN_RETRIEVE_G8, MNG_LC_START);
    9381. 

  9381. #endif
    9382. 

  9382. 

  9383.   pRGBArow = pData->pRGBArow;          /* temporary work pointers */
    9384. 

  9384.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9385. 

  9385. 

  9386.   if (pBuf->bHasTRNS)                  /* tRNS in buffer ? */
    9387. 

  9387.   {
    9388. 

  9388. #ifdef MNG_DECREMENT_LOOPS
    9389. 

  9389.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9390. 

  9390. #else
    9391. 

  9391.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9392. 

  9392. #endif
    9393. 

  9393.     {
    9394. 

  9394.       iG = *pWorkrow;                  /* get the gray-value */
    9395. 

  9395.                                        /* is it transparent ? */
    9396. 

  9396.       if ((mng_uint16)iG == pBuf->iTRNSgray)
    9397. 

  9397.       {
    9398. 

  9398.         *pRGBArow     = 0x00;          /* nuttin to display */
    9399. 

  9399.         *(pRGBArow+1) = 0x00;
    9400. 

  9400.         *(pRGBArow+2) = 0x00;
    9401. 

  9401.         *(pRGBArow+3) = 0x00;
    9402. 

  9402.       }
    9403. 

  9403.       else
    9404. 

  9404.       {
    9405. 

  9405. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    9406. 

  9406.         mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1};
    9407. 

  9407.         iG = (mng_uint8)(iG * multiplier[pBuf->iBitdepth]);
    9408. 

  9408. #endif
    9409. 

  9409. 

  9410.         *pRGBArow     = iG;            /* put in intermediate row */
    9411. 

  9411.         *(pRGBArow+1) = iG;
    9412. 

  9412.         *(pRGBArow+2) = iG;
    9413. 

  9413.         *(pRGBArow+3) = 0xFF;
    9414. 

  9414.       }
    9415. 

  9415. 

  9416.       pWorkrow++;                      /* next pixel */
    9417. 

  9417.       pRGBArow += 4;
    9418. 

  9418.     }
    9419. 

  9419.   }
    9420. 

  9420.   else
    9421. 

  9421.   {
    9422. 

  9422. #ifdef MNG_DECREMENT_LOOPS
    9423. 

  9423.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9424. 

  9424. #else
    9425. 

  9425.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9426. 

  9426. #endif
    9427. 

  9427.     {
    9428. 

  9428. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    9429. 

  9429.       mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1};   /* LBR scaling */
    9430. 

  9430.       iG = (mng_uint8)(multiplier[pBuf->iBitdepth] * *pWorkrow);
    9431. 

  9431. #else
    9432. 

  9432.       iG = *pWorkrow;                  /* get the gray-value */
    9433. 

  9433. #endif
    9434. 

  9434. 

  9435.       *pRGBArow     = iG;              /* put in intermediate row */
    9436. 

  9436.       *(pRGBArow+1) = iG;
    9437. 

  9437.       *(pRGBArow+2) = iG;
    9438. 

  9438.       *(pRGBArow+3) = 0xFF;
    9439. 

  9439. 

  9440.       pWorkrow++;                      /* next pixel */
    9441. 

  9441.       pRGBArow += 4;
    9442. 

  9442.     }
    9443. 

  9443.   }
    9444. 

  9444. 

  9445. #ifdef MNG_SUPPORT_TRACE
    9446. 

  9446.   MNG_TRACE (pData, MNG_FN_RETRIEVE_G8, MNG_LC_END);
    9447. 

  9447. #endif
    9448. 

  9448. 

  9449.   return MNG_NOERROR;
    9450. 

  9450. }
    9451. 

  9451. 

  9452. /* ************************************************************************** */
    9453. 

  9453. 

  9454. #ifndef MNG_NO_16BIT_SUPPORT
    9455. 

  9455. mng_retcode mng_retrieve_g16 (mng_datap pData)
    9456. 

  9456. {
    9457. 

  9457.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9458. 

  9458.   mng_uint8p     pWorkrow;
    9459. 

  9459.   mng_uint8p     pRGBArow;
    9460. 

  9460.   mng_int32      iX;
    9461. 

  9461.   mng_uint16     iG;
    9462. 

  9462. 

  9463. #ifdef MNG_SUPPORT_TRACE
    9464. 

  9464.   MNG_TRACE (pData, MNG_FN_RETRIEVE_G16, MNG_LC_START);
    9465. 

  9465. #endif
    9466. 

  9466.                                        /* temporary work pointers */
    9467. 

  9467.   pRGBArow = pData->pRGBArow;
    9468. 

  9468.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9469. 

  9469. 

  9470.   if (pBuf->bHasTRNS)                  /* tRNS in buffer ? */
    9471. 

  9471.   {
    9472. 

  9472. #ifdef MNG_DECREMENT_LOOPS
    9473. 

  9473.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9474. 

  9474. #else
    9475. 

  9475.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9476. 

  9476. #endif
    9477. 

  9477.     {
    9478. 

  9478.       iG = mng_get_uint16 (pWorkrow);  /* get the gray-value */
    9479. 

  9479.                                        /* is it transparent ? */
    9480. 

  9480.       if (iG == pBuf->iTRNSgray)
    9481. 

  9481.       {                                /* nuttin to display */
    9482. 

  9482.         mng_put_uint16 (pRGBArow,   0x0000);
    9483. 

  9483.         mng_put_uint16 (pRGBArow+2, 0x0000);
    9484. 

  9484.         mng_put_uint16 (pRGBArow+4, 0x0000);
    9485. 

  9485.         mng_put_uint16 (pRGBArow+6, 0x0000);
    9486. 

  9486.       }
    9487. 

  9487.       else
    9488. 

  9488.       {                                /* put in intermediate row */
    9489. 

  9489.         mng_put_uint16 (pRGBArow,   iG);
    9490. 

  9490.         mng_put_uint16 (pRGBArow+2, iG);
    9491. 

  9491.         mng_put_uint16 (pRGBArow+4, iG);
    9492. 

  9492.         mng_put_uint16 (pRGBArow+6, 0xFFFF);
    9493. 

  9493.       }
    9494. 

  9494. 

  9495.       pWorkrow += 2;                   /* next pixel */
    9496. 

  9496.       pRGBArow += 8;
    9497. 

  9497.     }
    9498. 

  9498.   }
    9499. 

  9499.   else
    9500. 

  9500.   {
    9501. 

  9501. #ifdef MNG_DECREMENT_LOOPS
    9502. 

  9502.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9503. 

  9503. #else
    9504. 

  9504.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9505. 

  9505. #endif
    9506. 

  9506.     {
    9507. 

  9507.       iG = mng_get_uint16 (pWorkrow);  /* get the gray-value */
    9508. 

  9508. 

  9509.       mng_put_uint16 (pRGBArow,   iG); /* and put in intermediate row */
    9510. 

  9510.       mng_put_uint16 (pRGBArow+2, iG);
    9511. 

  9511.       mng_put_uint16 (pRGBArow+4, iG);
    9512. 

  9512.       mng_put_uint16 (pRGBArow+6, 0xFFFF);
    9513. 

  9513. 

  9514.       pWorkrow += 2;                  /* next pixel */
    9515. 

  9515.       pRGBArow += 8;
    9516. 

  9516.     }
    9517. 

  9517.   }
    9518. 

  9518. 

  9519. #ifdef MNG_SUPPORT_TRACE
    9520. 

  9520.   MNG_TRACE (pData, MNG_FN_RETRIEVE_G16, MNG_LC_END);
    9521. 

  9521. #endif
    9522. 

  9522. 

  9523.   return MNG_NOERROR;
    9524. 

  9524. }
    9525. 

  9525. #endif
    9526. 

  9526. 

  9527. /* ************************************************************************** */
    9528. 

  9528. 

  9529. mng_retcode mng_retrieve_rgb8 (mng_datap pData)
    9530. 

  9530. {
    9531. 

  9531.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9532. 

  9532.   mng_uint8p     pWorkrow;
    9533. 

  9533.   mng_uint8p     pRGBArow;
    9534. 

  9534.   mng_int32      iX;
    9535. 

  9535.   mng_uint8      iR, iG, iB;
    9536. 

  9536. 

  9537. #ifdef MNG_SUPPORT_TRACE
    9538. 

  9538.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGB8, MNG_LC_START);
    9539. 

  9539. #endif
    9540. 

  9540. 

  9541.   pRGBArow = pData->pRGBArow;          /* temporary work pointers */
    9542. 

  9542.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9543. 

  9543. 

  9544.   if (pBuf->bHasTRNS)                  /* tRNS in buffer ? */
    9545. 

  9545.   {
    9546. 

  9546. #ifdef MNG_DECREMENT_LOOPS
    9547. 

  9547.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9548. 

  9548. #else
    9549. 

  9549.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9550. 

  9550. #endif
    9551. 

  9551.     {
    9552. 

  9552.       iR = *pWorkrow;                  /* get the rgb-values */
    9553. 

  9553.       iG = *(pWorkrow+1);
    9554. 

  9554.       iB = *(pWorkrow+2);
    9555. 

  9555.                                        /* is it transparent ? */
    9556. 

  9556.       if (((mng_uint16)iR == pBuf->iTRNSred  ) &&
    9557. 

  9557.           ((mng_uint16)iG == pBuf->iTRNSgreen) &&
    9558. 

  9558.           ((mng_uint16)iB == pBuf->iTRNSblue )    )
    9559. 

  9559.       {
    9560. 

  9560.         *pRGBArow     = 0x00;          /* nothing to display */
    9561. 

  9561.         *(pRGBArow+1) = 0x00;
    9562. 

  9562.         *(pRGBArow+2) = 0x00;
    9563. 

  9563.         *(pRGBArow+3) = 0x00;
    9564. 

  9564.       }
    9565. 

  9565.       else
    9566. 

  9566.       {
    9567. 

  9567.         *pRGBArow     = iR;            /* put in intermediate row */
    9568. 

  9568.         *(pRGBArow+1) = iG;
    9569. 

  9569.         *(pRGBArow+2) = iB;
    9570. 

  9570.         *(pRGBArow+3) = 0xFF;
    9571. 

  9571.       }
    9572. 

  9572. 

  9573.       pWorkrow += 3;                   /* next pixel */
    9574. 

  9574.       pRGBArow += 4;
    9575. 

  9575.     }
    9576. 

  9576.   }
    9577. 

  9577.   else
    9578. 

  9578.   {
    9579. 

  9579. #ifdef MNG_DECREMENT_LOOPS
    9580. 

  9580.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9581. 

  9581. #else
    9582. 

  9582.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9583. 

  9583. #endif
    9584. 

  9584.     {
    9585. 

  9585.       *pRGBArow     = *pWorkrow;       /* just copy the pixel */
    9586. 

  9586.       *(pRGBArow+1) = *(pWorkrow+1);
    9587. 

  9587.       *(pRGBArow+2) = *(pWorkrow+2);
    9588. 

  9588.       *(pRGBArow+3) = 0xFF;
    9589. 

  9589. 

  9590.       pWorkrow += 3;                   /* next pixel */
    9591. 

  9591.       pRGBArow += 4;
    9592. 

  9592.     }
    9593. 

  9593.   }
    9594. 

  9594. 

  9595. #ifdef MNG_SUPPORT_TRACE
    9596. 

  9596.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGB8, MNG_LC_END);
    9597. 

  9597. #endif
    9598. 

  9598. 

  9599.   return MNG_NOERROR;
    9600. 

  9600. }
    9601. 

  9601. 

  9602. /* ************************************************************************** */
    9603. 

  9603. 

  9604. #ifndef MNG_NO_16BIT_SUPPORT
    9605. 

  9605. mng_retcode mng_retrieve_rgb16 (mng_datap pData)
    9606. 

  9606. {
    9607. 

  9607.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9608. 

  9608.   mng_uint8p     pWorkrow;
    9609. 

  9609.   mng_uint8p     pRGBArow;
    9610. 

  9610.   mng_int32      iX;
    9611. 

  9611.   mng_uint16     iR, iG, iB;
    9612. 

  9612. 

  9613. #ifdef MNG_SUPPORT_TRACE
    9614. 

  9614.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGB16, MNG_LC_START);
    9615. 

  9615. #endif
    9616. 

  9616.                                        /* temporary work pointers */
    9617. 

  9617.   pRGBArow = pData->pRGBArow;
    9618. 

  9618.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9619. 

  9619. 

  9620.   if (pBuf->bHasTRNS)                  /* tRNS in buffer ? */
    9621. 

  9621.   {
    9622. 

  9622. #ifdef MNG_DECREMENT_LOOPS
    9623. 

  9623.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9624. 

  9624. #else
    9625. 

  9625.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9626. 

  9626. #endif
    9627. 

  9627.     {
    9628. 

  9628.       iR = mng_get_uint16 (pWorkrow);  /* get the rgb-values */
    9629. 

  9629.       iG = mng_get_uint16 (pWorkrow+2);
    9630. 

  9630.       iB = mng_get_uint16 (pWorkrow+4);
    9631. 

  9631.                                        /* is it transparent ? */
    9632. 

  9632.       if ((iR == pBuf->iTRNSred  ) &&
    9633. 

  9633.           (iG == pBuf->iTRNSgreen) &&
    9634. 

  9634.           (iB == pBuf->iTRNSblue )    )
    9635. 

  9635.       {                                /* nothing to display */
    9636. 

  9636.         mng_put_uint16 (pRGBArow,   0x0000);
    9637. 

  9637.         mng_put_uint16 (pRGBArow+2, 0x0000);
    9638. 

  9638.         mng_put_uint16 (pRGBArow+4, 0x0000);
    9639. 

  9639.         mng_put_uint16 (pRGBArow+6, 0x0000);
    9640. 

  9640.       }
    9641. 

  9641.       else
    9642. 

  9642.       {                                /* put in intermediate row */
    9643. 

  9643.         mng_put_uint16 (pRGBArow,   iR);
    9644. 

  9644.         mng_put_uint16 (pRGBArow+2, iG);
    9645. 

  9645.         mng_put_uint16 (pRGBArow+4, iB);
    9646. 

  9646.         mng_put_uint16 (pRGBArow+6, 0xFFFF);
    9647. 

  9647.       }
    9648. 

  9648. 

  9649.       pWorkrow += 6;                   /* next pixel */
    9650. 

  9650.       pRGBArow += 8;
    9651. 

  9651.     }
    9652. 

  9652.   }
    9653. 

  9653.   else
    9654. 

  9654.   {
    9655. 

  9655. #ifdef MNG_DECREMENT_LOOPS
    9656. 

  9656.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9657. 

  9657. #else
    9658. 

  9658.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9659. 

  9659. #endif
    9660. 

  9660.     {                                  /* just copy the pixel */
    9661. 

  9661.       mng_put_uint16 (pRGBArow,   mng_get_uint16 (pWorkrow  ));
    9662. 

  9662.       mng_put_uint16 (pRGBArow+2, mng_get_uint16 (pWorkrow+2));
    9663. 

  9663.       mng_put_uint16 (pRGBArow+4, mng_get_uint16 (pWorkrow+4));
    9664. 

  9664.       mng_put_uint16 (pRGBArow+6, 0xFFFF);
    9665. 

  9665. 

  9666.       pWorkrow += 6;                   /* next pixel */
    9667. 

  9667.       pRGBArow += 8;
    9668. 

  9668.     }
    9669. 

  9669.   }
    9670. 

  9670. 

  9671. #ifdef MNG_SUPPORT_TRACE
    9672. 

  9672.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGB16, MNG_LC_END);
    9673. 

  9673. #endif
    9674. 

  9674. 

  9675.   return MNG_NOERROR;
    9676. 

  9676. }
    9677. 

  9677. #endif
    9678. 

  9678. 

  9679. /* ************************************************************************** */
    9680. 

  9680. 

  9681. mng_retcode mng_retrieve_idx8 (mng_datap pData)
    9682. 

  9682. {
    9683. 

  9683.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9684. 

  9684.   mng_uint8p     pWorkrow;
    9685. 

  9685.   mng_uint8p     pRGBArow;
    9686. 

  9686.   mng_int32      iX;
    9687. 

  9687.   mng_uint8      iQ;
    9688. 

  9688. 

  9689. #ifdef MNG_SUPPORT_TRACE
    9690. 

  9690.   MNG_TRACE (pData, MNG_FN_RETRIEVE_IDX8, MNG_LC_START);
    9691. 

  9691. #endif
    9692. 

  9692. 

  9693.   pRGBArow = pData->pRGBArow;          /* temporary work pointers */
    9694. 

  9694.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9695. 

  9695. 

  9696.   if (pBuf->bHasTRNS)                  /* tRNS in buffer ? */
    9697. 

  9697.   {
    9698. 

  9698. #ifdef MNG_DECREMENT_LOOPS
    9699. 

  9699.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9700. 

  9700. #else
    9701. 

  9701.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9702. 

  9702. #endif
    9703. 

  9703.     {
    9704. 

  9704.       iQ = *pWorkrow;                  /* get the index */
    9705. 

  9705.                                        /* is it valid ? */
    9706. 

  9706.       if ((mng_uint32)iQ < pBuf->iPLTEcount)
    9707. 

  9707.       {                                /* put in intermediate row */
    9708. 

  9708.         *pRGBArow     = pBuf->aPLTEentries [iQ].iRed;
    9709. 

  9709.         *(pRGBArow+1) = pBuf->aPLTEentries [iQ].iGreen;
    9710. 

  9710.         *(pRGBArow+2) = pBuf->aPLTEentries [iQ].iBlue;
    9711. 

  9711.                                        /* transparency for this index ? */
    9712. 

  9712.         if ((mng_uint32)iQ < pBuf->iTRNScount)
    9713. 

  9713.           *(pRGBArow+3) = pBuf->aTRNSentries [iQ];
    9714. 

  9714.         else
    9715. 

  9715.           *(pRGBArow+3) = 0xFF;
    9716. 

  9716.       }
    9717. 

  9717.       else
    9718. 

  9718.         MNG_ERROR (pData, MNG_PLTEINDEXERROR);
    9719. 

  9719. 

  9720.       pWorkrow++;                      /* next pixel */
    9721. 

  9721.       pRGBArow += 4;
    9722. 

  9722.     }
    9723. 

  9723.   }
    9724. 

  9724.   else
    9725. 

  9725.   {
    9726. 

  9726. #ifdef MNG_DECREMENT_LOOPS
    9727. 

  9727.     for (iX = pData->iRowsamples; iX > 0; iX--)
    9728. 

  9728. #else
    9729. 

  9729.     for (iX = 0; iX < pData->iRowsamples; iX++)
    9730. 

  9730. #endif
    9731. 

  9731.     {
    9732. 

  9732.       iQ = *pWorkrow;                  /* get the index */
    9733. 

  9733.                                        /* is it valid ? */
    9734. 

  9734.       if ((mng_uint32)iQ < pBuf->iPLTEcount)
    9735. 

  9735.       {                                /* put in intermediate row */
    9736. 

  9736.         *pRGBArow     = pBuf->aPLTEentries [iQ].iRed;
    9737. 

  9737.         *(pRGBArow+1) = pBuf->aPLTEentries [iQ].iGreen;
    9738. 

  9738.         *(pRGBArow+2) = pBuf->aPLTEentries [iQ].iBlue;
    9739. 

  9739.         *(pRGBArow+3) = 0xFF;
    9740. 

  9740.       }
    9741. 

  9741.       else
    9742. 

  9742.         MNG_ERROR (pData, MNG_PLTEINDEXERROR);
    9743. 

  9743. 

  9744.       pWorkrow++;                      /* next pixel */
    9745. 

  9745.       pRGBArow += 4;
    9746. 

  9746.     }
    9747. 

  9747.   }
    9748. 

  9748. 

  9749. #ifdef MNG_SUPPORT_TRACE
    9750. 

  9750.   MNG_TRACE (pData, MNG_FN_RETRIEVE_IDX8, MNG_LC_END);
    9751. 

  9751. #endif
    9752. 

  9752. 

  9753.   return MNG_NOERROR;
    9754. 

  9754. }
    9755. 

  9755. 

  9756. /* ************************************************************************** */
    9757. 

  9757. 

  9758. mng_retcode mng_retrieve_ga8 (mng_datap pData)
    9759. 

  9759. {
    9760. 

  9760.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9761. 

  9761.   mng_uint8p     pWorkrow;
    9762. 

  9762.   mng_uint8p     pRGBArow;
    9763. 

  9763.   mng_int32      iX;
    9764. 

  9764.   mng_uint8      iG;
    9765. 

  9765. 

  9766. #ifdef MNG_SUPPORT_TRACE
    9767. 

  9767.   MNG_TRACE (pData, MNG_FN_RETRIEVE_GA8, MNG_LC_START);
    9768. 

  9768. #endif
    9769. 

  9769. 

  9770.   pRGBArow = pData->pRGBArow;          /* temporary work pointers */
    9771. 

  9771.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9772. 

  9772. 

  9773. #ifdef MNG_DECREMENT_LOOPS
    9774. 

  9774.   for (iX = pData->iRowsamples; iX > 0; iX--)
    9775. 

  9775. #else
    9776. 

  9776.   for (iX = 0; iX < pData->iRowsamples; iX++)
    9777. 

  9777. #endif
    9778. 

  9778.   {
    9779. 

  9779.     iG = *pWorkrow;                    /* get the gray-value */
    9780. 

  9780.     *pRGBArow     = iG;                /* put in intermediate row */
    9781. 

  9781.     *(pRGBArow+1) = iG;
    9782. 

  9782.     *(pRGBArow+2) = iG;
    9783. 

  9783.     *(pRGBArow+3) = *(pWorkrow+1);
    9784. 

  9784. 

  9785.     pWorkrow += 2;                     /* next pixel */
    9786. 

  9786.     pRGBArow += 4;
    9787. 

  9787.   }
    9788. 

  9788. 

  9789. #ifdef MNG_SUPPORT_TRACE
    9790. 

  9790.   MNG_TRACE (pData, MNG_FN_RETRIEVE_GA8, MNG_LC_END);
    9791. 

  9791. #endif
    9792. 

  9792. 

  9793.   return MNG_NOERROR;
    9794. 

  9794. }
    9795. 

  9795. 

  9796. /* ************************************************************************** */
    9797. 

  9797. 

  9798. #ifndef MNG_NO_16BIT_SUPPORT
    9799. 

  9799. mng_retcode mng_retrieve_ga16 (mng_datap pData)
    9800. 

  9800. {
    9801. 

  9801.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9802. 

  9802.   mng_uint8p     pWorkrow;
    9803. 

  9803.   mng_uint8p     pRGBArow;
    9804. 

  9804.   mng_int32      iX;
    9805. 

  9805.   mng_uint16     iG;
    9806. 

  9806. 

  9807. #ifdef MNG_SUPPORT_TRACE
    9808. 

  9808.   MNG_TRACE (pData, MNG_FN_RETRIEVE_GA16, MNG_LC_START);
    9809. 

  9809. #endif
    9810. 

  9810.                                        /* temporary work pointers */
    9811. 

  9811.   pRGBArow = pData->pRGBArow;
    9812. 

  9812.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9813. 

  9813. 

  9814. #ifdef MNG_DECREMENT_LOOPS
    9815. 

  9815.   for (iX = pData->iRowsamples; iX > 0; iX--)
    9816. 

  9816. #else
    9817. 

  9817.   for (iX = 0; iX < pData->iRowsamples; iX++)
    9818. 

  9818. #endif
    9819. 

  9819.   {
    9820. 

  9820.     iG = mng_get_uint16 (pWorkrow);    /* get the gray-value */
    9821. 

  9821. 

  9822.     mng_put_uint16 (pRGBArow,   iG);   /* and put in intermediate row */
    9823. 

  9823.     mng_put_uint16 (pRGBArow+2, iG);
    9824. 

  9824.     mng_put_uint16 (pRGBArow+4, iG);
    9825. 

  9825.     mng_put_uint16 (pRGBArow+6, mng_get_uint16 (pWorkrow+2));
    9826. 

  9826. 

  9827.     pWorkrow += 4;                     /* next pixel */
    9828. 

  9828.     pRGBArow += 8;
    9829. 

  9829.   }
    9830. 

  9830. 

  9831. #ifdef MNG_SUPPORT_TRACE
    9832. 

  9832.   MNG_TRACE (pData, MNG_FN_RETRIEVE_GA16, MNG_LC_END);
    9833. 

  9833. #endif
    9834. 

  9834. 

  9835.   return MNG_NOERROR;
    9836. 

  9836. }
    9837. 

  9837. #endif
    9838. 

  9838. 

  9839. /* ************************************************************************** */
    9840. 

  9840. 

  9841. mng_retcode mng_retrieve_rgba8 (mng_datap pData)
    9842. 

  9842. {
    9843. 

  9843.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9844. 

  9844.   mng_uint8p     pWorkrow;
    9845. 

  9845.   mng_uint8p     pRGBArow;
    9846. 

  9846. 

  9847. #ifdef MNG_SUPPORT_TRACE
    9848. 

  9848.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGBA8, MNG_LC_START);
    9849. 

  9849. #endif
    9850. 

  9850. 

  9851.   pRGBArow = pData->pRGBArow;          /* temporary work pointers */
    9852. 

  9852.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9853. 

  9853.                                        /* can't be easier than this ! */
    9854. 

  9854.   MNG_COPY (pRGBArow, pWorkrow, pBuf->iRowsize);
    9855. 

  9855. 

  9856. #ifdef MNG_SUPPORT_TRACE
    9857. 

  9857.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGBA8, MNG_LC_END);
    9858. 

  9858. #endif
    9859. 

  9859. 

  9860.   return MNG_NOERROR;
    9861. 

  9861. }
    9862. 

  9862. 

  9863. /* ************************************************************************** */
    9864. 

  9864. 

  9865. #ifndef MNG_NO_16BIT_SUPPORT
    9866. 

  9866. mng_retcode mng_retrieve_rgba16 (mng_datap pData)
    9867. 

  9867. {
    9868. 

  9868.   mng_imagedatap pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
    9869. 

  9869.   mng_uint8p     pWorkrow;
    9870. 

  9870.   mng_uint8p     pRGBArow;
    9871. 

  9871. 

  9872. #ifdef MNG_SUPPORT_TRACE
    9873. 

  9873.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGBA16, MNG_LC_START);
    9874. 

  9874. #endif
    9875. 

  9875.                                        /* temporary work pointers */
    9876. 

  9876.   pRGBArow = pData->pRGBArow;
    9877. 

  9877.   pWorkrow = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize);
    9878. 

  9878.                                        /* can't be easier than this ! */
    9879. 

  9879.   MNG_COPY (pRGBArow, pWorkrow, pBuf->iRowsize);
    9880. 

  9880. 

  9881. #ifdef MNG_SUPPORT_TRACE
    9882. 

  9882.   MNG_TRACE (pData, MNG_FN_RETRIEVE_RGBA16, MNG_LC_END);
    9883. 

  9883. #endif
    9884. 

  9884. 

  9885.   return MNG_NOERROR;
    9886. 

  9886. }
    9887. 

  9887. #endif
    9888. 

  9888. 

  9889. /* ************************************************************************** */
    9890. 

  9890. /* *                                                                        * */
    9891. 

  9891. /* * Row storage routines - store processed & uncompressed row-data         * */
    9892. 

  9892. /* * into the current "object"                                              * */
    9893. 

  9893. /* *                                                                        * */
    9894. 

  9894. /* ************************************************************************** */
    9895. 

  9895. 

  9896. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    9897. 

  9897. mng_retcode mng_store_g1 (mng_datap pData)
    9898. 

  9898. {
    9899. 

  9899.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    9900. 

  9900.   mng_uint8p     pWorkrow;
    9901. 

  9901.   mng_uint8p     pOutrow;
    9902. 

  9902.   mng_int32      iX;
    9903. 

  9903.   mng_uint8      iB;
    9904. 

  9904.   mng_uint8      iM;
    9905. 

  9905. 

  9906. #ifdef MNG_SUPPORT_TRACE
    9907. 

  9907.   MNG_TRACE (pData, MNG_FN_STORE_G1, MNG_LC_START);
    9908. 

  9908. #endif
    9909. 

  9909.                                        /* temporary work pointers */
    9910. 

  9910.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    9911. 

  9911.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    9912. 

  9912.                               (pData->iCol * pBuf->iSamplesize);
    9913. 

  9913.   iM       = 0;                        /* start at pixel 0 */
    9914. 

  9914.   iB       = 0;
    9915. 

  9915. 

  9916. #ifdef MNG_DECREMENT_LOOPS
    9917. 

  9917.   for (iX = pData->iRowsamples; iX > 0; iX--)
    9918. 

  9918. #else
    9919. 

  9919.   for (iX = 0; iX < pData->iRowsamples; iX++)
    9920. 

  9920. #endif
    9921. 

  9921.   {
    9922. 

  9922.     if (!iM)                           /* mask underflow ? */
    9923. 

  9923.     {
    9924. 

  9924.       iB = *pWorkrow;                  /* get next input-byte */
    9925. 

  9925.       pWorkrow++;
    9926. 

  9926.       iM = 0x80;
    9927. 

  9927.     }
    9928. 

  9928. 

  9929.     if (iB & iM)                       /* is it white ? */
    9930. 

  9930.       *pOutrow = 0x01;                 /* white */
    9931. 

  9931.     else
    9932. 

  9932.       *pOutrow = 0x00;                 /* black */
    9933. 

  9933. 

  9934.     pOutrow += pData->iColinc;         /* next pixel */
    9935. 

  9935.     iM >>=  1;
    9936. 

  9936.   }
    9937. 

  9937. 

  9938. #ifdef MNG_SUPPORT_TRACE
    9939. 

  9939.   MNG_TRACE (pData, MNG_FN_STORE_G1, MNG_LC_END);
    9940. 

  9940. #endif
    9941. 

  9941. 

  9942.   return MNG_NOERROR;
    9943. 

  9943. }
    9944. 

  9944. 

  9945. /* ************************************************************************** */
    9946. 

  9946. 

  9947. mng_retcode mng_store_g2 (mng_datap pData)
    9948. 

  9948. {
    9949. 

  9949.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    9950. 

  9950.   mng_uint8p     pWorkrow;
    9951. 

  9951.   mng_uint8p     pOutrow;
    9952. 

  9952.   mng_int32      iX;
    9953. 

  9953.   mng_uint8      iB;
    9954. 

  9954.   mng_uint8      iM;
    9955. 

  9955.   mng_uint32     iS;
    9956. 

  9956.   mng_uint8      iQ;
    9957. 

  9957. 

  9958. #ifdef MNG_SUPPORT_TRACE
    9959. 

  9959.   MNG_TRACE (pData, MNG_FN_STORE_G2, MNG_LC_START);
    9960. 

  9960. #endif
    9961. 

  9961.                                        /* temporary work pointers */
    9962. 

  9962.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    9963. 

  9963.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    9964. 

  9964.                               (pData->iCol * pBuf->iSamplesize);
    9965. 

  9965.   iM       = 0;                        /* start at pixel 0 */
    9966. 

  9966.   iB       = 0;
    9967. 

  9967.   iS       = 0;
    9968. 

  9968. 

  9969. #ifdef MNG_DECREMENT_LOOPS
    9970. 

  9970.   for (iX = pData->iRowsamples; iX > 0; iX--)
    9971. 

  9971. #else
    9972. 

  9972.   for (iX = 0; iX < pData->iRowsamples; iX++)
    9973. 

  9973. #endif
    9974. 

  9974.   {
    9975. 

  9975.     if (!iM)                           /* mask underflow ? */
    9976. 

  9976.     {
    9977. 

  9977.       iB = *pWorkrow;                  /* get next input-byte */
    9978. 

  9978.       pWorkrow++;
    9979. 

  9979.       iM = 0xC0;
    9980. 

  9980.       iS = 6;
    9981. 

  9981.     }
    9982. 

  9982. 

  9983.     iQ = (mng_uint8)((iB & iM) >> iS); /* get the gray level */
    9984. 

  9984.     *pOutrow = iQ;                     /* put in object buffer */
    9985. 

  9985. 

  9986.     pOutrow += pData->iColinc;         /* next pixel */
    9987. 

  9987.     iM >>=  2;
    9988. 

  9988.     iS -= 2;
    9989. 

  9989.   }
    9990. 

  9990. 

  9991. #ifdef MNG_SUPPORT_TRACE
    9992. 

  9992.   MNG_TRACE (pData, MNG_FN_STORE_G2, MNG_LC_END);
    9993. 

  9993. #endif
    9994. 

  9994. 

  9995.   return MNG_NOERROR;
    9996. 

  9996. }
    9997. 

  9997. 

  9998. /* ************************************************************************** */
    9999. 

  9999. 

  10000. mng_retcode mng_store_g4 (mng_datap pData)
    10001. 

  10001. {
    10002. 

  10002.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10003. 

  10003.   mng_uint8p     pWorkrow;
    10004. 

  10004.   mng_uint8p     pOutrow;
    10005. 

  10005.   mng_int32      iX;
    10006. 

  10006.   mng_uint8      iB;
    10007. 

  10007.   mng_uint8      iM;
    10008. 

  10008.   mng_uint32     iS;
    10009. 

  10009.   mng_uint8      iQ;
    10010. 

  10010. 

  10011. #ifdef MNG_SUPPORT_TRACE
    10012. 

  10012.   MNG_TRACE (pData, MNG_FN_STORE_G4, MNG_LC_START);
    10013. 

  10013. #endif
    10014. 

  10014.                                        /* temporary work pointers */
    10015. 

  10015.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10016. 

  10016.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10017. 

  10017.                               (pData->iCol * pBuf->iSamplesize);
    10018. 

  10018.   iM       = 0;                        /* start at pixel 0 */
    10019. 

  10019.   iB       = 0;
    10020. 

  10020.   iS       = 0;
    10021. 

  10021. 

  10022. #ifdef MNG_DECREMENT_LOOPS
    10023. 

  10023.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10024. 

  10024. #else
    10025. 

  10025.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10026. 

  10026. #endif
    10027. 

  10027.   {
    10028. 

  10028.     if (!iM)                           /* mask underflow ? */
    10029. 

  10029.     {
    10030. 

  10030.       iB = *pWorkrow;                  /* get next input-byte */
    10031. 

  10031.       pWorkrow++;
    10032. 

  10032.       iM = 0xF0;
    10033. 

  10033.       iS = 4;
    10034. 

  10034.     }
    10035. 

  10035. 

  10036.     iQ = (mng_uint8)((iB & iM) >> iS); /* get the gray level */
    10037. 

  10037.     *pOutrow = iQ;                     /* put in object buffer */
    10038. 

  10038. 

  10039.     pOutrow += pData->iColinc;         /* next pixel */
    10040. 

  10040.     iM >>=  4;
    10041. 

  10041.     iS -= 4;
    10042. 

  10042.   }
    10043. 

  10043. 

  10044. #ifdef MNG_SUPPORT_TRACE
    10045. 

  10045.   MNG_TRACE (pData, MNG_FN_STORE_G4, MNG_LC_END);
    10046. 

  10046. #endif
    10047. 

  10047. 

  10048.   return MNG_NOERROR;
    10049. 

  10049. }
    10050. 

  10050. #endif
    10051. 

  10051. 

  10052. /* ************************************************************************** */
    10053. 

  10053. 

  10054. mng_retcode mng_store_g8 (mng_datap pData)
    10055. 

  10055. {
    10056. 

  10056.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10057. 

  10057.   mng_uint8p     pWorkrow;
    10058. 

  10058.   mng_uint8p     pOutrow;
    10059. 

  10059.   mng_int32      iX;
    10060. 

  10060. 

  10061. #ifdef MNG_SUPPORT_TRACE
    10062. 

  10062.   MNG_TRACE (pData, MNG_FN_STORE_G8, MNG_LC_START);
    10063. 

  10063. #endif
    10064. 

  10064.                                        /* temporary work pointers */
    10065. 

  10065.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10066. 

  10066.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10067. 

  10067.                               (pData->iCol * pBuf->iSamplesize);
    10068. 

  10068. 

  10069. #ifdef MNG_DECREMENT_LOOPS
    10070. 

  10070.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10071. 

  10071. #else
    10072. 

  10072.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10073. 

  10073. #endif
    10074. 

  10074.   {
    10075. 

  10075.     *pOutrow = *pWorkrow;              /* put in object buffer */
    10076. 

  10076. 

  10077.     pOutrow += pData->iColinc;         /* next pixel */
    10078. 

  10078.     pWorkrow++;
    10079. 

  10079.   }
    10080. 

  10080. 

  10081. #ifdef MNG_SUPPORT_TRACE
    10082. 

  10082.   MNG_TRACE (pData, MNG_FN_STORE_G8, MNG_LC_END);
    10083. 

  10083. #endif
    10084. 

  10084. 

  10085.   return MNG_NOERROR;
    10086. 

  10086. }
    10087. 

  10087. 

  10088. /* ************************************************************************** */
    10089. 

  10089. 

  10090. #ifndef MNG_NO_16BIT_SUPPORT
    10091. 

  10091. mng_retcode mng_store_g16 (mng_datap pData)
    10092. 

  10092. {
    10093. 

  10093.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10094. 

  10094.   mng_uint8p     pWorkrow;
    10095. 

  10095.   mng_uint8p     pOutrow;
    10096. 

  10096.   mng_int32      iX;
    10097. 

  10097. 

  10098. #ifdef MNG_SUPPORT_TRACE
    10099. 

  10099.   MNG_TRACE (pData, MNG_FN_STORE_G16, MNG_LC_START);
    10100. 

  10100. #endif
    10101. 

  10101.                                        /* temporary work pointers */
    10102. 

  10102.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10103. 

  10103.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10104. 

  10104.                               (pData->iCol * pBuf->iSamplesize);
    10105. 

  10105. 

  10106. #ifdef MNG_DECREMENT_LOOPS
    10107. 

  10107.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10108. 

  10108. #else
    10109. 

  10109.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10110. 

  10110. #endif
    10111. 

  10111.   {                                    /* copy into object buffer */
    10112. 

  10112.     mng_put_uint16 (pOutrow, mng_get_uint16 (pWorkrow));
    10113. 

  10113. 

  10114.     pOutrow  += (pData->iColinc << 1); /* next pixel */
    10115. 

  10115.     pWorkrow += 2;
    10116. 

  10116.   }
    10117. 

  10117. 

  10118. #ifdef MNG_SUPPORT_TRACE
    10119. 

  10119.   MNG_TRACE (pData, MNG_FN_STORE_G16, MNG_LC_END);
    10120. 

  10120. #endif
    10121. 

  10121. 

  10122.   return MNG_NOERROR;
    10123. 

  10123. }
    10124. 

  10124. #endif
    10125. 

  10125. 

  10126. /* ************************************************************************** */
    10127. 

  10127. 

  10128. mng_retcode mng_store_rgb8 (mng_datap pData)
    10129. 

  10129. {
    10130. 

  10130.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10131. 

  10131.   mng_uint8p     pWorkrow;
    10132. 

  10132.   mng_uint8p     pOutrow;
    10133. 

  10133.   mng_int32      iX;
    10134. 

  10134. 

  10135. #ifdef MNG_SUPPORT_TRACE
    10136. 

  10136.   MNG_TRACE (pData, MNG_FN_STORE_RGB8, MNG_LC_START);
    10137. 

  10137. #endif
    10138. 

  10138.                                        /* temporary work pointers */
    10139. 

  10139.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10140. 

  10140.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10141. 

  10141.                               (pData->iCol * pBuf->iSamplesize);
    10142. 

  10142. 

  10143. #ifdef MNG_DECREMENT_LOOPS
    10144. 

  10144.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10145. 

  10145. #else
    10146. 

  10146.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10147. 

  10147. #endif
    10148. 

  10148.   {
    10149. 

  10149.     *pOutrow     = *pWorkrow;          /* copy the RGB bytes */
    10150. 

  10150.     *(pOutrow+1) = *(pWorkrow+1);
    10151. 

  10151.     *(pOutrow+2) = *(pWorkrow+2);
    10152. 

  10152. 

  10153.     pWorkrow += 3;                     /* next pixel */
    10154. 

  10154.     pOutrow  += (pData->iColinc * 3);
    10155. 

  10155.   }
    10156. 

  10156. 

  10157. #ifdef MNG_SUPPORT_TRACE
    10158. 

  10158.   MNG_TRACE (pData, MNG_FN_STORE_RGB8, MNG_LC_END);
    10159. 

  10159. #endif
    10160. 

  10160. 

  10161.   return MNG_NOERROR;
    10162. 

  10162. }
    10163. 

  10163. 

  10164. /* ************************************************************************** */
    10165. 

  10165. 

  10166. #ifndef MNG_NO_16BIT_SUPPORT
    10167. 

  10167. mng_retcode mng_store_rgb16 (mng_datap pData)
    10168. 

  10168. {
    10169. 

  10169.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10170. 

  10170.   mng_uint8p     pWorkrow;
    10171. 

  10171.   mng_uint8p     pOutrow;
    10172. 

  10172.   mng_int32      iX;
    10173. 

  10173. 

  10174. #ifdef MNG_SUPPORT_TRACE
    10175. 

  10175.   MNG_TRACE (pData, MNG_FN_STORE_RGB16, MNG_LC_START);
    10176. 

  10176. #endif
    10177. 

  10177.                                        /* temporary work pointers */
    10178. 

  10178.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10179. 

  10179.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10180. 

  10180.                               (pData->iCol * pBuf->iSamplesize);
    10181. 

  10181. 

  10182. #ifdef MNG_DECREMENT_LOOPS
    10183. 

  10183.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10184. 

  10184. #else
    10185. 

  10185.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10186. 

  10186. #endif
    10187. 

  10187.   {
    10188. 

  10188.     MNG_COPY (pOutrow, pWorkrow, 6);   /* copy the RGB bytes */
    10189. 

  10189. 

  10190.     pWorkrow += 6;                     /* next pixel */
    10191. 

  10191.     pOutrow  += (pData->iColinc * 6);
    10192. 

  10192.   }
    10193. 

  10193. 

  10194. #ifdef MNG_SUPPORT_TRACE
    10195. 

  10195.   MNG_TRACE (pData, MNG_FN_STORE_RGB16, MNG_LC_END);
    10196. 

  10196. #endif
    10197. 

  10197. 

  10198.   return MNG_NOERROR;
    10199. 

  10199. }
    10200. 

  10200. #endif
    10201. 

  10201. 

  10202. /* ************************************************************************** */
    10203. 

  10203. 

  10204. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    10205. 

  10205. mng_retcode mng_store_idx1 (mng_datap pData)
    10206. 

  10206. {
    10207. 

  10207.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10208. 

  10208.   mng_uint8p     pWorkrow;
    10209. 

  10209.   mng_uint8p     pOutrow;
    10210. 

  10210.   mng_int32      iX;
    10211. 

  10211.   mng_uint8      iB;
    10212. 

  10212.   mng_uint8      iM;
    10213. 

  10213. 

  10214. #ifdef MNG_SUPPORT_TRACE
    10215. 

  10215.   MNG_TRACE (pData, MNG_FN_STORE_IDX1, MNG_LC_START);
    10216. 

  10216. #endif
    10217. 

  10217.                                        /* temporary work pointers */
    10218. 

  10218.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10219. 

  10219.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10220. 

  10220.                               (pData->iCol * pBuf->iSamplesize);
    10221. 

  10221.   iM       = 0;                        /* start at pixel 0 */
    10222. 

  10222.   iB       = 0;
    10223. 

  10223. 

  10224. #ifdef MNG_DECREMENT_LOOPS
    10225. 

  10225.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10226. 

  10226. #else
    10227. 

  10227.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10228. 

  10228. #endif
    10229. 

  10229.   {
    10230. 

  10230.     if (!iM)                           /* mask underflow ? */
    10231. 

  10231.     {
    10232. 

  10232.       iB = *pWorkrow;                  /* get next input-byte */
    10233. 

  10233.       pWorkrow++;
    10234. 

  10234.       iM = 0x80;
    10235. 

  10235.     }
    10236. 

  10236. 

  10237.     if (iB & iM)                       /* store the index */
    10238. 

  10238.       *pOutrow = 0x01;
    10239. 

  10239.     else
    10240. 

  10240.       *pOutrow = 0x00;
    10241. 

  10241. 

  10242.     pOutrow += pData->iColinc;         /* next pixel */
    10243. 

  10243.     iM >>=  1;
    10244. 

  10244.   }
    10245. 

  10245. 

  10246. #ifdef MNG_SUPPORT_TRACE
    10247. 

  10247.   MNG_TRACE (pData, MNG_FN_STORE_IDX1, MNG_LC_END);
    10248. 

  10248. #endif
    10249. 

  10249. 

  10250.   return MNG_NOERROR;
    10251. 

  10251. }
    10252. 

  10252. 

  10253. /* ************************************************************************** */
    10254. 

  10254. 

  10255. mng_retcode mng_store_idx2 (mng_datap pData)
    10256. 

  10256. {
    10257. 

  10257.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10258. 

  10258.   mng_uint8p     pWorkrow;
    10259. 

  10259.   mng_uint8p     pOutrow;
    10260. 

  10260.   mng_int32      iX;
    10261. 

  10261.   mng_uint8      iB;
    10262. 

  10262.   mng_uint8      iM;
    10263. 

  10263.   mng_uint32     iS;
    10264. 

  10264. 

  10265. #ifdef MNG_SUPPORT_TRACE
    10266. 

  10266.   MNG_TRACE (pData, MNG_FN_STORE_IDX2, MNG_LC_START);
    10267. 

  10267. #endif
    10268. 

  10268.                                        /* temporary work pointers */
    10269. 

  10269.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10270. 

  10270.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10271. 

  10271.                               (pData->iCol * pBuf->iSamplesize);
    10272. 

  10272.   iM       = 0;                        /* start at pixel 0 */
    10273. 

  10273.   iB       = 0;
    10274. 

  10274.   iS       = 0;
    10275. 

  10275. 

  10276. #ifdef MNG_DECREMENT_LOOPS
    10277. 

  10277.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10278. 

  10278. #else
    10279. 

  10279.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10280. 

  10280. #endif
    10281. 

  10281.   {
    10282. 

  10282.     if (!iM)                           /* mask underflow ? */
    10283. 

  10283.     {
    10284. 

  10284.       iB = *pWorkrow;                  /* get next input-byte */
    10285. 

  10285.       pWorkrow++;
    10286. 

  10286.       iM = 0xC0;
    10287. 

  10287.       iS = 6;
    10288. 

  10288.     }
    10289. 

  10289.                                        /* store the index */
    10290. 

  10290.     *pOutrow = (mng_uint8)((iB & iM) >> iS);
    10291. 

  10291. 

  10292.     pOutrow += pData->iColinc;         /* next pixel */
    10293. 

  10293.     iM >>=  2;
    10294. 

  10294.     iS -= 2;
    10295. 

  10295.   }
    10296. 

  10296. 

  10297. #ifdef MNG_SUPPORT_TRACE
    10298. 

  10298.   MNG_TRACE (pData, MNG_FN_STORE_IDX2, MNG_LC_END);
    10299. 

  10299. #endif
    10300. 

  10300. 

  10301.   return MNG_NOERROR;
    10302. 

  10302. }
    10303. 

  10303. 

  10304. /* ************************************************************************** */
    10305. 

  10305. 

  10306. mng_retcode mng_store_idx4 (mng_datap pData)
    10307. 

  10307. {
    10308. 

  10308.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10309. 

  10309.   mng_uint8p     pWorkrow;
    10310. 

  10310.   mng_uint8p     pOutrow;
    10311. 

  10311.   mng_int32      iX;
    10312. 

  10312.   mng_uint8      iB;
    10313. 

  10313.   mng_uint8      iM;
    10314. 

  10314.   mng_uint32     iS;
    10315. 

  10315. 

  10316. #ifdef MNG_SUPPORT_TRACE
    10317. 

  10317.   MNG_TRACE (pData, MNG_FN_STORE_IDX4, MNG_LC_START);
    10318. 

  10318. #endif
    10319. 

  10319.                                        /* temporary work pointers */
    10320. 

  10320.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10321. 

  10321.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10322. 

  10322.                               (pData->iCol * pBuf->iSamplesize);
    10323. 

  10323.   iM       = 0;                        /* start at pixel 0 */
    10324. 

  10324.   iB       = 0;
    10325. 

  10325.   iS       = 0;
    10326. 

  10326. 

  10327. #ifdef MNG_DECREMENT_LOOPS
    10328. 

  10328.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10329. 

  10329. #else
    10330. 

  10330.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10331. 

  10331. #endif
    10332. 

  10332.   {
    10333. 

  10333.     if (!iM)                           /* mask underflow ? */
    10334. 

  10334.     {
    10335. 

  10335.       iB = *pWorkrow;                  /* get next input-byte */
    10336. 

  10336.       pWorkrow++;
    10337. 

  10337.       iM = 0xF0;
    10338. 

  10338.       iS = 4;
    10339. 

  10339.     }
    10340. 

  10340.                                        /* store the index */
    10341. 

  10341.     *pOutrow = (mng_uint8)((iB & iM) >> iS);
    10342. 

  10342. 

  10343.     pOutrow += pData->iColinc;         /* next pixel */
    10344. 

  10344.     iM >>=  4;
    10345. 

  10345.     iS -= 4;
    10346. 

  10346.   }
    10347. 

  10347. 

  10348. #ifdef MNG_SUPPORT_TRACE
    10349. 

  10349.   MNG_TRACE (pData, MNG_FN_STORE_IDX4, MNG_LC_END);
    10350. 

  10350. #endif
    10351. 

  10351. 

  10352.   return MNG_NOERROR;
    10353. 

  10353. }
    10354. 

  10354. #endif
    10355. 

  10355. 

  10356. /* ************************************************************************** */
    10357. 

  10357. 

  10358. mng_retcode mng_store_idx8 (mng_datap pData)
    10359. 

  10359. {
    10360. 

  10360.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10361. 

  10361.   mng_uint8p     pWorkrow;
    10362. 

  10362.   mng_uint8p     pOutrow;
    10363. 

  10363.   mng_int32      iX;
    10364. 

  10364. 

  10365. #ifdef MNG_SUPPORT_TRACE
    10366. 

  10366.   MNG_TRACE (pData, MNG_FN_STORE_IDX8, MNG_LC_START);
    10367. 

  10367. #endif
    10368. 

  10368.                                        /* temporary work pointers */
    10369. 

  10369.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10370. 

  10370.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10371. 

  10371.                               (pData->iCol * pBuf->iSamplesize);
    10372. 

  10372. 

  10373. #ifdef MNG_DECREMENT_LOOPS
    10374. 

  10374.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10375. 

  10375. #else
    10376. 

  10376.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10377. 

  10377. #endif
    10378. 

  10378.   {
    10379. 

  10379.     *pOutrow = *pWorkrow;              /* put in object buffer */
    10380. 

  10380. 

  10381.     pOutrow += pData->iColinc;         /* next pixel */
    10382. 

  10382.     pWorkrow++;
    10383. 

  10383.   }
    10384. 

  10384. 

  10385. #ifdef MNG_SUPPORT_TRACE
    10386. 

  10386.   MNG_TRACE (pData, MNG_FN_STORE_IDX8, MNG_LC_END);
    10387. 

  10387. #endif
    10388. 

  10388. 

  10389.   return MNG_NOERROR;
    10390. 

  10390. }
    10391. 

  10391. 

  10392. /* ************************************************************************** */
    10393. 

  10393. 

  10394. mng_retcode mng_store_ga8 (mng_datap pData)
    10395. 

  10395. {
    10396. 

  10396.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10397. 

  10397.   mng_uint8p     pWorkrow;
    10398. 

  10398.   mng_uint8p     pOutrow;
    10399. 

  10399.   mng_int32      iX;
    10400. 

  10400. 

  10401. #ifdef MNG_SUPPORT_TRACE
    10402. 

  10402.   MNG_TRACE (pData, MNG_FN_STORE_GA8, MNG_LC_START);
    10403. 

  10403. #endif
    10404. 

  10404.                                        /* temporary work pointers */
    10405. 

  10405.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10406. 

  10406.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10407. 

  10407.                               (pData->iCol * pBuf->iSamplesize);
    10408. 

  10408. 

  10409. #ifdef MNG_DECREMENT_LOOPS
    10410. 

  10410.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10411. 

  10411. #else
    10412. 

  10412.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10413. 

  10413. #endif
    10414. 

  10414.   {
    10415. 

  10415.     *pOutrow     = *pWorkrow;          /* copy the GA bytes */
    10416. 

  10416.     *(pOutrow+1) = *(pWorkrow+1);
    10417. 

  10417. 

  10418.     pWorkrow += 2;                     /* next pixel */
    10419. 

  10419.     pOutrow  += (pData->iColinc << 1);
    10420. 

  10420.   }
    10421. 

  10421. 

  10422. #ifdef MNG_SUPPORT_TRACE
    10423. 

  10423.   MNG_TRACE (pData, MNG_FN_STORE_GA8, MNG_LC_END);
    10424. 

  10424. #endif
    10425. 

  10425. 

  10426.   return MNG_NOERROR;
    10427. 

  10427. }
    10428. 

  10428. 

  10429. /* ************************************************************************** */
    10430. 

  10430. 

  10431. #ifndef MNG_NO_16BIT_SUPPORT
    10432. 

  10432. mng_retcode mng_store_ga16 (mng_datap pData)
    10433. 

  10433. {
    10434. 

  10434.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10435. 

  10435.   mng_uint8p     pWorkrow;
    10436. 

  10436.   mng_uint8p     pOutrow;
    10437. 

  10437.   mng_int32      iX;
    10438. 

  10438. 

  10439. #ifdef MNG_SUPPORT_TRACE
    10440. 

  10440.   MNG_TRACE (pData, MNG_FN_STORE_GA16, MNG_LC_START);
    10441. 

  10441. #endif
    10442. 

  10442.                                        /* temporary work pointers */
    10443. 

  10443.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10444. 

  10444.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10445. 

  10445.                               (pData->iCol * pBuf->iSamplesize);
    10446. 

  10446. 

  10447. #ifdef MNG_DECREMENT_LOOPS
    10448. 

  10448.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10449. 

  10449. #else
    10450. 

  10450.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10451. 

  10451. #endif
    10452. 

  10452.   {
    10453. 

  10453.     MNG_COPY (pOutrow, pWorkrow, 4);   /* copy the GA bytes */
    10454. 

  10454. 

  10455.     pWorkrow += 4;                     /* next pixel */
    10456. 

  10456.     pOutrow  += (pData->iColinc << 2);
    10457. 

  10457.   }
    10458. 

  10458. 

  10459. #ifdef MNG_SUPPORT_TRACE
    10460. 

  10460.   MNG_TRACE (pData, MNG_FN_STORE_GA16, MNG_LC_END);
    10461. 

  10461. #endif
    10462. 

  10462. 

  10463.   return MNG_NOERROR;
    10464. 

  10464. }
    10465. 

  10465. #endif
    10466. 

  10466. 

  10467. /* ************************************************************************** */
    10468. 

  10468. 

  10469. mng_retcode mng_store_rgba8 (mng_datap pData)
    10470. 

  10470. {
    10471. 

  10471.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10472. 

  10472.   mng_uint8p     pWorkrow;
    10473. 

  10473.   mng_uint8p     pOutrow;
    10474. 

  10474.   mng_int32      iX;
    10475. 

  10475. 

  10476. #ifdef MNG_SUPPORT_TRACE
    10477. 

  10477.   MNG_TRACE (pData, MNG_FN_STORE_RGBA8, MNG_LC_START);
    10478. 

  10478. #endif
    10479. 

  10479.                                        /* temporary work pointers */
    10480. 

  10480.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10481. 

  10481.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10482. 

  10482.                               (pData->iCol * pBuf->iSamplesize);
    10483. 

  10483. 

  10484. #ifdef MNG_DECREMENT_LOOPS
    10485. 

  10485.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10486. 

  10486. #else
    10487. 

  10487.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10488. 

  10488. #endif
    10489. 

  10489.   {
    10490. 

  10490.     *pOutrow     = *pWorkrow;          /* copy the RGBA bytes */
    10491. 

  10491.     *(pOutrow+1) = *(pWorkrow+1);
    10492. 

  10492.     *(pOutrow+2) = *(pWorkrow+2);
    10493. 

  10493.     *(pOutrow+3) = *(pWorkrow+3);
    10494. 

  10494. 

  10495.     pWorkrow += 4;                     /* next pixel */
    10496. 

  10496.     pOutrow  += (pData->iColinc << 2);
    10497. 

  10497.   }
    10498. 

  10498. 

  10499. #ifdef MNG_SUPPORT_TRACE
    10500. 

  10500.   MNG_TRACE (pData, MNG_FN_STORE_RGBA8, MNG_LC_END);
    10501. 

  10501. #endif
    10502. 

  10502. 

  10503.   return MNG_NOERROR;
    10504. 

  10504. }
    10505. 

  10505. 

  10506. /* ************************************************************************** */
    10507. 

  10507. 

  10508. #ifndef MNG_NO_16BIT_SUPPORT
    10509. 

  10509. mng_retcode mng_store_rgba16 (mng_datap pData)
    10510. 

  10510. {
    10511. 

  10511.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10512. 

  10512.   mng_uint8p     pWorkrow;
    10513. 

  10513.   mng_uint8p     pOutrow;
    10514. 

  10514.   mng_int32      iX;
    10515. 

  10515. 

  10516. #ifdef MNG_SUPPORT_TRACE
    10517. 

  10517.   MNG_TRACE (pData, MNG_FN_STORE_RGBA16, MNG_LC_START);
    10518. 

  10518. #endif
    10519. 

  10519.                                        /* temporary work pointers */
    10520. 

  10520.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10521. 

  10521.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10522. 

  10522.                               (pData->iCol * pBuf->iSamplesize);
    10523. 

  10523. 

  10524. #ifdef MNG_DECREMENT_LOOPS
    10525. 

  10525.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10526. 

  10526. #else
    10527. 

  10527.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10528. 

  10528. #endif
    10529. 

  10529.   {
    10530. 

  10530.     MNG_COPY (pOutrow, pWorkrow, 8);   /* copy the RGBA bytes */
    10531. 

  10531. 

  10532.     pWorkrow += 8;                     /* next pixel */
    10533. 

  10533.     pOutrow  += (pData->iColinc << 3);
    10534. 

  10534.   }
    10535. 

  10535. 

  10536. #ifdef MNG_SUPPORT_TRACE
    10537. 

  10537.   MNG_TRACE (pData, MNG_FN_STORE_RGBA16, MNG_LC_END);
    10538. 

  10538. #endif
    10539. 

  10539. 

  10540.   return MNG_NOERROR;
    10541. 

  10541. }
    10542. 

  10542. #endif
    10543. 

  10543. 

  10544. /* ************************************************************************** */
    10545. 

  10545. /* *                                                                        * */
    10546. 

  10546. /* * Row storage routines (JPEG) - store processed & uncompressed row-data  * */
    10547. 

  10547. /* * into the current "object"                                              * */
    10548. 

  10548. /* *                                                                        * */
    10549. 

  10549. /* ************************************************************************** */
    10550. 

  10550. 

  10551. #ifdef MNG_INCLUDE_JNG
    10552. 

  10552. 

  10553. /* ************************************************************************** */
    10554. 

  10554. 

  10555. mng_retcode mng_store_jpeg_g8 (mng_datap pData)
    10556. 

  10556. {
    10557. 

  10557.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10558. 

  10558.   mng_uint8p     pWorkrow;
    10559. 

  10559.   mng_uint8p     pOutrow;
    10560. 

  10560. 

  10561. #ifdef MNG_SUPPORT_TRACE
    10562. 

  10562.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8, MNG_LC_START);
    10563. 

  10563. #endif
    10564. 

  10564. 

  10565.   pWorkrow = pData->pJPEGrow;          /* temporary work pointers */
    10566. 

  10566.   pOutrow  = pBuf->pImgdata + (pData->iJPEGrow * pBuf->iRowsize);
    10567. 

  10567.                                        /* easy as pie ... */
    10568. 

  10568.   MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples);
    10569. 

  10569. 

  10570. #ifdef MNG_SUPPORT_TRACE
    10571. 

  10571.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8, MNG_LC_END);
    10572. 

  10572. #endif
    10573. 

  10573. 

  10574.   return mng_next_jpeg_row (pData);    /* we've got one more row of gray-samples */
    10575. 

  10575. }
    10576. 

  10576. 

  10577. /* ************************************************************************** */
    10578. 

  10578. 

  10579. mng_retcode mng_store_jpeg_rgb8 (mng_datap pData)
    10580. 

  10580. {
    10581. 

  10581.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10582. 

  10582.   mng_uint8p     pWorkrow;
    10583. 

  10583.   mng_uint8p     pOutrow;
    10584. 

  10584. #if RGB_PIXELSIZE != 3
    10585. 

  10585.   mng_int32      iX;
    10586. 

  10586. #endif
    10587. 

  10587. 

  10588. #ifdef MNG_SUPPORT_TRACE
    10589. 

  10589.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8, MNG_LC_START);
    10590. 

  10590. #endif
    10591. 

  10591. 

  10592.   pWorkrow = pData->pJPEGrow;          /* temporary work pointers */
    10593. 

  10593.   pOutrow  = pBuf->pImgdata + (pData->iJPEGrow * pBuf->iRowsize);
    10594. 

  10594. 

  10595. #if RGB_PIXELSIZE == 3
    10596. 

  10596.                                        /* easy as pie ... */
    10597. 

  10597.   MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples * 3);
    10598. 

  10598. #else
    10599. 

  10599. #ifdef MNG_DECREMENT_LOOPS
    10600. 

  10600.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10601. 

  10601. #else
    10602. 

  10602.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10603. 

  10603. #endif
    10604. 

  10604.   {
    10605. 

  10605.     *pOutrow     = *pWorkrow;          /* copy pixel into object buffer */
    10606. 

  10606.     *(pOutrow+1) = *(pWorkrow+1);
    10607. 

  10607.     *(pOutrow+2) = *(pWorkrow+2);
    10608. 

  10608. 

  10609.     pOutrow  += 3;                     /* next pixel */
    10610. 

  10610.     pWorkrow += RGB_PIXELSIZE;
    10611. 

  10611.   }
    10612. 

  10612. #endif
    10613. 

  10613. 

  10614. #ifdef MNG_SUPPORT_TRACE
    10615. 

  10615.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8, MNG_LC_END);
    10616. 

  10616. #endif
    10617. 

  10617. 

  10618.   return mng_next_jpeg_row (pData);    /* we've got one more row of rgb-samples */
    10619. 

  10619. }
    10620. 

  10620. 

  10621. /* ************************************************************************** */
    10622. 

  10622. 

  10623. mng_retcode mng_store_jpeg_ga8 (mng_datap pData)
    10624. 

  10624. {
    10625. 

  10625.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10626. 

  10626.   mng_uint8p     pWorkrow;
    10627. 

  10627.   mng_uint8p     pOutrow;
    10628. 

  10628.   mng_int32      iX;
    10629. 

  10629. 

  10630. #ifdef MNG_SUPPORT_TRACE
    10631. 

  10631.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_GA8, MNG_LC_START);
    10632. 

  10632. #endif
    10633. 

  10633. 

  10634.   pWorkrow = pData->pJPEGrow;          /* temporary work pointers */
    10635. 

  10635.   pOutrow  = pBuf->pImgdata + (pData->iJPEGrow * pBuf->iRowsize);
    10636. 

  10636. 

  10637. #ifdef MNG_DECREMENT_LOOPS
    10638. 

  10638.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10639. 

  10639. #else
    10640. 

  10640.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10641. 

  10641. #endif
    10642. 

  10642.   {
    10643. 

  10643.     *pOutrow = *pWorkrow;              /* copy into object buffer */
    10644. 

  10644. 

  10645.     pOutrow += 2;                      /* next pixel */
    10646. 

  10646.     pWorkrow++;
    10647. 

  10647.   }
    10648. 

  10648. 

  10649. #ifdef MNG_SUPPORT_TRACE
    10650. 

  10650.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_GA8, MNG_LC_END);
    10651. 

  10651. #endif
    10652. 

  10652. 

  10653.   return mng_next_jpeg_row (pData);    /* we've got one more row of gray-samples */
    10654. 

  10654. }
    10655. 

  10655. 

  10656. /* ************************************************************************** */
    10657. 

  10657. 

  10658. mng_retcode mng_store_jpeg_rgba8 (mng_datap pData)
    10659. 

  10659. {
    10660. 

  10660.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10661. 

  10661.   mng_uint8p     pWorkrow;
    10662. 

  10662.   mng_uint8p     pOutrow;
    10663. 

  10663.   mng_int32      iX;
    10664. 

  10664. 

  10665. #ifdef MNG_SUPPORT_TRACE
    10666. 

  10666.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGBA8, MNG_LC_START);
    10667. 

  10667. #endif
    10668. 

  10668. 

  10669.   pWorkrow = pData->pJPEGrow;          /* temporary work pointers */
    10670. 

  10670.   pOutrow  = pBuf->pImgdata + (pData->iJPEGrow * pBuf->iRowsize);
    10671. 

  10671. 

  10672. #ifdef MNG_DECREMENT_LOOPS
    10673. 

  10673.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10674. 

  10674. #else
    10675. 

  10675.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10676. 

  10676. #endif
    10677. 

  10677.   {
    10678. 

  10678.     *pOutrow     = *pWorkrow;          /* copy pixel into object buffer */
    10679. 

  10679.     *(pOutrow+1) = *(pWorkrow+1);
    10680. 

  10680.     *(pOutrow+2) = *(pWorkrow+2);
    10681. 

  10681. 

  10682.     pOutrow  += 4;                     /* next pixel */
    10683. 

  10683.     pWorkrow += RGB_PIXELSIZE;
    10684. 

  10684.   }
    10685. 

  10685. 

  10686. #ifdef MNG_SUPPORT_TRACE
    10687. 

  10687.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGBA8, MNG_LC_END);
    10688. 

  10688. #endif
    10689. 

  10689. 

  10690.   return mng_next_jpeg_row (pData);    /* we've got one more row of rgb-samples */
    10691. 

  10691. }
    10692. 

  10692. 

  10693. /* ************************************************************************** */
    10694. 

  10694. 

  10695. mng_retcode mng_store_jpeg_g8_alpha (mng_datap pData)
    10696. 

  10696. {
    10697. 

  10697.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10698. 

  10698.   mng_uint8p     pWorkrow;
    10699. 

  10699.   mng_uint8p     pOutrow;
    10700. 

  10700.   mng_int32      iX;
    10701. 

  10701. 

  10702. #ifdef MNG_SUPPORT_TRACE
    10703. 

  10703.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_ALPHA, MNG_LC_START);
    10704. 

  10704. #endif
    10705. 

  10705.                                        /* temporary work pointers */
    10706. 

  10706.   pWorkrow = pData->pJPEGrow2;
    10707. 

  10707.   pOutrow  = pBuf->pImgdata + (pData->iJPEGalpharow * pBuf->iRowsize) + 1;
    10708. 

  10708. 

  10709. #ifdef MNG_DECREMENT_LOOPS
    10710. 

  10710.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10711. 

  10711. #else
    10712. 

  10712.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10713. 

  10713. #endif
    10714. 

  10714.   {
    10715. 

  10715.     *pOutrow = *pWorkrow;              /* put in object buffer */
    10716. 

  10716. 

  10717.     pOutrow += 2;                      /* next pixel */
    10718. 

  10718.     pWorkrow++;
    10719. 

  10719.   }
    10720. 

  10720. 

  10721. #ifdef MNG_SUPPORT_TRACE
    10722. 

  10722.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_ALPHA, MNG_LC_END);
    10723. 

  10723. #endif
    10724. 

  10724.                                        /* we've got one more row of alpha-samples */
    10725. 

  10725.   return mng_next_jpeg_alpharow (pData);
    10726. 

  10726. }
    10727. 

  10727. 

  10728. /* ************************************************************************** */
    10729. 

  10729. 

  10730. mng_retcode mng_store_jpeg_rgb8_alpha (mng_datap pData)
    10731. 

  10731. {
    10732. 

  10732.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10733. 

  10733.   mng_uint8p     pWorkrow;
    10734. 

  10734.   mng_uint8p     pOutrow;
    10735. 

  10735.   mng_int32      iX;
    10736. 

  10736. 

  10737. #ifdef MNG_SUPPORT_TRACE
    10738. 

  10738.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_ALPHA, MNG_LC_START);
    10739. 

  10739. #endif
    10740. 

  10740.                                        /* temporary work pointers */
    10741. 

  10741.   pWorkrow = pData->pJPEGrow2;
    10742. 

  10742.   pOutrow  = pBuf->pImgdata + (pData->iJPEGalpharow * pBuf->iRowsize) + 3;
    10743. 

  10743. 

  10744. #ifdef MNG_DECREMENT_LOOPS
    10745. 

  10745.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10746. 

  10746. #else
    10747. 

  10747.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10748. 

  10748. #endif
    10749. 

  10749.   {
    10750. 

  10750.     *pOutrow = *pWorkrow;              /* put in object buffer */
    10751. 

  10751. 

  10752.     pOutrow += 4;                      /* next pixel */
    10753. 

  10753.     pWorkrow++;
    10754. 

  10754.   }
    10755. 

  10755. 

  10756. #ifdef MNG_SUPPORT_TRACE
    10757. 

  10757.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_ALPHA, MNG_LC_END);
    10758. 

  10758. #endif
    10759. 

  10759.                                        /* we've got one more row of alpha-samples */
    10760. 

  10760.   return mng_next_jpeg_alpharow (pData);
    10761. 

  10761. }
    10762. 

  10762. 

  10763. /* ************************************************************************** */
    10764. 

  10764. 

  10765. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    10766. 

  10766. mng_retcode mng_store_jpeg_g8_a1 (mng_datap pData)
    10767. 

  10767. {
    10768. 

  10768.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10769. 

  10769.   mng_uint8p     pWorkrow;
    10770. 

  10770.   mng_uint8p     pOutrow;
    10771. 

  10771.   mng_int32      iX;
    10772. 

  10772.   mng_uint8      iB;
    10773. 

  10773.   mng_uint8      iM;
    10774. 

  10774. 

  10775. #ifdef MNG_SUPPORT_TRACE
    10776. 

  10776.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A1, MNG_LC_START);
    10777. 

  10777. #endif
    10778. 

  10778.                                        /* temporary work pointers */
    10779. 

  10779.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10780. 

  10780.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10781. 

  10781.                               (pData->iCol * pBuf->iSamplesize) + 1;
    10782. 

  10782.   iM       = 0;                        /* start at pixel 0 */
    10783. 

  10783.   iB       = 0;
    10784. 

  10784. 

  10785. #ifdef MNG_DECREMENT_LOOPS
    10786. 

  10786.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10787. 

  10787. #else
    10788. 

  10788.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10789. 

  10789. #endif
    10790. 

  10790.   {
    10791. 

  10791.     if (!iM)                           /* mask underflow ? */
    10792. 

  10792.     {
    10793. 

  10793.       iB = *pWorkrow;                  /* get next input-byte */
    10794. 

  10794.       pWorkrow++;
    10795. 

  10795.       iM = 0x80;
    10796. 

  10796.     }
    10797. 

  10797. 

  10798.     if (iB & iM)                       /* is it opaque ? */
    10799. 

  10799.       *pOutrow = 0xFF;                 /* opaque */
    10800. 

  10800.     else
    10801. 

  10801.       *pOutrow = 0x00;                 /* transparent */
    10802. 

  10802. 

  10803.     pOutrow += 2;                      /* next pixel */
    10804. 

  10804.     iM >>=  1;
    10805. 

  10805.   }
    10806. 

  10806. 

  10807. #ifdef MNG_SUPPORT_TRACE
    10808. 

  10808.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A1, MNG_LC_END);
    10809. 

  10809. #endif
    10810. 

  10810.                                        /* we've got one more row of alpha-samples */
    10811. 

  10811.   return mng_next_jpeg_alpharow (pData);
    10812. 

  10812. }
    10813. 

  10813. 

  10814. /* ************************************************************************** */
    10815. 

  10815. 

  10816. mng_retcode mng_store_jpeg_g8_a2 (mng_datap pData)
    10817. 

  10817. {
    10818. 

  10818.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10819. 

  10819.   mng_uint8p     pWorkrow;
    10820. 

  10820.   mng_uint8p     pOutrow;
    10821. 

  10821.   mng_int32      iX;
    10822. 

  10822.   mng_uint8      iB;
    10823. 

  10823.   mng_uint8      iM;
    10824. 

  10824.   mng_uint32     iS;
    10825. 

  10825. 

  10826. #ifdef MNG_SUPPORT_TRACE
    10827. 

  10827.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A2, MNG_LC_START);
    10828. 

  10828. #endif
    10829. 

  10829.                                        /* temporary work pointers */
    10830. 

  10830.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10831. 

  10831.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10832. 

  10832.                               (pData->iCol * pBuf->iSamplesize) + 1;
    10833. 

  10833.   iM       = 0;                        /* start at pixel 0 */
    10834. 

  10834.   iB       = 0;
    10835. 

  10835.   iS       = 0;
    10836. 

  10836. 

  10837. #ifdef MNG_DECREMENT_LOOPS
    10838. 

  10838.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10839. 

  10839. #else
    10840. 

  10840.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10841. 

  10841. #endif
    10842. 

  10842.   {
    10843. 

  10843.     if (!iM)                           /* mask underflow ? */
    10844. 

  10844.     {
    10845. 

  10845.       iB = *pWorkrow;                  /* get next input-byte */
    10846. 

  10846.       pWorkrow++;
    10847. 

  10847.       iM = 0xC0;
    10848. 

  10848.       iS = 6;
    10849. 

  10849.     }
    10850. 

  10850. 

  10851. #ifdef MNG_OPTIMIZE_FOOTPRINT_SWITCH
    10852. 

  10852.     {
    10853. 

  10853.       const mng_uint8  alpha_level[4] = { 0x00, 0x55, 0xAA, 0xFF};
    10854. 

  10854.         *pOutrow = alpha_level[((iB & iM) >> iS)] ;
    10855. 

  10855.     }
    10856. 

  10856. #else
    10857. 

  10857.     switch ((iB & iM) >> iS)           /* determine the alpha level */
    10858. 

  10858.     {
    10859. 

  10859.       case 0x03 : { *pOutrow = 0xFF; break; }
    10860. 

  10860.       case 0x02 : { *pOutrow = 0xAA; break; }
    10861. 

  10861.       case 0x01 : { *pOutrow = 0x55; break; }
    10862. 

  10862.       default   : { *pOutrow = 0x00; }
    10863. 

  10863.     }
    10864. 

  10864. #endif
    10865. 

  10865. 

  10866.     pOutrow += 2;                      /* next pixel */
    10867. 

  10867.     iM >>=  2;
    10868. 

  10868.     iS -= 2;
    10869. 

  10869.   }
    10870. 

  10870. 

  10871. #ifdef MNG_SUPPORT_TRACE
    10872. 

  10872.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A2, MNG_LC_END);
    10873. 

  10873. #endif
    10874. 

  10874.                                        /* we've got one more row of alpha-samples */
    10875. 

  10875.   return mng_next_jpeg_alpharow (pData);
    10876. 

  10876. }
    10877. 

  10877. 

  10878. /* ************************************************************************** */
    10879. 

  10879. 

  10880. mng_retcode mng_store_jpeg_g8_a4 (mng_datap pData)
    10881. 

  10881. {
    10882. 

  10882.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10883. 

  10883.   mng_uint8p     pWorkrow;
    10884. 

  10884.   mng_uint8p     pOutrow;
    10885. 

  10885.   mng_int32      iX;
    10886. 

  10886.   mng_uint8      iB;
    10887. 

  10887.   mng_uint8      iM;
    10888. 

  10888.   mng_uint32     iS;
    10889. 

  10889.   mng_uint8      iQ;
    10890. 

  10890. 

  10891. #ifdef MNG_SUPPORT_TRACE
    10892. 

  10892.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A4, MNG_LC_START);
    10893. 

  10893. #endif
    10894. 

  10894.                                        /* temporary work pointers */
    10895. 

  10895.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10896. 

  10896.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10897. 

  10897.                               (pData->iCol * pBuf->iSamplesize) + 1;
    10898. 

  10898.   iM       = 0;                        /* start at pixel 0 */
    10899. 

  10899.   iB       = 0;
    10900. 

  10900.   iS       = 0;
    10901. 

  10901. 

  10902. #ifdef MNG_DECREMENT_LOOPS
    10903. 

  10903.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10904. 

  10904. #else
    10905. 

  10905.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10906. 

  10906. #endif
    10907. 

  10907.   {
    10908. 

  10908.     if (!iM)                           /* mask underflow ? */
    10909. 

  10909.     {
    10910. 

  10910.       iB = *pWorkrow;                  /* get next input-byte */
    10911. 

  10911.       pWorkrow++;
    10912. 

  10912.       iM = 0xF0;
    10913. 

  10913.       iS = 4;
    10914. 

  10914.     }
    10915. 

  10915.                                        /* get the alpha level */
    10916. 

  10916.     iQ = (mng_uint8)((iB & iM) >> iS);
    10917. 

  10917.     iQ = (mng_uint8)(iQ + (iQ << 4));  /* expand to 8-bit by replication */
    10918. 

  10918. 

  10919.     *pOutrow = iQ;                     /* put in object buffer */
    10920. 

  10920. 

  10921.     pOutrow += 2;                      /* next pixel */
    10922. 

  10922.     iM >>=  4;
    10923. 

  10923.     iS -= 4;
    10924. 

  10924.   }
    10925. 

  10925. 

  10926. #ifdef MNG_SUPPORT_TRACE
    10927. 

  10927.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A4, MNG_LC_END);
    10928. 

  10928. #endif
    10929. 

  10929.                                        /* we've got one more row of alpha-samples */
    10930. 

  10930.   return mng_next_jpeg_alpharow (pData);
    10931. 

  10931. }
    10932. 

  10932. #endif
    10933. 

  10933. 

  10934. /* ************************************************************************** */
    10935. 

  10935. 

  10936. mng_retcode mng_store_jpeg_g8_a8 (mng_datap pData)
    10937. 

  10937. {
    10938. 

  10938.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10939. 

  10939.   mng_uint8p     pWorkrow;
    10940. 

  10940.   mng_uint8p     pOutrow;
    10941. 

  10941.   mng_int32      iX;
    10942. 

  10942. 

  10943. #ifdef MNG_SUPPORT_TRACE
    10944. 

  10944.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A8, MNG_LC_START);
    10945. 

  10945. #endif
    10946. 

  10946.                                        /* temporary work pointers */
    10947. 

  10947.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10948. 

  10948.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10949. 

  10949.                               (pData->iCol * pBuf->iSamplesize) + 1;
    10950. 

  10950. 

  10951. #ifdef MNG_DECREMENT_LOOPS
    10952. 

  10952.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10953. 

  10953. #else
    10954. 

  10954.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10955. 

  10955. #endif
    10956. 

  10956.   {
    10957. 

  10957.     *pOutrow = *pWorkrow;              /* put in object buffer */
    10958. 

  10958. 

  10959.     pOutrow += 2;                      /* next pixel */
    10960. 

  10960.     pWorkrow++;
    10961. 

  10961.   }
    10962. 

  10962. 

  10963. #ifdef MNG_SUPPORT_TRACE
    10964. 

  10964.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A8, MNG_LC_END);
    10965. 

  10965. #endif
    10966. 

  10966.                                        /* we've got one more row of alpha-samples */
    10967. 

  10967.   return mng_next_jpeg_alpharow (pData);
    10968. 

  10968. }
    10969. 

  10969. 

  10970. /* ************************************************************************** */
    10971. 

  10971. 

  10972. #ifndef MNG_NO_16BIT_SUPPORT
    10973. 

  10973. mng_retcode mng_store_jpeg_g8_a16 (mng_datap pData)
    10974. 

  10974. {
    10975. 

  10975.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    10976. 

  10976.   mng_uint8p     pWorkrow;
    10977. 

  10977.   mng_uint8p     pOutrow;
    10978. 

  10978.   mng_int32      iX;
    10979. 

  10979. 

  10980. #ifdef MNG_SUPPORT_TRACE
    10981. 

  10981.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A16, MNG_LC_START);
    10982. 

  10982. #endif
    10983. 

  10983.                                        /* temporary work pointers */
    10984. 

  10984.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    10985. 

  10985.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    10986. 

  10986.                               (pData->iCol * pBuf->iSamplesize) + 1;
    10987. 

  10987. 

  10988. #ifdef MNG_DECREMENT_LOOPS
    10989. 

  10989.   for (iX = pData->iRowsamples; iX > 0; iX--)
    10990. 

  10990. #else
    10991. 

  10991.   for (iX = 0; iX < pData->iRowsamples; iX++)
    10992. 

  10992. #endif
    10993. 

  10993.   {
    10994. 

  10994.     *pOutrow = *pWorkrow;              /* only high-order byte! */
    10995. 

  10995. 

  10996.     pOutrow  += 2;                     /* next pixel */
    10997. 

  10997.     pWorkrow += 2;
    10998. 

  10998.   }
    10999. 

  10999. 

  11000. #ifdef MNG_SUPPORT_TRACE
    11001. 

  11001.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G8_A16, MNG_LC_END);
    11002. 

  11002. #endif
    11003. 

  11003.                                        /* we've got one more row of alpha-samples */
    11004. 

  11004.   return mng_next_jpeg_alpharow (pData);
    11005. 

  11005. }
    11006. 

  11006. #endif
    11007. 

  11007. 

  11008. /* ************************************************************************** */
    11009. 

  11009. 

  11010. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    11011. 

  11011. mng_retcode mng_store_jpeg_rgb8_a1 (mng_datap pData)
    11012. 

  11012. {
    11013. 

  11013.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11014. 

  11014.   mng_uint8p     pWorkrow;
    11015. 

  11015.   mng_uint8p     pOutrow;
    11016. 

  11016.   mng_int32      iX;
    11017. 

  11017.   mng_uint8      iB;
    11018. 

  11018.   mng_uint8      iM;
    11019. 

  11019. 

  11020. #ifdef MNG_SUPPORT_TRACE
    11021. 

  11021.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A1, MNG_LC_START);
    11022. 

  11022. #endif
    11023. 

  11023.                                        /* temporary work pointers */
    11024. 

  11024.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11025. 

  11025.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11026. 

  11026.                               (pData->iCol * pBuf->iSamplesize) + 3;
    11027. 

  11027.   iM       = 0;                        /* start at pixel 0 */
    11028. 

  11028.   iB       = 0;
    11029. 

  11029. 

  11030. #ifdef MNG_DECREMENT_LOOPS
    11031. 

  11031.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11032. 

  11032. #else
    11033. 

  11033.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11034. 

  11034. #endif
    11035. 

  11035.   {
    11036. 

  11036.     if (!iM)                           /* mask underflow ? */
    11037. 

  11037.     {
    11038. 

  11038.       iB = *pWorkrow;                  /* get next input-byte */
    11039. 

  11039.       pWorkrow++;
    11040. 

  11040.       iM = 0x80;
    11041. 

  11041.     }
    11042. 

  11042. 

  11043.     if (iB & iM)                       /* is it opaque ? */
    11044. 

  11044.       *pOutrow = 0xFF;                 /* opaque */
    11045. 

  11045.     else
    11046. 

  11046.       *pOutrow = 0x00;                 /* transparent */
    11047. 

  11047. 

  11048.     pOutrow += 4;                      /* next pixel */
    11049. 

  11049.     iM >>=  1;
    11050. 

  11050.   }
    11051. 

  11051. 

  11052. #ifdef MNG_SUPPORT_TRACE
    11053. 

  11053.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A1, MNG_LC_END);
    11054. 

  11054. #endif
    11055. 

  11055.                                        /* we've got one more row of alpha-samples */
    11056. 

  11056.   return mng_next_jpeg_alpharow (pData);
    11057. 

  11057. }
    11058. 

  11058. 

  11059. /* ************************************************************************** */
    11060. 

  11060. 

  11061. mng_retcode mng_store_jpeg_rgb8_a2 (mng_datap pData)
    11062. 

  11062. {
    11063. 

  11063.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11064. 

  11064.   mng_uint8p     pWorkrow;
    11065. 

  11065.   mng_uint8p     pOutrow;
    11066. 

  11066.   mng_int32      iX;
    11067. 

  11067.   mng_uint8      iB;
    11068. 

  11068.   mng_uint8      iM;
    11069. 

  11069.   mng_uint32     iS;
    11070. 

  11070. 

  11071. #ifdef MNG_SUPPORT_TRACE
    11072. 

  11072.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A2, MNG_LC_START);
    11073. 

  11073. #endif
    11074. 

  11074.                                        /* temporary work pointers */
    11075. 

  11075.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11076. 

  11076.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11077. 

  11077.                               (pData->iCol * pBuf->iSamplesize) + 3;
    11078. 

  11078.   iM       = 0;                        /* start at pixel 0 */
    11079. 

  11079.   iB       = 0;
    11080. 

  11080.   iS       = 0;
    11081. 

  11081. 

  11082. #ifdef MNG_DECREMENT_LOOPS
    11083. 

  11083.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11084. 

  11084. #else
    11085. 

  11085.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11086. 

  11086. #endif
    11087. 

  11087.   {
    11088. 

  11088.     if (!iM)                           /* mask underflow ? */
    11089. 

  11089.     {
    11090. 

  11090.       iB = *pWorkrow;                  /* get next input-byte */
    11091. 

  11091.       pWorkrow++;
    11092. 

  11092.       iM = 0xC0;
    11093. 

  11093.       iS = 6;
    11094. 

  11094.     }
    11095. 

  11095. 

  11096. #ifdef MNG_OPTIMIZE_FOOTPRINT_SWITCH
    11097. 

  11097.     {
    11098. 

  11098.       const mng_uint8  alpha_level[4] = { 0x00, 0x55, 0xAA, 0xFF};
    11099. 

  11099.       *pOutrow = alpha_level[((iB & iM) >> iS)] ;
    11100. 

  11100.     }
    11101. 

  11101. #else
    11102. 

  11102.     switch ((iB & iM) >> iS)           /* determine the alpha level */
    11103. 

  11103.     {
    11104. 

  11104.       case 0x03 : { *pOutrow = 0xFF; break; }
    11105. 

  11105.       case 0x02 : { *pOutrow = 0xAA; break; }
    11106. 

  11106.       case 0x01 : { *pOutrow = 0x55; break; }
    11107. 

  11107.       default   : { *pOutrow = 0x00; }
    11108. 

  11108.     }
    11109. 

  11109. #endif
    11110. 

  11110. 

  11111.     pOutrow += 4;                      /* next pixel */
    11112. 

  11112.     iM >>=  2;
    11113. 

  11113.     iS -= 2;
    11114. 

  11114.   }
    11115. 

  11115. 

  11116. #ifdef MNG_SUPPORT_TRACE
    11117. 

  11117.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A2, MNG_LC_END);
    11118. 

  11118. #endif
    11119. 

  11119.                                        /* we've got one more row of alpha-samples */
    11120. 

  11120.   return mng_next_jpeg_alpharow (pData);
    11121. 

  11121. }
    11122. 

  11122. 

  11123. /* ************************************************************************** */
    11124. 

  11124. 

  11125. mng_retcode mng_store_jpeg_rgb8_a4 (mng_datap pData)
    11126. 

  11126. {
    11127. 

  11127.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11128. 

  11128.   mng_uint8p     pWorkrow;
    11129. 

  11129.   mng_uint8p     pOutrow;
    11130. 

  11130.   mng_int32      iX;
    11131. 

  11131.   mng_uint8      iB;
    11132. 

  11132.   mng_uint8      iM;
    11133. 

  11133.   mng_uint32     iS;
    11134. 

  11134.   mng_uint8      iQ;
    11135. 

  11135. 

  11136. #ifdef MNG_SUPPORT_TRACE
    11137. 

  11137.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A4, MNG_LC_START);
    11138. 

  11138. #endif
    11139. 

  11139.                                        /* temporary work pointers */
    11140. 

  11140.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11141. 

  11141.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11142. 

  11142.                               (pData->iCol * pBuf->iSamplesize) + 3;
    11143. 

  11143.   iM       = 0;                        /* start at pixel 0 */
    11144. 

  11144.   iB       = 0;
    11145. 

  11145.   iS       = 0;
    11146. 

  11146. 

  11147. #ifdef MNG_DECREMENT_LOOPS
    11148. 

  11148.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11149. 

  11149. #else
    11150. 

  11150.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11151. 

  11151. #endif
    11152. 

  11152.   {
    11153. 

  11153.     if (!iM)                           /* mask underflow ? */
    11154. 

  11154.     {
    11155. 

  11155.       iB = *pWorkrow;                  /* get next input-byte */
    11156. 

  11156.       pWorkrow++;
    11157. 

  11157.       iM = 0xF0;
    11158. 

  11158.       iS = 4;
    11159. 

  11159.     }
    11160. 

  11160.                                        /* get the alpha level */
    11161. 

  11161.     iQ = (mng_uint8)((iB & iM) >> iS);
    11162. 

  11162.     iQ = (mng_uint8)(iQ + (iQ << 4));  /* expand to 8-bit by replication */
    11163. 

  11163. 

  11164.     *pOutrow = iQ;                     /* put in object buffer */
    11165. 

  11165. 

  11166.     pOutrow += 4;                      /* next pixel */
    11167. 

  11167.     iM >>=  4;
    11168. 

  11168.     iS -= 4;
    11169. 

  11169.   }
    11170. 

  11170. 

  11171. #ifdef MNG_SUPPORT_TRACE
    11172. 

  11172.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A4, MNG_LC_END);
    11173. 

  11173. #endif
    11174. 

  11174.                                        /* we've got one more row of alpha-samples */
    11175. 

  11175.   return mng_next_jpeg_alpharow (pData);
    11176. 

  11176. }
    11177. 

  11177. #endif
    11178. 

  11178. 

  11179. /* ************************************************************************** */
    11180. 

  11180. 

  11181. mng_retcode mng_store_jpeg_rgb8_a8 (mng_datap pData)
    11182. 

  11182. {
    11183. 

  11183.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11184. 

  11184.   mng_uint8p     pWorkrow;
    11185. 

  11185.   mng_uint8p     pOutrow;
    11186. 

  11186.   mng_int32      iX;
    11187. 

  11187. 

  11188. #ifdef MNG_SUPPORT_TRACE
    11189. 

  11189.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A8, MNG_LC_START);
    11190. 

  11190. #endif
    11191. 

  11191.                                        /* temporary work pointers */
    11192. 

  11192.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11193. 

  11193.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11194. 

  11194.                               (pData->iCol * pBuf->iSamplesize) + 3;
    11195. 

  11195. 

  11196. #ifdef MNG_DECREMENT_LOOPS
    11197. 

  11197.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11198. 

  11198. #else
    11199. 

  11199.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11200. 

  11200. #endif
    11201. 

  11201.   {
    11202. 

  11202.     *pOutrow = *pWorkrow;              /* put in buffer */
    11203. 

  11203. 

  11204.     pOutrow += 4;                      /* next pixel */
    11205. 

  11205.     pWorkrow++;
    11206. 

  11206.   }
    11207. 

  11207. 

  11208. #ifdef MNG_SUPPORT_TRACE
    11209. 

  11209.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A8, MNG_LC_END);
    11210. 

  11210. #endif
    11211. 

  11211.                                        /* we've got one more row of alpha-samples */
    11212. 

  11212.   return mng_next_jpeg_alpharow (pData);
    11213. 

  11213. }
    11214. 

  11214. 

  11215. /* ************************************************************************** */
    11216. 

  11216. 

  11217. #ifndef MNG_NO_16BIT_SUPPORT
    11218. 

  11218. mng_retcode mng_store_jpeg_rgb8_a16 (mng_datap pData)
    11219. 

  11219. {
    11220. 

  11220.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11221. 

  11221.   mng_uint8p     pWorkrow;
    11222. 

  11222.   mng_uint8p     pOutrow;
    11223. 

  11223.   mng_int32      iX;
    11224. 

  11224. 

  11225. #ifdef MNG_SUPPORT_TRACE
    11226. 

  11226.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A16, MNG_LC_START);
    11227. 

  11227. #endif
    11228. 

  11228.                                        /* temporary work pointers */
    11229. 

  11229.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11230. 

  11230.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11231. 

  11231.                               (pData->iCol * pBuf->iSamplesize) + 3;
    11232. 

  11232. 

  11233. #ifdef MNG_DECREMENT_LOOPS
    11234. 

  11234.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11235. 

  11235. #else
    11236. 

  11236.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11237. 

  11237. #endif
    11238. 

  11238.   {
    11239. 

  11239.     *pOutrow = *pWorkrow;              /* only high-order byte */
    11240. 

  11240. 

  11241.     pOutrow  += 4;                     /* next pixel */
    11242. 

  11242.     pWorkrow += 2;
    11243. 

  11243.   }
    11244. 

  11244. 

  11245. #ifdef MNG_SUPPORT_TRACE
    11246. 

  11246.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_RGB8_A16, MNG_LC_END);
    11247. 

  11247. #endif
    11248. 

  11248.                                        /* we've got one more row of alpha-samples */
    11249. 

  11249.   return mng_next_jpeg_alpharow (pData);
    11250. 

  11250. }
    11251. 

  11251. #endif
    11252. 

  11252. 

  11253. /* ************************************************************************** */
    11254. 

  11254. 

  11255. #ifdef MNG_SUPPORT_JPEG12
    11256. 

  11256. mng_retcode mng_store_jpeg_g12_a1 (mng_datap pData)
    11257. 

  11257. {
    11258. 

  11258.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11259. 

  11259.   mng_uint8p     pWorkrow;
    11260. 

  11260.   mng_uint8p     pOutrow;
    11261. 

  11261.   mng_int32      iX;
    11262. 

  11262.   mng_uint8      iB;
    11263. 

  11263.   mng_uint8      iM;
    11264. 

  11264. 

  11265. #ifdef MNG_SUPPORT_TRACE
    11266. 

  11266.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A1, MNG_LC_START);
    11267. 

  11267. #endif
    11268. 

  11268.                                        /* temporary work pointers */
    11269. 

  11269.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11270. 

  11270.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11271. 

  11271.                               (pData->iCol * pBuf->iSamplesize) + 2;
    11272. 

  11272.   iM       = 0;                        /* start at pixel 0 */
    11273. 

  11273.   iB       = 0;
    11274. 

  11274. 

  11275. #ifdef MNG_DECREMENT_LOOPS
    11276. 

  11276.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11277. 

  11277. #else
    11278. 

  11278.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11279. 

  11279. #endif
    11280. 

  11280.   {
    11281. 

  11281.     if (!iM)                           /* mask underflow ? */
    11282. 

  11282.     {
    11283. 

  11283.       iB = *pWorkrow;                  /* get next input-byte */
    11284. 

  11284.       pWorkrow++;
    11285. 

  11285.       iM = 0x80;
    11286. 

  11286.     }
    11287. 

  11287. 

  11288.     if (iB & iM)                       /* opaque ? */
    11289. 

  11289.       mng_put_uint16 (pOutrow, 0xFFFF);/* opaque */
    11290. 

  11290.     else
    11291. 

  11291.       mng_put_uint16 (pOutrow, 0x0000);/* transparent */
    11292. 

  11292. 

  11293.     pOutrow += 4;                      /* next pixel */
    11294. 

  11294.     iM >>=  1;
    11295. 

  11295.   }
    11296. 

  11296. 

  11297. #ifdef MNG_SUPPORT_TRACE
    11298. 

  11298.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A1, MNG_LC_END);
    11299. 

  11299. #endif
    11300. 

  11300.                                        /* we've got one more row of alpha-samples */
    11301. 

  11301.   return mng_next_jpeg_alpharow (pData);
    11302. 

  11302. }
    11303. 

  11303. #endif /* MNG_SUPPORT_JPEG12 */
    11304. 

  11304. 

  11305. /* ************************************************************************** */
    11306. 

  11306. 

  11307. #ifdef MNG_SUPPORT_JPEG12
    11308. 

  11308. mng_retcode mng_store_jpeg_g12_a2 (mng_datap pData)
    11309. 

  11309. {
    11310. 

  11310.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11311. 

  11311.   mng_uint8p     pWorkrow;
    11312. 

  11312.   mng_uint8p     pOutrow;
    11313. 

  11313.   mng_int32      iX;
    11314. 

  11314.   mng_uint8      iB;
    11315. 

  11315.   mng_uint8      iM;
    11316. 

  11316.   mng_uint32     iS;
    11317. 

  11317. 

  11318. #ifdef MNG_SUPPORT_TRACE
    11319. 

  11319.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A2, MNG_LC_START);
    11320. 

  11320. #endif
    11321. 

  11321.                                        /* temporary work pointers */
    11322. 

  11322.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11323. 

  11323.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11324. 

  11324.                               (pData->iCol * pBuf->iSamplesize) + 2;
    11325. 

  11325.   iM       = 0;                        /* start at pixel 0 */
    11326. 

  11326.   iB       = 0;
    11327. 

  11327.   iS       = 0;
    11328. 

  11328. 

  11329. #ifdef MNG_DECREMENT_LOOPS
    11330. 

  11330.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11331. 

  11331. #else
    11332. 

  11332.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11333. 

  11333. #endif
    11334. 

  11334.   {
    11335. 

  11335.     if (!iM)                           /* mask underflow ? */
    11336. 

  11336.     {
    11337. 

  11337.       iB = *pWorkrow;                  /* get next input-byte */
    11338. 

  11338.       pWorkrow++;
    11339. 

  11339.       iM = 0xC0;
    11340. 

  11340.       iS = 6;
    11341. 

  11341.     }
    11342. 

  11342. 

  11343. #ifdef MNG_OPTIMIZE_FOOTPRINT_SWITCH
    11344. 

  11344.     {
    11345. 

  11345.       const mng_uint16  gray_level[4] = { 0x0000, 0x5555, 0xAAAA, 0xFFFF};
    11346. 

  11346.       mng_put_uint16 (pOutrow, gray_level[((iB & iM) >> iS)]) ;
    11347. 

  11347.     }
    11348. 

  11348. #else
    11349. 

  11349.     switch ((iB & iM) >> iS)           /* determine the gray level */
    11350. 

  11350.     {
    11351. 

  11351.       case 0x03 : { mng_put_uint16 (pOutrow, 0xFFFF); break; }
    11352. 

  11352.       case 0x02 : { mng_put_uint16 (pOutrow, 0xAAAA); break; }
    11353. 

  11353.       case 0x01 : { mng_put_uint16 (pOutrow, 0x5555); break; }
    11354. 

  11354.       default   : { mng_put_uint16 (pOutrow, 0x0000); }
    11355. 

  11355.     }
    11356. 

  11356. #endif
    11357. 

  11357. 

  11358.     pOutrow += 4;                      /* next pixel */
    11359. 

  11359.     iM >>=  2;
    11360. 

  11360.     iS -= 2;
    11361. 

  11361.   }
    11362. 

  11362. 

  11363. #ifdef MNG_SUPPORT_TRACE
    11364. 

  11364.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A2, MNG_LC_END);
    11365. 

  11365. #endif
    11366. 

  11366.                                        /* we've got one more row of alpha-samples */
    11367. 

  11367.   return mng_next_jpeg_alpharow (pData);
    11368. 

  11368. }
    11369. 

  11369. #endif /* MNG_SUPPORT_JPEG12 */
    11370. 

  11370. 

  11371. /* ************************************************************************** */
    11372. 

  11372. 

  11373. #ifdef MNG_SUPPORT_JPEG12
    11374. 

  11374. mng_retcode mng_store_jpeg_g12_a4 (mng_datap pData)
    11375. 

  11375. {
    11376. 

  11376.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11377. 

  11377.   mng_uint8p     pWorkrow;
    11378. 

  11378.   mng_uint8p     pOutrow;
    11379. 

  11379.   mng_int32      iX;
    11380. 

  11380.   mng_uint8      iB;
    11381. 

  11381.   mng_uint8      iM;
    11382. 

  11382.   mng_uint32     iS;
    11383. 

  11383.   mng_uint16     iQ;
    11384. 

  11384. 

  11385. #ifdef MNG_SUPPORT_TRACE
    11386. 

  11386.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A4, MNG_LC_START);
    11387. 

  11387. #endif
    11388. 

  11388.                                        /* temporary work pointers */
    11389. 

  11389.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11390. 

  11390.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11391. 

  11391.                               (pData->iCol * pBuf->iSamplesize) + 2;
    11392. 

  11392.   iM       = 0;                        /* start at pixel 0 */
    11393. 

  11393.   iB       = 0;
    11394. 

  11394.   iS       = 0;
    11395. 

  11395. 

  11396. #ifdef MNG_DECREMENT_LOOPS
    11397. 

  11397.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11398. 

  11398. #else
    11399. 

  11399.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11400. 

  11400. #endif
    11401. 

  11401.   {
    11402. 

  11402.     if (!iM)                           /* mask underflow ? */
    11403. 

  11403.     {
    11404. 

  11404.       iB = *pWorkrow;                  /* get next input-byte */
    11405. 

  11405.       pWorkrow++;
    11406. 

  11406.       iM = 0xF0;
    11407. 

  11407.       iS = 4;
    11408. 

  11408.     }
    11409. 

  11409.                                        /* get the gray level */
    11410. 

  11410.     iQ = (mng_uint16)((iB & iM) >> iS);
    11411. 

  11411.     iQ = (mng_uint16)(iQ + (iQ << 4)); /* expand to 16-bit by replication */
    11412. 

  11412.     iQ = (mng_uint16)(iQ + (iQ << 8));
    11413. 

  11413.                                        /* put in object buffer */
    11414. 

  11414.     mng_put_uint16 (pOutrow, iQ);
    11415. 

  11415. 

  11416.     pOutrow += 4;                      /* next pixel */
    11417. 

  11417.     iM >>=  4;
    11418. 

  11418.     iS -= 4;
    11419. 

  11419.   }
    11420. 

  11420. 

  11421. #ifdef MNG_SUPPORT_TRACE
    11422. 

  11422.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A4, MNG_LC_END);
    11423. 

  11423. #endif
    11424. 

  11424.                                        /* we've got one more row of alpha-samples */
    11425. 

  11425.   return mng_next_jpeg_alpharow (pData);
    11426. 

  11426. }
    11427. 

  11427. #endif /* MNG_SUPPORT_JPEG12 */
    11428. 

  11428. 

  11429. /* ************************************************************************** */
    11430. 

  11430. 

  11431. #ifdef MNG_SUPPORT_JPEG12
    11432. 

  11432. mng_retcode mng_store_jpeg_g12_a8 (mng_datap pData)
    11433. 

  11433. {
    11434. 

  11434.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11435. 

  11435.   mng_uint8p     pWorkrow;
    11436. 

  11436.   mng_uint8p     pOutrow;
    11437. 

  11437.   mng_int32      iX;
    11438. 

  11438.   mng_uint16     iW;
    11439. 

  11439. 

  11440. #ifdef MNG_SUPPORT_TRACE
    11441. 

  11441.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A8, MNG_LC_START);
    11442. 

  11442. #endif
    11443. 

  11443.                                        /* temporary work pointers */
    11444. 

  11444.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11445. 

  11445.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11446. 

  11446.                               (pData->iCol * pBuf->iSamplesize) + 2;
    11447. 

  11447. 

  11448. #ifdef MNG_DECREMENT_LOOPS
    11449. 

  11449.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11450. 

  11450. #else
    11451. 

  11451.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11452. 

  11452. #endif
    11453. 

  11453.   {
    11454. 

  11454.     iW = (mng_uint16)(*pWorkrow);      /* get input byte */
    11455. 

  11455.     iW = (mng_uint16)(iW + (iW << 8)); /* expand to 16-bit by replication */
    11456. 

  11456. 

  11457.     mng_put_uint16 (pOutrow, iW);      /* put in object buffer */
    11458. 

  11458. 

  11459.     pOutrow += 4;                      /* next pixel */
    11460. 

  11460.     pWorkrow++;
    11461. 

  11461.   }
    11462. 

  11462. 

  11463. #ifdef MNG_SUPPORT_TRACE
    11464. 

  11464.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A8, MNG_LC_END);
    11465. 

  11465. #endif
    11466. 

  11466.                                        /* we've got one more row of alpha-samples */
    11467. 

  11467.   return mng_next_jpeg_alpharow (pData);
    11468. 

  11468. }
    11469. 

  11469. #endif /* MNG_SUPPORT_JPEG12 */
    11470. 

  11470. 

  11471. /* ************************************************************************** */
    11472. 

  11472. 

  11473. #ifdef MNG_SUPPORT_JPEG12
    11474. 

  11474. #ifndef MNG_NO_16BIT_SUPPORT
    11475. 

  11475. mng_retcode mng_store_jpeg_g12_a16 (mng_datap pData)
    11476. 

  11476. {
    11477. 

  11477.   mng_imagedatap pBuf = (mng_imagedatap)pData->pStorebuf;
    11478. 

  11478.   mng_uint8p     pWorkrow;
    11479. 

  11479.   mng_uint8p     pOutrow;
    11480. 

  11480.   mng_int32      iX;
    11481. 

  11481. 

  11482. #ifdef MNG_SUPPORT_TRACE
    11483. 

  11483.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A16, MNG_LC_START);
    11484. 

  11484. #endif
    11485. 

  11485.                                        /* temporary work pointers */
    11486. 

  11486.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11487. 

  11487.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    11488. 

  11488.                               (pData->iCol * pBuf->iSamplesize) + 2;
    11489. 

  11489. 

  11490. #ifdef MNG_DECREMENT_LOOPS
    11491. 

  11491.   for (iX = pData->iRowsamples; iX > 0; iX--)
    11492. 

  11492. #else
    11493. 

  11493.   for (iX = 0; iX < pData->iRowsamples; iX++)
    11494. 

  11494. #endif
    11495. 

  11495.   {                                    /* copy it */
    11496. 

  11496.     mng_put_uint16 (pOutrow, mng_get_uint16 (pWorkrow));
    11497. 

  11497. 

  11498.     pOutrow  += 4;                     /* next pixel */
    11499. 

  11499.     pWorkrow += 2;
    11500. 

  11500.   }
    11501. 

  11501. 

  11502. #ifdef MNG_SUPPORT_TRACE
    11503. 

  11503.   MNG_TRACE (pData, MNG_FN_STORE_JPEG_G12_A16, MNG_LC_END);
    11504. 

  11504. #endif
    11505. 

  11505.                                        /* we've got one more row of alpha-samples */
    11506. 

  11506.   return mng_next_jpeg_alpharow (pData);
    11507. 

  11507. }
    11508. 

  11508. #endif
    11509. 

  11509. #endif /* MNG_SUPPORT_JPEG12 */
    11510. 

  11510. 

  11511. /* ************************************************************************** */
    11512. 

  11512. 

  11513. #endif /* MNG_INCLUDE_JNG */
    11514. 

  11514. 

  11515. #ifndef MNG_NO_DELTA_PNG
    11516. 

  11516. /* ************************************************************************** */
    11517. 

  11517. /* *                                                                        * */
    11518. 

  11518. /* * Delta-image row routines - apply the processed & uncompressed row-data * */
    11519. 

  11519. /* * onto the target "object"                                               * */
    11520. 

  11520. /* *                                                                        * */
    11521. 

  11521. /* ************************************************************************** */
    11522. 

  11522. 

  11523. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    11524. 

  11524. mng_retcode mng_delta_g1 (mng_datap pData)
    11525. 

  11525. {
    11526. 

  11526.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11527. 

  11527.   mng_uint8p     pWorkrow;
    11528. 

  11528.   mng_uint8p     pOutrow;
    11529. 

  11529.   mng_int32      iX;
    11530. 

  11530.   mng_uint8      iB;
    11531. 

  11531.   mng_uint8      iM;
    11532. 

  11532. 

  11533. #ifdef MNG_SUPPORT_TRACE
    11534. 

  11534.   MNG_TRACE (pData, MNG_FN_DELTA_G1, MNG_LC_START);
    11535. 

  11535. #endif
    11536. 

  11536.                                        /* temporary work pointers */
    11537. 

  11537.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11538. 

  11538.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11539. 

  11539.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11540. 

  11540.                               (pData->iCol         * pBuf->iSamplesize) +
    11541. 

  11541.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11542. 

  11542.   iM       = 0;                        /* start at pixel 0 */
    11543. 

  11543.   iB       = 0;
    11544. 

  11544.                                        /* pixel replace ? */
    11545. 

  11545.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11546. 

  11546.   {
    11547. 

  11547. #ifdef MNG_DECREMENT_LOOPS
    11548. 

  11548.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11549. 

  11549. #else
    11550. 

  11550.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11551. 

  11551. #endif
    11552. 

  11552.     {
    11553. 

  11553.       if (!iM)                         /* mask underflow ? */
    11554. 

  11554.       {
    11555. 

  11555.         iB = *pWorkrow;                /* get next input-byte */
    11556. 

  11556.         pWorkrow++;
    11557. 

  11557.         iM = 0x80;
    11558. 

  11558.       }
    11559. 

  11559. 

  11560.       if (iB & iM)                     /* is it white ? */
    11561. 

  11561.         *pOutrow = 0xFF;               /* white */
    11562. 

  11562.       else
    11563. 

  11563.         *pOutrow = 0x00;               /* black */
    11564. 

  11564. 

  11565.       pOutrow += pData->iColinc;       /* next pixel */
    11566. 

  11566.       iM >>=  1;
    11567. 

  11567.     }
    11568. 

  11568.   }
    11569. 

  11569.   else
    11570. 

  11570.   {                                    /* pixel add ! */
    11571. 

  11571. #ifdef MNG_DECREMENT_LOOPS
    11572. 

  11572.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11573. 

  11573. #else
    11574. 

  11574.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11575. 

  11575. #endif
    11576. 

  11576.     {
    11577. 

  11577.       if (!iM)                         /* mask underflow ? */
    11578. 

  11578.       {
    11579. 

  11579.         iB = *pWorkrow;                /* get next input-byte */
    11580. 

  11580.         pWorkrow++;
    11581. 

  11581.         iM = 0x80;
    11582. 

  11582.       }
    11583. 

  11583. 

  11584.       if (iB & iM)                     /* invert if it is white ? */
    11585. 

  11585.         *pOutrow = (mng_uint8)(*pOutrow ^ 0xFF);
    11586. 

  11586. 

  11587.       pOutrow += pData->iColinc;       /* next pixel */
    11588. 

  11588.       iM >>=  1;
    11589. 

  11589.     }
    11590. 

  11590.   }
    11591. 

  11591. 

  11592. #ifdef MNG_SUPPORT_TRACE
    11593. 

  11593.   MNG_TRACE (pData, MNG_FN_DELTA_G1, MNG_LC_END);
    11594. 

  11594. #endif
    11595. 

  11595. 

  11596.   return mng_store_g1 (pData);
    11597. 

  11597. }
    11598. 

  11598. 

  11599. /* ************************************************************************** */
    11600. 

  11600. 

  11601. mng_retcode mng_delta_g2 (mng_datap pData)
    11602. 

  11602. {
    11603. 

  11603.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11604. 

  11604.   mng_uint8p     pWorkrow;
    11605. 

  11605.   mng_uint8p     pOutrow;
    11606. 

  11606.   mng_int32      iX;
    11607. 

  11607.   mng_uint8      iB;
    11608. 

  11608.   mng_uint8      iM;
    11609. 

  11609.   mng_uint32     iS;
    11610. 

  11610. #ifdef MNG_OPTIMIZE_FOOTPRINT_SWITCH
    11611. 

  11611.   const mng_uint8  level[4] = { 0x00, 0x55, 0xAA, 0xFF};
    11612. 

  11612. #endif
    11613. 

  11613. 

  11614. #ifdef MNG_SUPPORT_TRACE
    11615. 

  11615.   MNG_TRACE (pData, MNG_FN_DELTA_G2, MNG_LC_START);
    11616. 

  11616. #endif
    11617. 

  11617.                                        /* temporary work pointers */
    11618. 

  11618.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11619. 

  11619.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11620. 

  11620.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11621. 

  11621.                               (pData->iCol         * pBuf->iSamplesize) +
    11622. 

  11622.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11623. 

  11623.   iM       = 0;                        /* start at pixel 0 */
    11624. 

  11624.   iB       = 0;
    11625. 

  11625.   iS       = 0;
    11626. 

  11626.                                        /* pixel replace ? */
    11627. 

  11627.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11628. 

  11628.   {
    11629. 

  11629. #ifdef MNG_DECREMENT_LOOPS
    11630. 

  11630.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11631. 

  11631. #else
    11632. 

  11632.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11633. 

  11633. #endif
    11634. 

  11634.     {
    11635. 

  11635.       if (!iM)                         /* mask underflow ? */
    11636. 

  11636.       {
    11637. 

  11637.         iB = *pWorkrow;                /* get next input-byte */
    11638. 

  11638.         pWorkrow++;
    11639. 

  11639.         iM = 0xC0;
    11640. 

  11640.         iS = 6;
    11641. 

  11641.       }
    11642. 

  11642. 

  11643. #ifdef MNG_OPTIMIZE_FOOTPRINT_SWITCH
    11644. 

  11644.     *pOutrow = level[((iB & iM) >> iS)] ;
    11645. 

  11645. #else
    11646. 

  11646.     switch ((iB & iM) >> iS)           /* determine the alpha level */
    11647. 

  11647.     {
    11648. 

  11648.       case 0x03 : { *pOutrow = 0xFF; break; }
    11649. 

  11649.       case 0x02 : { *pOutrow = 0xAA; break; }
    11650. 

  11650.       case 0x01 : { *pOutrow = 0x55; break; }
    11651. 

  11651.       default   : { *pOutrow = 0x00; }
    11652. 

  11652.     }
    11653. 

  11653. #endif
    11654. 

  11654. 

  11655.       pOutrow += pData->iColinc;       /* next pixel */
    11656. 

  11656.       iM >>=  2;
    11657. 

  11657.       iS -= 2;
    11658. 

  11658.     }
    11659. 

  11659.   }
    11660. 

  11660.   else
    11661. 

  11661.   {                                    /* pixel add ! */
    11662. 

  11662. #ifdef MNG_DECREMENT_LOOPS
    11663. 

  11663.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11664. 

  11664. #else
    11665. 

  11665.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11666. 

  11666. #endif
    11667. 

  11667.     {
    11668. 

  11668.       if (!iM)                         /* mask underflow ? */
    11669. 

  11669.       {
    11670. 

  11670.         iB = *pWorkrow;                /* get next input-byte */
    11671. 

  11671.         pWorkrow++;
    11672. 

  11672.         iM = 0xC0;
    11673. 

  11673.         iS = 6;
    11674. 

  11674.       }
    11675. 

  11675. 

  11676. #ifdef MNG_OPTIMIZE_FOOTPRINT_SWITCH
    11677. 

  11677.       *pOutrow = level[((*pOutrow >> 6) + ((iB & iM) >> iS)) & 0x03] ;
    11678. 

  11678. #else
    11679. 

  11679.       switch (((*pOutrow >> 6) + ((iB & iM) >> iS)) & 0x03)
    11680. 

  11680.       {
    11681. 

  11681.         case 0x03 : { *pOutrow = 0xFF; break; }
    11682. 

  11682.         case 0x02 : { *pOutrow = 0xAA; break; }
    11683. 

  11683.         case 0x01 : { *pOutrow = 0x55; break; }
    11684. 

  11684.         default   : { *pOutrow = 0x00; }
    11685. 

  11685.       }
    11686. 

  11686. #endif
    11687. 

  11687. 

  11688.       pOutrow += pData->iColinc;       /* next pixel */
    11689. 

  11689.       iM >>=  2;
    11690. 

  11690.       iS -= 2;
    11691. 

  11691.     }
    11692. 

  11692.   }
    11693. 

  11693. 

  11694. #ifdef MNG_SUPPORT_TRACE
    11695. 

  11695.   MNG_TRACE (pData, MNG_FN_DELTA_G2, MNG_LC_END);
    11696. 

  11696. #endif
    11697. 

  11697. 

  11698.   return mng_store_g2 (pData);
    11699. 

  11699. }
    11700. 

  11700. 

  11701. /* ************************************************************************** */
    11702. 

  11702. 

  11703. mng_retcode mng_delta_g4 (mng_datap pData)
    11704. 

  11704. {
    11705. 

  11705.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11706. 

  11706.   mng_uint8p     pWorkrow;
    11707. 

  11707.   mng_uint8p     pOutrow;
    11708. 

  11708.   mng_int32      iX;
    11709. 

  11709.   mng_uint8      iB;
    11710. 

  11710.   mng_uint8      iM;
    11711. 

  11711.   mng_uint32     iS;
    11712. 

  11712.   mng_uint8      iQ;
    11713. 

  11713. 

  11714. #ifdef MNG_SUPPORT_TRACE
    11715. 

  11715.   MNG_TRACE (pData, MNG_FN_DELTA_G4, MNG_LC_START);
    11716. 

  11716. #endif
    11717. 

  11717.                                        /* temporary work pointers */
    11718. 

  11718.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11719. 

  11719.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11720. 

  11720.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11721. 

  11721.                               (pData->iCol         * pBuf->iSamplesize) +
    11722. 

  11722.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11723. 

  11723.   iM       = 0;                        /* start at pixel 0 */
    11724. 

  11724.   iB       = 0;
    11725. 

  11725.   iS       = 0;
    11726. 

  11726.                                        /* pixel replace ? */
    11727. 

  11727.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11728. 

  11728.   {
    11729. 

  11729. #ifdef MNG_DECREMENT_LOOPS
    11730. 

  11730.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11731. 

  11731. #else
    11732. 

  11732.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11733. 

  11733. #endif
    11734. 

  11734.     {
    11735. 

  11735.       if (!iM)                         /* mask underflow ? */
    11736. 

  11736.       {
    11737. 

  11737.         iB = *pWorkrow;                /* get next input-byte */
    11738. 

  11738.         pWorkrow++;
    11739. 

  11739.         iM = 0xF0;
    11740. 

  11740.         iS = 4;
    11741. 

  11741.       }
    11742. 

  11742.                                        /* get the gray level */
    11743. 

  11743.       iQ = (mng_uint8)((iB & iM) >> iS);
    11744. 

  11744.                                        /* expand to 8-bit by replication */
    11745. 

  11745.       iQ = (mng_uint8)(iQ + (iQ << 4));
    11746. 

  11746. 

  11747.       *pOutrow = iQ;                   /* put in object buffer */
    11748. 

  11748. 

  11749.       pOutrow += pData->iColinc;       /* next pixel */
    11750. 

  11750.       iM >>=  4;
    11751. 

  11751.       iS -= 4;
    11752. 

  11752.     }
    11753. 

  11753.   }
    11754. 

  11754.   else
    11755. 

  11755.   {                                    /* pixel add ! */
    11756. 

  11756. #ifdef MNG_DECREMENT_LOOPS
    11757. 

  11757.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11758. 

  11758. #else
    11759. 

  11759.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11760. 

  11760. #endif
    11761. 

  11761.     {
    11762. 

  11762.       if (!iM)                         /* mask underflow ? */
    11763. 

  11763.       {
    11764. 

  11764.         iB = *pWorkrow;                /* get next input-byte */
    11765. 

  11765.         pWorkrow++;
    11766. 

  11766.         iM = 0xF0;
    11767. 

  11767.         iS = 4;
    11768. 

  11768.       }
    11769. 

  11769.                                        /* get the gray level */
    11770. 

  11770.       iQ = (mng_uint8)(((*pOutrow >> 4) + ((iB & iM) >> iS)) & 0x0F);
    11771. 

  11771.                                        /* expand to 8-bit by replication */
    11772. 

  11772.       iQ = (mng_uint8)(iQ + (iQ << 4));
    11773. 

  11773. 

  11774.       *pOutrow = iQ;                   /* put in object buffer */
    11775. 

  11775. 

  11776.       pOutrow += pData->iColinc;       /* next pixel */
    11777. 

  11777.       iM >>=  4;
    11778. 

  11778.       iS -= 4;
    11779. 

  11779.     }
    11780. 

  11780.   }
    11781. 

  11781. 

  11782. #ifdef MNG_SUPPORT_TRACE
    11783. 

  11783.   MNG_TRACE (pData, MNG_FN_DELTA_G4, MNG_LC_END);
    11784. 

  11784. #endif
    11785. 

  11785. 

  11786.   return mng_store_g4 (pData);
    11787. 

  11787. }
    11788. 

  11788. #endif /* MNG_NO_1_2_4BIT_SUPPORT */
    11789. 

  11789. 

  11790. /* ************************************************************************** */
    11791. 

  11791. 

  11792. mng_retcode mng_delta_g8 (mng_datap pData)
    11793. 

  11793. {
    11794. 

  11794.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11795. 

  11795.   mng_uint8p     pWorkrow;
    11796. 

  11796.   mng_uint8p     pOutrow;
    11797. 

  11797.   mng_int32      iX;
    11798. 

  11798. 

  11799. #ifdef MNG_SUPPORT_TRACE
    11800. 

  11800.   MNG_TRACE (pData, MNG_FN_DELTA_G8, MNG_LC_START);
    11801. 

  11801. #endif
    11802. 

  11802.                                        /* temporary work pointers */
    11803. 

  11803.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11804. 

  11804.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11805. 

  11805.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11806. 

  11806.                               (pData->iCol         * pBuf->iSamplesize) +
    11807. 

  11807.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11808. 

  11808.                                        /* pixel replace ? */
    11809. 

  11809.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11810. 

  11810.   {
    11811. 

  11811. #ifdef MNG_DECREMENT_LOOPS
    11812. 

  11812.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11813. 

  11813. #else
    11814. 

  11814.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11815. 

  11815. #endif
    11816. 

  11816.     {
    11817. 

  11817.       *pOutrow = *pWorkrow;            /* put in object buffer */
    11818. 

  11818. 

  11819.       pOutrow += pData->iColinc;       /* next pixel */
    11820. 

  11820.       pWorkrow++;
    11821. 

  11821.     }
    11822. 

  11822.   }
    11823. 

  11823.   else
    11824. 

  11824.   {                                    /* pixel add ! */
    11825. 

  11825. #ifdef MNG_DECREMENT_LOOPS
    11826. 

  11826.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11827. 

  11827. #else
    11828. 

  11828.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11829. 

  11829. #endif
    11830. 

  11830.     {                                  /* add to object buffer */
    11831. 

  11831.       *pOutrow = (mng_uint8)(*pOutrow + *pWorkrow);
    11832. 

  11832. 

  11833.       pOutrow += pData->iColinc;       /* next pixel */
    11834. 

  11834.       pWorkrow++;
    11835. 

  11835.     }
    11836. 

  11836.   }
    11837. 

  11837. 

  11838. #ifdef MNG_SUPPORT_TRACE
    11839. 

  11839.   MNG_TRACE (pData, MNG_FN_DELTA_G8, MNG_LC_END);
    11840. 

  11840. #endif
    11841. 

  11841. 

  11842.   return mng_store_g8 (pData);
    11843. 

  11843. }
    11844. 

  11844. 

  11845. /* ************************************************************************** */
    11846. 

  11846. 

  11847. #ifndef MNG_NO_16BIT_SUPPORT
    11848. 

  11848. mng_retcode mng_delta_g16 (mng_datap pData)
    11849. 

  11849. {
    11850. 

  11850.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11851. 

  11851.   mng_uint8p     pWorkrow;
    11852. 

  11852.   mng_uint8p     pOutrow;
    11853. 

  11853.   mng_int32      iX;
    11854. 

  11854. 

  11855. #ifdef MNG_SUPPORT_TRACE
    11856. 

  11856.   MNG_TRACE (pData, MNG_FN_DELTA_G16, MNG_LC_START);
    11857. 

  11857. #endif
    11858. 

  11858.                                        /* temporary work pointers */
    11859. 

  11859.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11860. 

  11860.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11861. 

  11861.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11862. 

  11862.                               (pData->iCol         * pBuf->iSamplesize) +
    11863. 

  11863.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11864. 

  11864.                                        /* pixel replace ? */
    11865. 

  11865.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11866. 

  11866.   {
    11867. 

  11867. #ifdef MNG_DECREMENT_LOOPS
    11868. 

  11868.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11869. 

  11869. #else
    11870. 

  11870.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11871. 

  11871. #endif
    11872. 

  11872.     {
    11873. 

  11873.       *pOutrow     = *pWorkrow;        /* put in object buffer */
    11874. 

  11874.       *(pOutrow+1) = *(pWorkrow+1);
    11875. 

  11875.                                        /* next pixel */
    11876. 

  11876.       pOutrow  += (pData->iColinc << 1);
    11877. 

  11877.       pWorkrow += 2;
    11878. 

  11878.     }
    11879. 

  11879.   }
    11880. 

  11880.   else
    11881. 

  11881.   {                                    /* pixel add ! */
    11882. 

  11882. #ifdef MNG_DECREMENT_LOOPS
    11883. 

  11883.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11884. 

  11884. #else
    11885. 

  11885.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11886. 

  11886. #endif
    11887. 

  11887.     {                                  /* add to object buffer */
    11888. 

  11888.       mng_put_uint16 (pOutrow, (mng_uint16)(mng_get_uint16 (pOutrow ) +
    11889. 

  11889.                                             mng_get_uint16 (pWorkrow)   ));
    11890. 

  11890.                                        /* next pixel */
    11891. 

  11891.       pOutrow  += (pData->iColinc << 1);
    11892. 

  11892.       pWorkrow += 2;
    11893. 

  11893.     }
    11894. 

  11894.   }
    11895. 

  11895. 

  11896. #ifdef MNG_SUPPORT_TRACE
    11897. 

  11897.   MNG_TRACE (pData, MNG_FN_DELTA_G16, MNG_LC_END);
    11898. 

  11898. #endif
    11899. 

  11899. 

  11900.   return mng_store_g16 (pData);
    11901. 

  11901. }
    11902. 

  11902. #endif
    11903. 

  11903. 

  11904. /* ************************************************************************** */
    11905. 

  11905. 

  11906. mng_retcode mng_delta_rgb8 (mng_datap pData)
    11907. 

  11907. {
    11908. 

  11908.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11909. 

  11909.   mng_uint8p     pWorkrow;
    11910. 

  11910.   mng_uint8p     pOutrow;
    11911. 

  11911.   mng_int32      iX;
    11912. 

  11912. 

  11913. #ifdef MNG_SUPPORT_TRACE
    11914. 

  11914.   MNG_TRACE (pData, MNG_FN_DELTA_RGB8, MNG_LC_START);
    11915. 

  11915. #endif
    11916. 

  11916.                                        /* temporary work pointers */
    11917. 

  11917.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11918. 

  11918.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11919. 

  11919.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11920. 

  11920.                               (pData->iCol         * pBuf->iSamplesize) +
    11921. 

  11921.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11922. 

  11922.                                        /* pixel replace ? */
    11923. 

  11923.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11924. 

  11924.   {
    11925. 

  11925. #ifdef MNG_DECREMENT_LOOPS
    11926. 

  11926.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11927. 

  11927. #else
    11928. 

  11928.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11929. 

  11929. #endif
    11930. 

  11930.     {
    11931. 

  11931.       *pOutrow     = *pWorkrow;        /* put in object buffer */
    11932. 

  11932.       *(pOutrow+1) = *(pWorkrow+1);
    11933. 

  11933.       *(pOutrow+2) = *(pWorkrow+2);
    11934. 

  11934.                                        /* next pixel */
    11935. 

  11935.       pOutrow  += (pData->iColinc * 3);
    11936. 

  11936.       pWorkrow += 3;
    11937. 

  11937.     }
    11938. 

  11938.   }
    11939. 

  11939.   else
    11940. 

  11940.   {                                    /* pixel add ! */
    11941. 

  11941. #ifdef MNG_DECREMENT_LOOPS
    11942. 

  11942.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11943. 

  11943. #else
    11944. 

  11944.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11945. 

  11945. #endif
    11946. 

  11946.     {                                  /* add to object buffer */
    11947. 

  11947.       *pOutrow     = (mng_uint8)(*pOutrow     + *pWorkrow    );
    11948. 

  11948.       *(pOutrow+1) = (mng_uint8)(*(pOutrow+1) + *(pWorkrow+1));
    11949. 

  11949.       *(pOutrow+2) = (mng_uint8)(*(pOutrow+2) + *(pWorkrow+2));
    11950. 

  11950.                                        /* next pixel */
    11951. 

  11951.       pOutrow  += (pData->iColinc * 3);
    11952. 

  11952.       pWorkrow += 3;
    11953. 

  11953.     }
    11954. 

  11954.   }
    11955. 

  11955. 

  11956. #ifdef MNG_SUPPORT_TRACE
    11957. 

  11957.   MNG_TRACE (pData, MNG_FN_DELTA_RGB8, MNG_LC_END);
    11958. 

  11958. #endif
    11959. 

  11959. 

  11960.   return mng_store_rgb8 (pData);
    11961. 

  11961. }
    11962. 

  11962. 

  11963. /* ************************************************************************** */
    11964. 

  11964. 

  11965. #ifndef MNG_NO_16BIT_SUPPORT
    11966. 

  11966. mng_retcode mng_delta_rgb16 (mng_datap pData)
    11967. 

  11967. {
    11968. 

  11968.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    11969. 

  11969.   mng_uint8p     pWorkrow;
    11970. 

  11970.   mng_uint8p     pOutrow;
    11971. 

  11971.   mng_int32      iX;
    11972. 

  11972. 

  11973. #ifdef MNG_SUPPORT_TRACE
    11974. 

  11974.   MNG_TRACE (pData, MNG_FN_DELTA_RGB16, MNG_LC_START);
    11975. 

  11975. #endif
    11976. 

  11976.                                        /* temporary work pointers */
    11977. 

  11977.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    11978. 

  11978.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    11979. 

  11979.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    11980. 

  11980.                               (pData->iCol         * pBuf->iSamplesize) +
    11981. 

  11981.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    11982. 

  11982.                                        /* pixel replace ? */
    11983. 

  11983.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    11984. 

  11984.   {
    11985. 

  11985. #ifdef MNG_DECREMENT_LOOPS
    11986. 

  11986.     for (iX = pData->iRowsamples; iX > 0; iX--)
    11987. 

  11987. #else
    11988. 

  11988.     for (iX = 0; iX < pData->iRowsamples; iX++)
    11989. 

  11989. #endif
    11990. 

  11990.     {
    11991. 

  11991.       *pOutrow     = *pWorkrow;        /* put in object buffer */
    11992. 

  11992.       *(pOutrow+1) = *(pWorkrow+1);
    11993. 

  11993.       *(pOutrow+2) = *(pWorkrow+2);
    11994. 

  11994.       *(pOutrow+3) = *(pWorkrow+3);
    11995. 

  11995.       *(pOutrow+4) = *(pWorkrow+4);
    11996. 

  11996.       *(pOutrow+5) = *(pWorkrow+5);
    11997. 

  11997.                                        /* next pixel */
    11998. 

  11998.       pOutrow  += (pData->iColinc * 6);
    11999. 

  11999.       pWorkrow += 6;
    12000. 

  12000.     }
    12001. 

  12001.   }
    12002. 

  12002.   else
    12003. 

  12003.   {                                    /* pixel add ! */
    12004. 

  12004. #ifdef MNG_DECREMENT_LOOPS
    12005. 

  12005.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12006. 

  12006. #else
    12007. 

  12007.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12008. 

  12008. #endif
    12009. 

  12009.     {                                  /* add to object buffer */
    12010. 

  12010.       mng_put_uint16 (pOutrow,   (mng_uint16)(mng_get_uint16 (pOutrow   ) +
    12011. 

  12011.                                               mng_get_uint16 (pWorkrow  )   ));
    12012. 

  12012.       mng_put_uint16 (pOutrow+2, (mng_uint16)(mng_get_uint16 (pOutrow+2 ) +
    12013. 

  12013.                                               mng_get_uint16 (pWorkrow+2)   ));
    12014. 

  12014.       mng_put_uint16 (pOutrow+4, (mng_uint16)(mng_get_uint16 (pOutrow+4 ) +
    12015. 

  12015.                                               mng_get_uint16 (pWorkrow+4)   ));
    12016. 

  12016.                                        /* next pixel */
    12017. 

  12017.       pOutrow  += (pData->iColinc * 6);
    12018. 

  12018.       pWorkrow += 6;
    12019. 

  12019.     }
    12020. 

  12020.   }
    12021. 

  12021. 

  12022. #ifdef MNG_SUPPORT_TRACE
    12023. 

  12023.   MNG_TRACE (pData, MNG_FN_DELTA_RGB16, MNG_LC_END);
    12024. 

  12024. #endif
    12025. 

  12025. 

  12026.   return mng_store_rgb16 (pData);
    12027. 

  12027. }
    12028. 

  12028. #endif
    12029. 

  12029. 

  12030. /* ************************************************************************** */
    12031. 

  12031. 

  12032. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    12033. 

  12033. mng_retcode mng_delta_idx1 (mng_datap pData)
    12034. 

  12034. {
    12035. 

  12035.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12036. 

  12036.   mng_uint8p     pWorkrow;
    12037. 

  12037.   mng_uint8p     pOutrow;
    12038. 

  12038.   mng_int32      iX;
    12039. 

  12039.   mng_uint8      iB;
    12040. 

  12040.   mng_uint8      iM;
    12041. 

  12041. 

  12042. #ifdef MNG_SUPPORT_TRACE
    12043. 

  12043.   MNG_TRACE (pData, MNG_FN_DELTA_IDX1, MNG_LC_START);
    12044. 

  12044. #endif
    12045. 

  12045.                                        /* temporary work pointers */
    12046. 

  12046.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12047. 

  12047.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12048. 

  12048.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12049. 

  12049.                               (pData->iCol         * pBuf->iSamplesize) +
    12050. 

  12050.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12051. 

  12051.   iM       = 0;                        /* start at pixel 0 */
    12052. 

  12052.   iB       = 0;
    12053. 

  12053.                                        /* pixel replace ? */
    12054. 

  12054.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12055. 

  12055.   {
    12056. 

  12056. #ifdef MNG_DECREMENT_LOOPS
    12057. 

  12057.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12058. 

  12058. #else
    12059. 

  12059.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12060. 

  12060. #endif
    12061. 

  12061.     {
    12062. 

  12062.       if (!iM)                         /* mask underflow ? */
    12063. 

  12063.       {
    12064. 

  12064.         iB = *pWorkrow;                /* get next input-byte */
    12065. 

  12065.         pWorkrow++;
    12066. 

  12066.         iM = 0x80;
    12067. 

  12067.       }
    12068. 

  12068. 

  12069.       if (iB & iM)                     /* put the right index value */
    12070. 

  12070.         *pOutrow = 1;
    12071. 

  12071.       else
    12072. 

  12072.         *pOutrow = 0;
    12073. 

  12073. 

  12074.       pOutrow += pData->iColinc;       /* next pixel */
    12075. 

  12075.       iM >>=  1;
    12076. 

  12076.     }
    12077. 

  12077.   }
    12078. 

  12078.   else
    12079. 

  12079.   {                                    /* pixel add ! */
    12080. 

  12080. #ifdef MNG_DECREMENT_LOOPS
    12081. 

  12081.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12082. 

  12082. #else
    12083. 

  12083.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12084. 

  12084. #endif
    12085. 

  12085.     {
    12086. 

  12086.       if (!iM)                         /* mask underflow ? */
    12087. 

  12087.       {
    12088. 

  12088.         iB = *pWorkrow;                /* get next input-byte */
    12089. 

  12089.         pWorkrow++;
    12090. 

  12090.         iM = 0x80;
    12091. 

  12091.       }
    12092. 

  12092. 

  12093.       if (iB & iM)                     /* invert if it is non-zero index */
    12094. 

  12094.         *pOutrow = (mng_uint8)(*pOutrow ^ 0x01);
    12095. 

  12095. 

  12096.       pOutrow += pData->iColinc;       /* next pixel */
    12097. 

  12097.       iM >>=  1;
    12098. 

  12098.     }
    12099. 

  12099.   }
    12100. 

  12100. 

  12101. #ifdef MNG_SUPPORT_TRACE
    12102. 

  12102.   MNG_TRACE (pData, MNG_FN_DELTA_IDX1, MNG_LC_END);
    12103. 

  12103. #endif
    12104. 

  12104. 

  12105.   return mng_store_idx1 (pData);
    12106. 

  12106. }
    12107. 

  12107. 

  12108. /* ************************************************************************** */
    12109. 

  12109. 

  12110. mng_retcode mng_delta_idx2 (mng_datap pData)
    12111. 

  12111. {
    12112. 

  12112.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12113. 

  12113.   mng_uint8p     pWorkrow;
    12114. 

  12114.   mng_uint8p     pOutrow;
    12115. 

  12115.   mng_int32      iX;
    12116. 

  12116.   mng_uint8      iB;
    12117. 

  12117.   mng_uint8      iM;
    12118. 

  12118.   mng_uint32     iS;
    12119. 

  12119. 

  12120. #ifdef MNG_SUPPORT_TRACE
    12121. 

  12121.   MNG_TRACE (pData, MNG_FN_DELTA_IDX2, MNG_LC_START);
    12122. 

  12122. #endif
    12123. 

  12123.                                        /* temporary work pointers */
    12124. 

  12124.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12125. 

  12125.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12126. 

  12126.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12127. 

  12127.                               (pData->iCol         * pBuf->iSamplesize) +
    12128. 

  12128.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12129. 

  12129.   iM       = 0;                        /* start at pixel 0 */
    12130. 

  12130.   iB       = 0;
    12131. 

  12131.   iS       = 0;
    12132. 

  12132.                                        /* pixel replace ? */
    12133. 

  12133.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12134. 

  12134.   {
    12135. 

  12135. #ifdef MNG_DECREMENT_LOOPS
    12136. 

  12136.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12137. 

  12137. #else
    12138. 

  12138.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12139. 

  12139. #endif
    12140. 

  12140.     {
    12141. 

  12141.       if (!iM)                         /* mask underflow ? */
    12142. 

  12142.       {
    12143. 

  12143.         iB = *pWorkrow;                /* get next input-byte */
    12144. 

  12144.         pWorkrow++;
    12145. 

  12145.         iM = 0xC0;
    12146. 

  12146.         iS = 6;
    12147. 

  12147.       }
    12148. 

  12148.                                        /* put the index */
    12149. 

  12149.       *pOutrow = (mng_uint8)((iB & iM) >> iS);
    12150. 

  12150. 

  12151.       pOutrow += pData->iColinc;       /* next pixel */
    12152. 

  12152.       iM >>=  2;
    12153. 

  12153.       iS -= 2;
    12154. 

  12154.     }
    12155. 

  12155.   }
    12156. 

  12156.   else
    12157. 

  12157.   {                                    /* pixel add ! */
    12158. 

  12158. #ifdef MNG_DECREMENT_LOOPS
    12159. 

  12159.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12160. 

  12160. #else
    12161. 

  12161.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12162. 

  12162. #endif
    12163. 

  12163.     {
    12164. 

  12164.       if (!iM)                         /* mask underflow ? */
    12165. 

  12165.       {
    12166. 

  12166.         iB = *pWorkrow;                /* get next input-byte */
    12167. 

  12167.         pWorkrow++;
    12168. 

  12168.         iM = 0xC0;
    12169. 

  12169.         iS = 6;
    12170. 

  12170.       }
    12171. 

  12171.                                        /* calculate the index */
    12172. 

  12172.       *pOutrow = (mng_uint8)((*pOutrow + ((iB & iM) >> iS)) & 0x03);
    12173. 

  12173. 

  12174.       pOutrow += pData->iColinc;       /* next pixel */
    12175. 

  12175.       iM >>=  2;
    12176. 

  12176.       iS -= 2;
    12177. 

  12177.     }
    12178. 

  12178.   }
    12179. 

  12179. 

  12180. #ifdef MNG_SUPPORT_TRACE
    12181. 

  12181.   MNG_TRACE (pData, MNG_FN_DELTA_IDX2, MNG_LC_END);
    12182. 

  12182. #endif
    12183. 

  12183. 

  12184.   return mng_store_idx2 (pData);
    12185. 

  12185. }
    12186. 

  12186. 

  12187. /* ************************************************************************** */
    12188. 

  12188. 

  12189. mng_retcode mng_delta_idx4 (mng_datap pData)
    12190. 

  12190. {
    12191. 

  12191.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12192. 

  12192.   mng_uint8p     pWorkrow;
    12193. 

  12193.   mng_uint8p     pOutrow;
    12194. 

  12194.   mng_int32      iX;
    12195. 

  12195.   mng_uint8      iB;
    12196. 

  12196.   mng_uint8      iM;
    12197. 

  12197.   mng_uint32     iS;
    12198. 

  12198. 

  12199. #ifdef MNG_SUPPORT_TRACE
    12200. 

  12200.   MNG_TRACE (pData, MNG_FN_DELTA_IDX4, MNG_LC_START);
    12201. 

  12201. #endif
    12202. 

  12202.                                        /* temporary work pointers */
    12203. 

  12203.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12204. 

  12204.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12205. 

  12205.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12206. 

  12206.                               (pData->iCol         * pBuf->iSamplesize) +
    12207. 

  12207.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12208. 

  12208.   iM       = 0;                        /* start at pixel 0 */
    12209. 

  12209.   iB       = 0;
    12210. 

  12210.   iS       = 0;
    12211. 

  12211.                                        /* pixel replace ? */
    12212. 

  12212.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12213. 

  12213.   {
    12214. 

  12214. #ifdef MNG_DECREMENT_LOOPS
    12215. 

  12215.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12216. 

  12216. #else
    12217. 

  12217.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12218. 

  12218. #endif
    12219. 

  12219.     {
    12220. 

  12220.       if (!iM)                         /* mask underflow ? */
    12221. 

  12221.       {
    12222. 

  12222.         iB = *pWorkrow;                /* get next input-byte */
    12223. 

  12223.         pWorkrow++;
    12224. 

  12224.         iM = 0xF0;
    12225. 

  12225.         iS = 4;
    12226. 

  12226.       }
    12227. 

  12227.                                        /* put the index */
    12228. 

  12228.       *pOutrow = (mng_uint8)((iB & iM) >> iS);
    12229. 

  12229. 

  12230.       pOutrow += pData->iColinc;       /* next pixel */
    12231. 

  12231.       iM >>=  4;
    12232. 

  12232.       iS -= 4;
    12233. 

  12233.     }
    12234. 

  12234.   }
    12235. 

  12235.   else
    12236. 

  12236.   {                                    /* pixel add ! */
    12237. 

  12237. #ifdef MNG_DECREMENT_LOOPS
    12238. 

  12238.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12239. 

  12239. #else
    12240. 

  12240.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12241. 

  12241. #endif
    12242. 

  12242.     {
    12243. 

  12243.       if (!iM)                         /* mask underflow ? */
    12244. 

  12244.       {
    12245. 

  12245.         iB = *pWorkrow;                /* get next input-byte */
    12246. 

  12246.         pWorkrow++;
    12247. 

  12247.         iM = 0xF0;
    12248. 

  12248.         iS = 4;
    12249. 

  12249.       }
    12250. 

  12250.                                        /* calculate the index */
    12251. 

  12251.       *pOutrow = (mng_uint8)((*pOutrow + ((iB & iM) >> iS)) & 0x0F);
    12252. 

  12252. 

  12253.       pOutrow += pData->iColinc;       /* next pixel */
    12254. 

  12254.       iM >>=  4;
    12255. 

  12255.       iS -= 4;
    12256. 

  12256.     }
    12257. 

  12257.   }
    12258. 

  12258. 

  12259. #ifdef MNG_SUPPORT_TRACE
    12260. 

  12260.   MNG_TRACE (pData, MNG_FN_DELTA_IDX4, MNG_LC_END);
    12261. 

  12261. #endif
    12262. 

  12262. 

  12263.   return mng_store_idx4 (pData);
    12264. 

  12264. }
    12265. 

  12265. #endif
    12266. 

  12266. 

  12267. /* ************************************************************************** */
    12268. 

  12268. 

  12269. mng_retcode mng_delta_idx8 (mng_datap pData)
    12270. 

  12270. {
    12271. 

  12271.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12272. 

  12272.   mng_uint8p     pWorkrow;
    12273. 

  12273.   mng_uint8p     pOutrow;
    12274. 

  12274.   mng_int32      iX;
    12275. 

  12275. 

  12276. #ifdef MNG_SUPPORT_TRACE
    12277. 

  12277.   MNG_TRACE (pData, MNG_FN_DELTA_IDX8, MNG_LC_START);
    12278. 

  12278. #endif
    12279. 

  12279.                                        /* temporary work pointers */
    12280. 

  12280.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12281. 

  12281.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12282. 

  12282.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12283. 

  12283.                               (pData->iCol         * pBuf->iSamplesize) +
    12284. 

  12284.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12285. 

  12285.                                        /* pixel replace ? */
    12286. 

  12286.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12287. 

  12287.   {
    12288. 

  12288. #ifdef MNG_DECREMENT_LOOPS
    12289. 

  12289.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12290. 

  12290. #else
    12291. 

  12291.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12292. 

  12292. #endif
    12293. 

  12293.     {
    12294. 

  12294.       *pOutrow = *pWorkrow;            /* put in object buffer */
    12295. 

  12295. 

  12296.       pOutrow += pData->iColinc;       /* next pixel */
    12297. 

  12297.       pWorkrow++;
    12298. 

  12298.     }
    12299. 

  12299.   }
    12300. 

  12300.   else
    12301. 

  12301.   {                                    /* pixel add ! */
    12302. 

  12302. #ifdef MNG_DECREMENT_LOOPS
    12303. 

  12303.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12304. 

  12304. #else
    12305. 

  12305.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12306. 

  12306. #endif
    12307. 

  12307.     {                                  /* add to object buffer */
    12308. 

  12308.       *pOutrow = (mng_uint8)(*pOutrow + *pWorkrow);
    12309. 

  12309. 

  12310.       pOutrow += pData->iColinc;       /* next pixel */
    12311. 

  12311.       pWorkrow++;
    12312. 

  12312.     }
    12313. 

  12313.   }
    12314. 

  12314. 

  12315. #ifdef MNG_SUPPORT_TRACE
    12316. 

  12316.   MNG_TRACE (pData, MNG_FN_DELTA_IDX8, MNG_LC_END);
    12317. 

  12317. #endif
    12318. 

  12318. 

  12319.   return mng_store_idx8 (pData);
    12320. 

  12320. }
    12321. 

  12321. 

  12322. /* ************************************************************************** */
    12323. 

  12323. 

  12324. mng_retcode mng_delta_ga8 (mng_datap pData)
    12325. 

  12325. {
    12326. 

  12326.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12327. 

  12327.   mng_uint8p     pWorkrow;
    12328. 

  12328.   mng_uint8p     pOutrow;
    12329. 

  12329.   mng_int32      iX;
    12330. 

  12330. 

  12331. #ifdef MNG_SUPPORT_TRACE
    12332. 

  12332.   MNG_TRACE (pData, MNG_FN_DELTA_GA8, MNG_LC_START);
    12333. 

  12333. #endif
    12334. 

  12334.                                        /* temporary work pointers */
    12335. 

  12335.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12336. 

  12336.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12337. 

  12337.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12338. 

  12338.                               (pData->iCol         * pBuf->iSamplesize) +
    12339. 

  12339.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12340. 

  12340.                                        /* pixel replace ? */
    12341. 

  12341.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12342. 

  12342.   {
    12343. 

  12343. #ifdef MNG_DECREMENT_LOOPS
    12344. 

  12344.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12345. 

  12345. #else
    12346. 

  12346.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12347. 

  12347. #endif
    12348. 

  12348.     {
    12349. 

  12349.       *pOutrow     = *pWorkrow;        /* put in object buffer */
    12350. 

  12350.       *(pOutrow+1) = *(pWorkrow+1);
    12351. 

  12351.                                        /* next pixel */
    12352. 

  12352.       pOutrow  += (pData->iColinc << 1);
    12353. 

  12353.       pWorkrow += 2;
    12354. 

  12354.     }
    12355. 

  12355.   }
    12356. 

  12356.   else
    12357. 

  12357.   {                                    /* pixel add ! */
    12358. 

  12358. #ifdef MNG_DECREMENT_LOOPS
    12359. 

  12359.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12360. 

  12360. #else
    12361. 

  12361.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12362. 

  12362. #endif
    12363. 

  12363.     {                                  /* add to object buffer */
    12364. 

  12364.       *pOutrow     = (mng_uint8)(*pOutrow     + *pWorkrow    );
    12365. 

  12365.       *(pOutrow+1) = (mng_uint8)(*(pOutrow+1) + *(pWorkrow+1));
    12366. 

  12366.                                        /* next pixel */
    12367. 

  12367.       pOutrow  += (pData->iColinc << 1);
    12368. 

  12368.       pWorkrow += 2;
    12369. 

  12369.     }
    12370. 

  12370.   }
    12371. 

  12371. 

  12372. #ifdef MNG_SUPPORT_TRACE
    12373. 

  12373.   MNG_TRACE (pData, MNG_FN_DELTA_GA8, MNG_LC_END);
    12374. 

  12374. #endif
    12375. 

  12375. 

  12376.   return mng_store_ga8 (pData);
    12377. 

  12377. }
    12378. 

  12378. 

  12379. /* ************************************************************************** */
    12380. 

  12380. 

  12381. #ifndef MNG_NO_16BIT_SUPPORT
    12382. 

  12382. mng_retcode mng_delta_ga16 (mng_datap pData)
    12383. 

  12383. {
    12384. 

  12384.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12385. 

  12385.   mng_uint8p     pWorkrow;
    12386. 

  12386.   mng_uint8p     pOutrow;
    12387. 

  12387.   mng_int32      iX;
    12388. 

  12388. 

  12389. #ifdef MNG_SUPPORT_TRACE
    12390. 

  12390.   MNG_TRACE (pData, MNG_FN_DELTA_GA16, MNG_LC_START);
    12391. 

  12391. #endif
    12392. 

  12392.                                        /* temporary work pointers */
    12393. 

  12393.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12394. 

  12394.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12395. 

  12395.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12396. 

  12396.                               (pData->iCol         * pBuf->iSamplesize) +
    12397. 

  12397.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12398. 

  12398.                                        /* pixel replace ? */
    12399. 

  12399.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12400. 

  12400.   {
    12401. 

  12401. #ifdef MNG_DECREMENT_LOOPS
    12402. 

  12402.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12403. 

  12403. #else
    12404. 

  12404.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12405. 

  12405. #endif
    12406. 

  12406.     {
    12407. 

  12407.       *pOutrow     = *pWorkrow;        /* put in object buffer */
    12408. 

  12408.       *(pOutrow+1) = *(pWorkrow+1);
    12409. 

  12409.       *(pOutrow+2) = *(pWorkrow+2);
    12410. 

  12410.       *(pOutrow+3) = *(pWorkrow+3);
    12411. 

  12411.                                        /* next pixel */
    12412. 

  12412.       pOutrow  += (pData->iColinc << 2);
    12413. 

  12413.       pWorkrow += 4;
    12414. 

  12414.     }
    12415. 

  12415.   }
    12416. 

  12416.   else
    12417. 

  12417.   {                                    /* pixel add ! */
    12418. 

  12418. #ifdef MNG_DECREMENT_LOOPS
    12419. 

  12419.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12420. 

  12420. #else
    12421. 

  12421.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12422. 

  12422. #endif
    12423. 

  12423.     {                                  /* add to object buffer */
    12424. 

  12424.       mng_put_uint16 (pOutrow,   (mng_uint16)(mng_get_uint16 (pOutrow   ) +
    12425. 

  12425.                                               mng_get_uint16 (pWorkrow  )   ));
    12426. 

  12426.       mng_put_uint16 (pOutrow+2, (mng_uint16)(mng_get_uint16 (pOutrow+2 ) +
    12427. 

  12427.                                               mng_get_uint16 (pWorkrow+2)   ));
    12428. 

  12428.                                        /* next pixel */
    12429. 

  12429.       pOutrow  += (pData->iColinc << 2);
    12430. 

  12430.       pWorkrow += 4;
    12431. 

  12431.     }
    12432. 

  12432.   }
    12433. 

  12433. 

  12434. #ifdef MNG_SUPPORT_TRACE
    12435. 

  12435.   MNG_TRACE (pData, MNG_FN_DELTA_GA16, MNG_LC_END);
    12436. 

  12436. #endif
    12437. 

  12437. 

  12438.   return mng_store_ga16 (pData);
    12439. 

  12439. }
    12440. 

  12440. #endif
    12441. 

  12441. 

  12442. /* ************************************************************************** */
    12443. 

  12443. 

  12444. mng_retcode mng_delta_rgba8 (mng_datap pData)
    12445. 

  12445. {
    12446. 

  12446.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12447. 

  12447.   mng_uint8p     pWorkrow;
    12448. 

  12448.   mng_uint8p     pOutrow;
    12449. 

  12449.   mng_int32      iX;
    12450. 

  12450. 

  12451. #ifdef MNG_SUPPORT_TRACE
    12452. 

  12452.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8, MNG_LC_START);
    12453. 

  12453. #endif
    12454. 

  12454.                                        /* temporary work pointers */
    12455. 

  12455.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12456. 

  12456.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12457. 

  12457.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12458. 

  12458.                               (pData->iCol         * pBuf->iSamplesize) +
    12459. 

  12459.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12460. 

  12460.                                        /* pixel replace ? */
    12461. 

  12461.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12462. 

  12462.   {
    12463. 

  12463. #ifdef MNG_DECREMENT_LOOPS
    12464. 

  12464.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12465. 

  12465. #else
    12466. 

  12466.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12467. 

  12467. #endif
    12468. 

  12468.     {
    12469. 

  12469.       *pOutrow     = *pWorkrow;        /* put in object buffer */
    12470. 

  12470.       *(pOutrow+1) = *(pWorkrow+1);
    12471. 

  12471.       *(pOutrow+2) = *(pWorkrow+2);
    12472. 

  12472.       *(pOutrow+3) = *(pWorkrow+3);
    12473. 

  12473.                                        /* next pixel */
    12474. 

  12474.       pOutrow  += (pData->iColinc << 2);
    12475. 

  12475.       pWorkrow += 4;
    12476. 

  12476.     }
    12477. 

  12477.   }
    12478. 

  12478.   else
    12479. 

  12479.   {                                    /* pixel add ! */
    12480. 

  12480. #ifdef MNG_DECREMENT_LOOPS
    12481. 

  12481.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12482. 

  12482. #else
    12483. 

  12483.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12484. 

  12484. #endif
    12485. 

  12485.     {                                  /* add to object buffer */
    12486. 

  12486.       *pOutrow     = (mng_uint8)(*pOutrow     + *pWorkrow    );
    12487. 

  12487.       *(pOutrow+1) = (mng_uint8)(*(pOutrow+1) + *(pWorkrow+1));
    12488. 

  12488.       *(pOutrow+2) = (mng_uint8)(*(pOutrow+2) + *(pWorkrow+2));
    12489. 

  12489.       *(pOutrow+3) = (mng_uint8)(*(pOutrow+3) + *(pWorkrow+3));
    12490. 

  12490.                                        /* next pixel */
    12491. 

  12491.       pOutrow  += (pData->iColinc << 2);
    12492. 

  12492.       pWorkrow += 4;
    12493. 

  12493.     }
    12494. 

  12494.   }
    12495. 

  12495. 

  12496. #ifdef MNG_SUPPORT_TRACE
    12497. 

  12497.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8, MNG_LC_END);
    12498. 

  12498. #endif
    12499. 

  12499. 

  12500.   return mng_store_rgba8 (pData);
    12501. 

  12501. }
    12502. 

  12502. 

  12503. /* ************************************************************************** */
    12504. 

  12504. 

  12505. #ifndef MNG_NO_16BIT_SUPPORT
    12506. 

  12506. mng_retcode mng_delta_rgba16 (mng_datap pData)
    12507. 

  12507. {
    12508. 

  12508.   mng_imagedatap pBuf = ((mng_imagep)pData->pDeltaImage)->pImgbuf;
    12509. 

  12509.   mng_uint8p     pWorkrow;
    12510. 

  12510.   mng_uint8p     pOutrow;
    12511. 

  12511.   mng_int32      iX;
    12512. 

  12512. 

  12513. #ifdef MNG_SUPPORT_TRACE
    12514. 

  12514.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16, MNG_LC_START);
    12515. 

  12515. #endif
    12516. 

  12516.                                        /* temporary work pointers */
    12517. 

  12517.   pWorkrow = pData->pWorkrow + pData->iPixelofs;
    12518. 

  12518.   pOutrow  = pBuf->pImgdata + (pData->iRow         * pBuf->iRowsize   ) +
    12519. 

  12519.                               (pData->iDeltaBlocky * pBuf->iRowsize   ) +
    12520. 

  12520.                               (pData->iCol         * pBuf->iSamplesize) +
    12521. 

  12521.                               (pData->iDeltaBlockx * pBuf->iSamplesize);
    12522. 

  12522.                                        /* pixel replace ? */
    12523. 

  12523.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)
    12524. 

  12524.   {
    12525. 

  12525. #ifdef MNG_DECREMENT_LOOPS
    12526. 

  12526.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12527. 

  12527. #else
    12528. 

  12528.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12529. 

  12529. #endif
    12530. 

  12530.     {
    12531. 

  12531.       MNG_COPY (pOutrow, pWorkrow, 8); /* put in object buffer */
    12532. 

  12532.                                        /* next pixel */
    12533. 

  12533.       pOutrow  += (pData->iColinc << 3);
    12534. 

  12534.       pWorkrow += 8;
    12535. 

  12535.     }
    12536. 

  12536.   }
    12537. 

  12537.   else
    12538. 

  12538.   {                                    /* pixel add ! */
    12539. 

  12539. #ifdef MNG_DECREMENT_LOOPS
    12540. 

  12540.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12541. 

  12541. #else
    12542. 

  12542.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12543. 

  12543. #endif
    12544. 

  12544.     {                                  /* add to object buffer */
    12545. 

  12545.       mng_put_uint16 (pOutrow,   (mng_uint16)(mng_get_uint16 (pOutrow   ) +
    12546. 

  12546.                                               mng_get_uint16 (pWorkrow  )   ));
    12547. 

  12547.       mng_put_uint16 (pOutrow+2, (mng_uint16)(mng_get_uint16 (pOutrow+2 ) +
    12548. 

  12548.                                               mng_get_uint16 (pWorkrow+2)   ));
    12549. 

  12549.       mng_put_uint16 (pOutrow+4, (mng_uint16)(mng_get_uint16 (pOutrow+4 ) +
    12550. 

  12550.                                               mng_get_uint16 (pWorkrow+4)   ));
    12551. 

  12551.       mng_put_uint16 (pOutrow+6, (mng_uint16)(mng_get_uint16 (pOutrow+6 ) +
    12552. 

  12552.                                               mng_get_uint16 (pWorkrow+6)   ));
    12553. 

  12553.                                        /* next pixel */
    12554. 

  12554.       pOutrow  += (pData->iColinc << 3);
    12555. 

  12555.       pWorkrow += 8;
    12556. 

  12556.     }
    12557. 

  12557.   }
    12558. 

  12558. 

  12559. #ifdef MNG_SUPPORT_TRACE
    12560. 

  12560.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16, MNG_LC_END);
    12561. 

  12561. #endif
    12562. 

  12562. 

  12563.   return mng_store_rgba16 (pData);
    12564. 

  12564. }
    12565. 

  12565. #endif
    12566. 

  12566. 

  12567. /* ************************************************************************** */
    12568. 

  12568. /* *                                                                        * */
    12569. 

  12569. /* * Delta-image row routines - apply the source row onto the target        * */
    12570. 

  12570. /* *                                                                        * */
    12571. 

  12571. /* ************************************************************************** */
    12572. 

  12572. 

  12573. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    12574. 

  12574. mng_retcode mng_delta_g1_g1 (mng_datap pData)
    12575. 

  12575. {
    12576. 

  12576.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12577. 

  12577.   mng_uint8p     pWorkrow;
    12578. 

  12578.   mng_uint8p     pOutrow;
    12579. 

  12579.   mng_int32      iX;
    12580. 

  12580. 

  12581. #ifdef MNG_SUPPORT_TRACE
    12582. 

  12582.   MNG_TRACE (pData, MNG_FN_DELTA_G1_G1, MNG_LC_START);
    12583. 

  12583. #endif
    12584. 

  12584. 

  12585.   pWorkrow = pData->pRGBArow;
    12586. 

  12586.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12587. 

  12587.                               (pData->iCol * pBuf->iSamplesize);
    12588. 

  12588. 

  12589.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12590. 

  12590.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12591. 

  12591.   {
    12592. 

  12592.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples);
    12593. 

  12593.   }
    12594. 

  12594.   else
    12595. 

  12595.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12596. 

  12596.   {
    12597. 

  12597. #ifdef MNG_DECREMENT_LOOPS
    12598. 

  12598.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12599. 

  12599. #else
    12600. 

  12600.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12601. 

  12601. #endif
    12602. 

  12602.     {
    12603. 

  12603.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12604. 

  12604.                               (mng_uint16)*pWorkrow) & 0x01);
    12605. 

  12605. 

  12606.       pOutrow++;
    12607. 

  12607.       pWorkrow++;
    12608. 

  12608.     }
    12609. 

  12609.   }
    12610. 

  12610. 

  12611. #ifdef MNG_SUPPORT_TRACE
    12612. 

  12612.   MNG_TRACE (pData, MNG_FN_DELTA_G1_G1, MNG_LC_END);
    12613. 

  12613. #endif
    12614. 

  12614. 

  12615.   return MNG_NOERROR;
    12616. 

  12616. }
    12617. 

  12617. 

  12618. /* ************************************************************************** */
    12619. 

  12619. 

  12620. mng_retcode mng_delta_g2_g2 (mng_datap pData)
    12621. 

  12621. {
    12622. 

  12622.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12623. 

  12623.   mng_uint8p     pWorkrow;
    12624. 

  12624.   mng_uint8p     pOutrow;
    12625. 

  12625.   mng_int32      iX;
    12626. 

  12626. 

  12627. #ifdef MNG_SUPPORT_TRACE
    12628. 

  12628.   MNG_TRACE (pData, MNG_FN_DELTA_G2_G2, MNG_LC_START);
    12629. 

  12629. #endif
    12630. 

  12630. 

  12631.   pWorkrow = pData->pRGBArow;
    12632. 

  12632.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12633. 

  12633.                               (pData->iCol * pBuf->iSamplesize);
    12634. 

  12634. 

  12635.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12636. 

  12636.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12637. 

  12637.   {
    12638. 

  12638.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples);
    12639. 

  12639.   }
    12640. 

  12640.   else
    12641. 

  12641.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12642. 

  12642.   {
    12643. 

  12643. #ifdef MNG_DECREMENT_LOOPS
    12644. 

  12644.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12645. 

  12645. #else
    12646. 

  12646.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12647. 

  12647. #endif
    12648. 

  12648.     {
    12649. 

  12649.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12650. 

  12650.                               (mng_uint16)*pWorkrow) & 0x03);
    12651. 

  12651. 

  12652.       pOutrow++;
    12653. 

  12653.       pWorkrow++;
    12654. 

  12654.     }
    12655. 

  12655.   }
    12656. 

  12656. 

  12657. #ifdef MNG_SUPPORT_TRACE
    12658. 

  12658.   MNG_TRACE (pData, MNG_FN_DELTA_G2_G2, MNG_LC_END);
    12659. 

  12659. #endif
    12660. 

  12660. 

  12661.   return MNG_NOERROR;
    12662. 

  12662. }
    12663. 

  12663. 

  12664. /* ************************************************************************** */
    12665. 

  12665. 

  12666. mng_retcode mng_delta_g4_g4 (mng_datap pData)
    12667. 

  12667. {
    12668. 

  12668.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12669. 

  12669.   mng_uint8p     pWorkrow;
    12670. 

  12670.   mng_uint8p     pOutrow;
    12671. 

  12671.   mng_int32      iX;
    12672. 

  12672. 

  12673. #ifdef MNG_SUPPORT_TRACE
    12674. 

  12674.   MNG_TRACE (pData, MNG_FN_DELTA_G4_G4, MNG_LC_START);
    12675. 

  12675. #endif
    12676. 

  12676. 

  12677.   pWorkrow = pData->pRGBArow;
    12678. 

  12678.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12679. 

  12679.                               (pData->iCol * pBuf->iSamplesize);
    12680. 

  12680. 

  12681.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12682. 

  12682.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12683. 

  12683.   {
    12684. 

  12684.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples);
    12685. 

  12685.   }
    12686. 

  12686.   else
    12687. 

  12687.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12688. 

  12688.   {
    12689. 

  12689. #ifdef MNG_DECREMENT_LOOPS
    12690. 

  12690.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12691. 

  12691. #else
    12692. 

  12692.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12693. 

  12693. #endif
    12694. 

  12694.     {
    12695. 

  12695.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12696. 

  12696.                               (mng_uint16)*pWorkrow) & 0x0F);
    12697. 

  12697. 

  12698.       pOutrow++;
    12699. 

  12699.       pWorkrow++;
    12700. 

  12700.     }
    12701. 

  12701.   }
    12702. 

  12702. 

  12703. #ifdef MNG_SUPPORT_TRACE
    12704. 

  12704.   MNG_TRACE (pData, MNG_FN_DELTA_G4_G4, MNG_LC_END);
    12705. 

  12705. #endif
    12706. 

  12706. 

  12707.   return MNG_NOERROR;
    12708. 

  12708. }
    12709. 

  12709. #endif
    12710. 

  12710. 

  12711. /* ************************************************************************** */
    12712. 

  12712. 

  12713. mng_retcode mng_delta_g8_g8 (mng_datap pData)
    12714. 

  12714. {
    12715. 

  12715.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12716. 

  12716.   mng_uint8p     pWorkrow;
    12717. 

  12717.   mng_uint8p     pOutrow;
    12718. 

  12718.   mng_int32      iX;
    12719. 

  12719. 

  12720. #ifdef MNG_SUPPORT_TRACE
    12721. 

  12721.   MNG_TRACE (pData, MNG_FN_DELTA_G8_G8, MNG_LC_START);
    12722. 

  12722. #endif
    12723. 

  12723. 

  12724.   pWorkrow = pData->pRGBArow;
    12725. 

  12725.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12726. 

  12726.                               (pData->iCol * pBuf->iSamplesize);
    12727. 

  12727. 

  12728.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12729. 

  12729.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12730. 

  12730.   {
    12731. 

  12731.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples);
    12732. 

  12732.   }
    12733. 

  12733.   else
    12734. 

  12734.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12735. 

  12735.   {
    12736. 

  12736. #ifdef MNG_DECREMENT_LOOPS
    12737. 

  12737.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12738. 

  12738. #else
    12739. 

  12739.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12740. 

  12740. #endif
    12741. 

  12741.     {
    12742. 

  12742.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12743. 

  12743.                               (mng_uint16)*pWorkrow) & 0xFF);
    12744. 

  12744. 

  12745.       pOutrow++;
    12746. 

  12746.       pWorkrow++;
    12747. 

  12747.     }
    12748. 

  12748.   }
    12749. 

  12749. 

  12750. #ifdef MNG_SUPPORT_TRACE
    12751. 

  12751.   MNG_TRACE (pData, MNG_FN_DELTA_G8_G8, MNG_LC_END);
    12752. 

  12752. #endif
    12753. 

  12753. 

  12754.   return MNG_NOERROR;
    12755. 

  12755. }
    12756. 

  12756. 

  12757. /* ************************************************************************** */
    12758. 

  12758. 

  12759. #ifndef MNG_NO_16BIT_SUPPORT
    12760. 

  12760. mng_retcode mng_delta_g16_g16 (mng_datap pData)
    12761. 

  12761. {
    12762. 

  12762.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12763. 

  12763.   mng_uint8p     pWorkrow;
    12764. 

  12764.   mng_uint8p     pOutrow;
    12765. 

  12765.   mng_int32      iX;
    12766. 

  12766. 

  12767. #ifdef MNG_SUPPORT_TRACE
    12768. 

  12768.   MNG_TRACE (pData, MNG_FN_DELTA_G16_G16, MNG_LC_START);
    12769. 

  12769. #endif
    12770. 

  12770. 

  12771.   pWorkrow = pData->pRGBArow;
    12772. 

  12772.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12773. 

  12773.                               (pData->iCol * pBuf->iSamplesize);
    12774. 

  12774. 

  12775.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12776. 

  12776.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12777. 

  12777.   {
    12778. 

  12778.     MNG_COPY (pOutrow, pWorkrow, (pData->iRowsamples << 1));
    12779. 

  12779.   }
    12780. 

  12780.   else
    12781. 

  12781.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12782. 

  12782.   {
    12783. 

  12783. #ifdef MNG_DECREMENT_LOOPS
    12784. 

  12784.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12785. 

  12785. #else
    12786. 

  12786.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12787. 

  12787. #endif
    12788. 

  12788.     {
    12789. 

  12789.       mng_put_uint16 (pOutrow, (mng_uint16)((mng_get_uint16 (pOutrow) +
    12790. 

  12790.                                              mng_get_uint16 (pWorkrow)) & 0xFFFF));
    12791. 

  12791. 

  12792.       pOutrow  += 2;
    12793. 

  12793.       pWorkrow += 2;
    12794. 

  12794.     }
    12795. 

  12795.   }
    12796. 

  12796. 

  12797. #ifdef MNG_SUPPORT_TRACE
    12798. 

  12798.   MNG_TRACE (pData, MNG_FN_DELTA_G16_G16, MNG_LC_END);
    12799. 

  12799. #endif
    12800. 

  12800. 

  12801.   return MNG_NOERROR;
    12802. 

  12802. }
    12803. 

  12803. #endif
    12804. 

  12804. #endif /* MNG_NO_DELTA_PNG */
    12805. 

  12805. 

  12806. /* ************************************************************************** */
    12807. 

  12807. 

  12808. mng_retcode mng_delta_rgb8_rgb8 (mng_datap pData)
    12809. 

  12809. {
    12810. 

  12810.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12811. 

  12811.   mng_uint8p     pWorkrow;
    12812. 

  12812.   mng_uint8p     pOutrow;
    12813. 

  12813.   mng_int32      iX;
    12814. 

  12814. 

  12815. #ifdef MNG_SUPPORT_TRACE
    12816. 

  12816.   MNG_TRACE (pData, MNG_FN_DELTA_RGB8_RGB8, MNG_LC_START);
    12817. 

  12817. #endif
    12818. 

  12818. 

  12819.   pWorkrow = pData->pRGBArow;
    12820. 

  12820.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12821. 

  12821.                               (pData->iCol * pBuf->iSamplesize);
    12822. 

  12822. 

  12823.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12824. 

  12824.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12825. 

  12825.   {
    12826. 

  12826.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples * 3);
    12827. 

  12827.   }
    12828. 

  12828.   else
    12829. 

  12829.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12830. 

  12830.   {
    12831. 

  12831. #ifdef MNG_DECREMENT_LOOPS
    12832. 

  12832.     for (iX = pData->iRowsamples*3; iX > 0; iX--)
    12833. 

  12833. #else
    12834. 

  12834.     for (iX = 0; iX < (pData->iRowsamples * 3); iX++)
    12835. 

  12835. #endif
    12836. 

  12836.     {
    12837. 

  12837.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12838. 

  12838.                               (mng_uint16)*pWorkrow) & 0xFF);
    12839. 

  12839. 

  12840.       pOutrow++;
    12841. 

  12841.       pWorkrow++;
    12842. 

  12842.     }
    12843. 

  12843.   }
    12844. 

  12844. 

  12845. #ifdef MNG_SUPPORT_TRACE
    12846. 

  12846.   MNG_TRACE (pData, MNG_FN_DELTA_RGB8_RGB8, MNG_LC_END);
    12847. 

  12847. #endif
    12848. 

  12848. 

  12849.   return MNG_NOERROR;
    12850. 

  12850. }
    12851. 

  12851. 

  12852. /* ************************************************************************** */
    12853. 

  12853. 

  12854. #ifndef MNG_NO_16BIT_SUPPORT
    12855. 

  12855. mng_retcode mng_delta_rgb16_rgb16 (mng_datap pData)
    12856. 

  12856. {
    12857. 

  12857.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12858. 

  12858.   mng_uint8p     pWorkrow;
    12859. 

  12859.   mng_uint8p     pOutrow;
    12860. 

  12860.   mng_int32      iX;
    12861. 

  12861. 

  12862. #ifdef MNG_SUPPORT_TRACE
    12863. 

  12863.   MNG_TRACE (pData, MNG_FN_DELTA_RGB16_RGB16, MNG_LC_START);
    12864. 

  12864. #endif
    12865. 

  12865. 

  12866.   pWorkrow = pData->pRGBArow;
    12867. 

  12867.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12868. 

  12868.                               (pData->iCol * pBuf->iSamplesize);
    12869. 

  12869. 

  12870.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12871. 

  12871.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12872. 

  12872.   {
    12873. 

  12873.     MNG_COPY (pOutrow, pWorkrow, (pData->iRowsamples * 6));
    12874. 

  12874.   }
    12875. 

  12875.   else
    12876. 

  12876.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12877. 

  12877.   {
    12878. 

  12878. #ifdef MNG_DECREMENT_LOOPS
    12879. 

  12879.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12880. 

  12880. #else
    12881. 

  12881.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12882. 

  12882. #endif
    12883. 

  12883.     {
    12884. 

  12884.       mng_put_uint16 (pOutrow,   (mng_uint16)((mng_get_uint16 (pOutrow  ) +
    12885. 

  12885.                                                mng_get_uint16 (pWorkrow  )) & 0xFFFF));
    12886. 

  12886.       mng_put_uint16 (pOutrow+2, (mng_uint16)((mng_get_uint16 (pOutrow+2) +
    12887. 

  12887.                                                mng_get_uint16 (pWorkrow+2)) & 0xFFFF));
    12888. 

  12888.       mng_put_uint16 (pOutrow+4, (mng_uint16)((mng_get_uint16 (pOutrow+4) +
    12889. 

  12889.                                                mng_get_uint16 (pWorkrow+4)) & 0xFFFF));
    12890. 

  12890. 

  12891.       pOutrow  += 6;
    12892. 

  12892.       pWorkrow += 6;
    12893. 

  12893.     }
    12894. 

  12894.   }
    12895. 

  12895. 

  12896. #ifdef MNG_SUPPORT_TRACE
    12897. 

  12897.   MNG_TRACE (pData, MNG_FN_DELTA_RGB16_RGB16, MNG_LC_END);
    12898. 

  12898. #endif
    12899. 

  12899. 

  12900.   return MNG_NOERROR;
    12901. 

  12901. }
    12902. 

  12902. #endif
    12903. 

  12903. 

  12904. /* ************************************************************************** */
    12905. 

  12905. 

  12906. #ifndef MNG_NO_DELTA_PNG
    12907. 

  12907. mng_retcode mng_delta_ga8_ga8 (mng_datap pData)
    12908. 

  12908. {
    12909. 

  12909.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12910. 

  12910.   mng_uint8p     pWorkrow;
    12911. 

  12911.   mng_uint8p     pOutrow;
    12912. 

  12912.   mng_int32      iX;
    12913. 

  12913. 

  12914. #ifdef MNG_SUPPORT_TRACE
    12915. 

  12915.   MNG_TRACE (pData, MNG_FN_DELTA_GA8_GA8, MNG_LC_START);
    12916. 

  12916. #endif
    12917. 

  12917. 

  12918.   pWorkrow = pData->pRGBArow;
    12919. 

  12919.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12920. 

  12920.                               (pData->iCol * pBuf->iSamplesize);
    12921. 

  12921. 

  12922.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    12923. 

  12923.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    12924. 

  12924.   {
    12925. 

  12925.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples << 1);
    12926. 

  12926.   }
    12927. 

  12927.   else
    12928. 

  12928.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    12929. 

  12929.   {
    12930. 

  12930. #ifdef MNG_DECREMENT_LOOPS
    12931. 

  12931.     for (iX = (pData->iRowsamples<<1); iX > 0; iX--)
    12932. 

  12932. #else
    12933. 

  12933.     for (iX = 0; iX < (pData->iRowsamples << 1); iX++)
    12934. 

  12934. #endif
    12935. 

  12935.     {
    12936. 

  12936.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12937. 

  12937.                               (mng_uint16)*pWorkrow) & 0xFF);
    12938. 

  12938. 

  12939.       pOutrow++;
    12940. 

  12940.       pWorkrow++;
    12941. 

  12941.     }
    12942. 

  12942.   }
    12943. 

  12943. 

  12944. #ifdef MNG_SUPPORT_TRACE
    12945. 

  12945.   MNG_TRACE (pData, MNG_FN_DELTA_GA8_GA8, MNG_LC_END);
    12946. 

  12946. #endif
    12947. 

  12947. 

  12948.   return MNG_NOERROR;
    12949. 

  12949. }
    12950. 

  12950. 

  12951. /* ************************************************************************** */
    12952. 

  12952. 

  12953. mng_retcode mng_delta_ga8_g8 (mng_datap pData)
    12954. 

  12954. {
    12955. 

  12955.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    12956. 

  12956.   mng_uint8p     pWorkrow;
    12957. 

  12957.   mng_uint8p     pOutrow;
    12958. 

  12958.   mng_int32      iX;
    12959. 

  12959. 

  12960. #ifdef MNG_SUPPORT_TRACE
    12961. 

  12961.   MNG_TRACE (pData, MNG_FN_DELTA_GA8_G8, MNG_LC_START);
    12962. 

  12962. #endif
    12963. 

  12963. 

  12964.   pWorkrow = pData->pRGBArow;
    12965. 

  12965.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    12966. 

  12966.                               (pData->iCol * pBuf->iSamplesize);
    12967. 

  12967. 

  12968.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORREPLACE)
    12969. 

  12969.   {
    12970. 

  12970. #ifdef MNG_DECREMENT_LOOPS
    12971. 

  12971.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12972. 

  12972. #else
    12973. 

  12973.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12974. 

  12974. #endif
    12975. 

  12975.     {
    12976. 

  12976.       *pOutrow = *pWorkrow;
    12977. 

  12977. 

  12978.       pOutrow += 2;
    12979. 

  12979.       pWorkrow++;
    12980. 

  12980.     }
    12981. 

  12981.   }
    12982. 

  12982.   else
    12983. 

  12983.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORADD)
    12984. 

  12984.   {
    12985. 

  12985. #ifdef MNG_DECREMENT_LOOPS
    12986. 

  12986.     for (iX = pData->iRowsamples; iX > 0; iX--)
    12987. 

  12987. #else
    12988. 

  12988.     for (iX = 0; iX < pData->iRowsamples; iX++)
    12989. 

  12989. #endif
    12990. 

  12990.     {
    12991. 

  12991.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    12992. 

  12992.                               (mng_uint16)*pWorkrow) & 0xFF);
    12993. 

  12993. 

  12994.       pOutrow += 2;
    12995. 

  12995.       pWorkrow++;
    12996. 

  12996.     }
    12997. 

  12997.   }
    12998. 

  12998. 

  12999. #ifdef MNG_SUPPORT_TRACE
    13000. 

  13000.   MNG_TRACE (pData, MNG_FN_DELTA_GA8_G8, MNG_LC_END);
    13001. 

  13001. #endif
    13002. 

  13002. 

  13003.   return MNG_NOERROR;
    13004. 

  13004. }
    13005. 

  13005. 

  13006. /* ************************************************************************** */
    13007. 

  13007. 

  13008. mng_retcode mng_delta_ga8_a8 (mng_datap pData)
    13009. 

  13009. {
    13010. 

  13010.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13011. 

  13011.   mng_uint8p     pWorkrow;
    13012. 

  13012.   mng_uint8p     pOutrow;
    13013. 

  13013.   mng_int32      iX;
    13014. 

  13014. 

  13015. #ifdef MNG_SUPPORT_TRACE
    13016. 

  13016.   MNG_TRACE (pData, MNG_FN_DELTA_GA8_A8, MNG_LC_START);
    13017. 

  13017. #endif
    13018. 

  13018. 

  13019.   pWorkrow = pData->pRGBArow;
    13020. 

  13020.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13021. 

  13021.                               (pData->iCol * pBuf->iSamplesize) + 1;
    13022. 

  13022. 

  13023.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAREPLACE)
    13024. 

  13024.   {
    13025. 

  13025. #ifdef MNG_DECREMENT_LOOPS
    13026. 

  13026.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13027. 

  13027. #else
    13028. 

  13028.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13029. 

  13029. #endif
    13030. 

  13030.     {
    13031. 

  13031.       *pOutrow = *pWorkrow;
    13032. 

  13032. 

  13033.       pOutrow += 2;
    13034. 

  13034.       pWorkrow++;
    13035. 

  13035.     }
    13036. 

  13036.   }
    13037. 

  13037.   else
    13038. 

  13038.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAADD)
    13039. 

  13039.   {
    13040. 

  13040. #ifdef MNG_DECREMENT_LOOPS
    13041. 

  13041.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13042. 

  13042. #else
    13043. 

  13043.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13044. 

  13044. #endif
    13045. 

  13045.     {
    13046. 

  13046.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    13047. 

  13047.                               (mng_uint16)*pWorkrow) & 0xFF);
    13048. 

  13048. 

  13049.       pOutrow += 2;
    13050. 

  13050.       pWorkrow++;
    13051. 

  13051.     }
    13052. 

  13052.   }
    13053. 

  13053. 

  13054. #ifdef MNG_SUPPORT_TRACE
    13055. 

  13055.   MNG_TRACE (pData, MNG_FN_DELTA_GA8_A8, MNG_LC_END);
    13056. 

  13056. #endif
    13057. 

  13057. 

  13058.   return MNG_NOERROR;
    13059. 

  13059. }
    13060. 

  13060. 

  13061. /* ************************************************************************** */
    13062. 

  13062. 

  13063. #ifndef MNG_NO_16BIT_SUPPORT
    13064. 

  13064. mng_retcode mng_delta_ga16_ga16 (mng_datap pData)
    13065. 

  13065. {
    13066. 

  13066.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13067. 

  13067.   mng_uint8p     pWorkrow;
    13068. 

  13068.   mng_uint8p     pOutrow;
    13069. 

  13069.   mng_int32      iX;
    13070. 

  13070. 

  13071. #ifdef MNG_SUPPORT_TRACE
    13072. 

  13072.   MNG_TRACE (pData, MNG_FN_DELTA_GA16_GA16, MNG_LC_START);
    13073. 

  13073. #endif
    13074. 

  13074. 

  13075.   pWorkrow = pData->pRGBArow;
    13076. 

  13076.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13077. 

  13077.                               (pData->iCol * pBuf->iSamplesize);
    13078. 

  13078. 

  13079.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    13080. 

  13080.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    13081. 

  13081.   {
    13082. 

  13082.     MNG_COPY (pOutrow, pWorkrow, (pData->iRowsamples << 2));
    13083. 

  13083.   }
    13084. 

  13084.   else
    13085. 

  13085.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    13086. 

  13086.   {
    13087. 

  13087. #ifdef MNG_DECREMENT_LOOPS
    13088. 

  13088.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13089. 

  13089. #else
    13090. 

  13090.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13091. 

  13091. #endif
    13092. 

  13092.     {
    13093. 

  13093.       mng_put_uint16 (pOutrow,   (mng_uint16)((mng_get_uint16 (pOutrow  ) +
    13094. 

  13094.                                                mng_get_uint16 (pWorkrow  )) & 0xFFFF));
    13095. 

  13095.       mng_put_uint16 (pOutrow+2, (mng_uint16)((mng_get_uint16 (pOutrow+2) +
    13096. 

  13096.                                                mng_get_uint16 (pWorkrow+2)) & 0xFFFF));
    13097. 

  13097. 

  13098.       pOutrow  += 4;
    13099. 

  13099.       pWorkrow += 4;
    13100. 

  13100.     }
    13101. 

  13101.   }
    13102. 

  13102. 

  13103. #ifdef MNG_SUPPORT_TRACE
    13104. 

  13104.   MNG_TRACE (pData, MNG_FN_DELTA_GA16_GA16, MNG_LC_END);
    13105. 

  13105. #endif
    13106. 

  13106. 

  13107.   return MNG_NOERROR;
    13108. 

  13108. }
    13109. 

  13109. #endif
    13110. 

  13110. 

  13111. /* ************************************************************************** */
    13112. 

  13112. 

  13113. #ifndef MNG_NO_16BIT_SUPPORT
    13114. 

  13114. mng_retcode mng_delta_ga16_g16 (mng_datap pData)
    13115. 

  13115. {
    13116. 

  13116.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13117. 

  13117.   mng_uint8p     pWorkrow;
    13118. 

  13118.   mng_uint8p     pOutrow;
    13119. 

  13119.   mng_int32      iX;
    13120. 

  13120. 

  13121. #ifdef MNG_SUPPORT_TRACE
    13122. 

  13122.   MNG_TRACE (pData, MNG_FN_DELTA_GA16_G16, MNG_LC_START);
    13123. 

  13123. #endif
    13124. 

  13124. 

  13125.   pWorkrow = pData->pRGBArow;
    13126. 

  13126.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13127. 

  13127.                               (pData->iCol * pBuf->iSamplesize);
    13128. 

  13128. 

  13129.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORREPLACE)
    13130. 

  13130.   {
    13131. 

  13131. #ifdef MNG_DECREMENT_LOOPS
    13132. 

  13132.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13133. 

  13133. #else
    13134. 

  13134.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13135. 

  13135. #endif
    13136. 

  13136.     {
    13137. 

  13137.       mng_put_uint16 (pOutrow, mng_get_uint16 (pWorkrow));
    13138. 

  13138. 

  13139.       pOutrow  += 4;
    13140. 

  13140.       pWorkrow += 2;
    13141. 

  13141.     }
    13142. 

  13142.   }
    13143. 

  13143.   else
    13144. 

  13144.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORADD)
    13145. 

  13145.   {
    13146. 

  13146. #ifdef MNG_DECREMENT_LOOPS
    13147. 

  13147.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13148. 

  13148. #else
    13149. 

  13149.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13150. 

  13150. #endif
    13151. 

  13151.     {
    13152. 

  13152.       mng_put_uint16 (pOutrow, (mng_uint16)((mng_get_uint16 (pOutrow) +
    13153. 

  13153.                                              mng_get_uint16 (pWorkrow)) & 0xFFFF));
    13154. 

  13154. 

  13155.       pOutrow  += 4;
    13156. 

  13156.       pWorkrow += 2;
    13157. 

  13157.     }
    13158. 

  13158.   }
    13159. 

  13159. 

  13160. #ifdef MNG_SUPPORT_TRACE
    13161. 

  13161.   MNG_TRACE (pData, MNG_FN_DELTA_GA16_G16, MNG_LC_END);
    13162. 

  13162. #endif
    13163. 

  13163. 

  13164.   return MNG_NOERROR;
    13165. 

  13165. }
    13166. 

  13166. #endif
    13167. 

  13167. 

  13168. /* ************************************************************************** */
    13169. 

  13169. 

  13170. #ifndef MNG_NO_16BIT_SUPPORT
    13171. 

  13171. mng_retcode mng_delta_ga16_a16 (mng_datap pData)
    13172. 

  13172. {
    13173. 

  13173.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13174. 

  13174.   mng_uint8p     pWorkrow;
    13175. 

  13175.   mng_uint8p     pOutrow;
    13176. 

  13176.   mng_int32      iX;
    13177. 

  13177. 

  13178. #ifdef MNG_SUPPORT_TRACE
    13179. 

  13179.   MNG_TRACE (pData, MNG_FN_DELTA_GA16_A16, MNG_LC_START);
    13180. 

  13180. #endif
    13181. 

  13181. 

  13182.   pWorkrow = pData->pRGBArow;
    13183. 

  13183.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13184. 

  13184.                               (pData->iCol * pBuf->iSamplesize);
    13185. 

  13185. 

  13186.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAREPLACE)
    13187. 

  13187.   {
    13188. 

  13188. #ifdef MNG_DECREMENT_LOOPS
    13189. 

  13189.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13190. 

  13190. #else
    13191. 

  13191.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13192. 

  13192. #endif
    13193. 

  13193.     {
    13194. 

  13194.       mng_put_uint16 (pOutrow+2, mng_get_uint16 (pWorkrow));
    13195. 

  13195. 

  13196.       pOutrow  += 4;
    13197. 

  13197.       pWorkrow += 2;
    13198. 

  13198.     }
    13199. 

  13199.   }
    13200. 

  13200.   else
    13201. 

  13201.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAADD)
    13202. 

  13202.   {
    13203. 

  13203. #ifdef MNG_DECREMENT_LOOPS
    13204. 

  13204.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13205. 

  13205. #else
    13206. 

  13206.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13207. 

  13207. #endif
    13208. 

  13208.     {
    13209. 

  13209.       mng_put_uint16 (pOutrow+2, (mng_uint16)((mng_get_uint16 (pOutrow+2) +
    13210. 

  13210.                                                mng_get_uint16 (pWorkrow)) & 0xFFFF));
    13211. 

  13211. 

  13212.       pOutrow  += 4;
    13213. 

  13213.       pWorkrow += 2;
    13214. 

  13214.     }
    13215. 

  13215.   }
    13216. 

  13216. 

  13217. #ifdef MNG_SUPPORT_TRACE
    13218. 

  13218.   MNG_TRACE (pData, MNG_FN_DELTA_GA16_A16, MNG_LC_END);
    13219. 

  13219. #endif
    13220. 

  13220. 

  13221.   return MNG_NOERROR;
    13222. 

  13222. }
    13223. 

  13223. #endif
    13224. 

  13224. #endif /* MNG_NO_DELTA_PNG */
    13225. 

  13225. 

  13226. /* ************************************************************************** */
    13227. 

  13227. 

  13228. mng_retcode mng_delta_rgba8_rgba8 (mng_datap pData)
    13229. 

  13229. {
    13230. 

  13230.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13231. 

  13231.   mng_uint8p     pWorkrow;
    13232. 

  13232.   mng_uint8p     pOutrow;
    13233. 

  13233.   mng_int32      iX;
    13234. 

  13234. 

  13235. #ifdef MNG_SUPPORT_TRACE
    13236. 

  13236.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8_RGBA8, MNG_LC_START);
    13237. 

  13237. #endif
    13238. 

  13238. 

  13239.   pWorkrow = pData->pRGBArow;
    13240. 

  13240.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13241. 

  13241.                               (pData->iCol * pBuf->iSamplesize);
    13242. 

  13242. 

  13243.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    13244. 

  13244.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    13245. 

  13245.   {
    13246. 

  13246.     MNG_COPY (pOutrow, pWorkrow, pData->iRowsamples << 2);
    13247. 

  13247.   }
    13248. 

  13248.   else
    13249. 

  13249.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    13250. 

  13250.   {
    13251. 

  13251. #ifdef MNG_DECREMENT_LOOPS
    13252. 

  13252.     for (iX = (pData->iRowsamples << 2); iX > 0; iX--)
    13253. 

  13253. #else
    13254. 

  13254.     for (iX = 0; iX < (pData->iRowsamples << 2); iX++)
    13255. 

  13255. #endif
    13256. 

  13256.     {
    13257. 

  13257.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    13258. 

  13258.                               (mng_uint16)*pWorkrow) & 0xFF);
    13259. 

  13259. 

  13260.       pOutrow++;
    13261. 

  13261.       pWorkrow++;
    13262. 

  13262.     }
    13263. 

  13263.   }
    13264. 

  13264. 

  13265. #ifdef MNG_SUPPORT_TRACE
    13266. 

  13266.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8_RGBA8, MNG_LC_END);
    13267. 

  13267. #endif
    13268. 

  13268. 

  13269.   return MNG_NOERROR;
    13270. 

  13270. }
    13271. 

  13271. 

  13272. /* ************************************************************************** */
    13273. 

  13273. 

  13274. #ifndef MNG_NO_DELTA_PNG
    13275. 

  13275. mng_retcode mng_delta_rgba8_rgb8 (mng_datap pData)
    13276. 

  13276. {
    13277. 

  13277.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13278. 

  13278.   mng_uint8p     pWorkrow;
    13279. 

  13279.   mng_uint8p     pOutrow;
    13280. 

  13280.   mng_int32      iX;
    13281. 

  13281. 

  13282. #ifdef MNG_SUPPORT_TRACE
    13283. 

  13283.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8_RGB8, MNG_LC_START);
    13284. 

  13284. #endif
    13285. 

  13285. 

  13286.   pWorkrow = pData->pRGBArow;
    13287. 

  13287.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13288. 

  13288.                               (pData->iCol * pBuf->iSamplesize);
    13289. 

  13289. 

  13290.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORREPLACE)
    13291. 

  13291.   {
    13292. 

  13292. #ifdef MNG_DECREMENT_LOOPS
    13293. 

  13293.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13294. 

  13294. #else
    13295. 

  13295.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13296. 

  13296. #endif
    13297. 

  13297.     {
    13298. 

  13298.       *pOutrow     = *pWorkrow;
    13299. 

  13299.       *(pOutrow+1) = *(pWorkrow+1);
    13300. 

  13300.       *(pOutrow+2) = *(pWorkrow+2);
    13301. 

  13301. 

  13302.       pOutrow  += 4;
    13303. 

  13303.       pWorkrow += 3;
    13304. 

  13304.     }
    13305. 

  13305.   }
    13306. 

  13306.   else
    13307. 

  13307.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORADD)
    13308. 

  13308.   {
    13309. 

  13309. #ifdef MNG_DECREMENT_LOOPS
    13310. 

  13310.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13311. 

  13311. #else
    13312. 

  13312.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13313. 

  13313. #endif
    13314. 

  13314.     {
    13315. 

  13315.       *pOutrow     = (mng_uint8)(((mng_uint16)*pOutrow     +
    13316. 

  13316.                                   (mng_uint16)*pWorkrow    ) & 0xFF);
    13317. 

  13317.       *(pOutrow+1) = (mng_uint8)(((mng_uint16)*(pOutrow+1) +
    13318. 

  13318.                                   (mng_uint16)*(pWorkrow+1)) & 0xFF);
    13319. 

  13319.       *(pOutrow+2) = (mng_uint8)(((mng_uint16)*(pOutrow+2) +
    13320. 

  13320.                                   (mng_uint16)*(pWorkrow+2)) & 0xFF);
    13321. 

  13321. 

  13322.       pOutrow  += 4;
    13323. 

  13323.       pWorkrow += 3;
    13324. 

  13324.     }
    13325. 

  13325.   }
    13326. 

  13326. 

  13327. #ifdef MNG_SUPPORT_TRACE
    13328. 

  13328.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8_RGB8, MNG_LC_END);
    13329. 

  13329. #endif
    13330. 

  13330. 

  13331.   return MNG_NOERROR;
    13332. 

  13332. }
    13333. 

  13333. 

  13334. /* ************************************************************************** */
    13335. 

  13335. 

  13336. mng_retcode mng_delta_rgba8_a8 (mng_datap pData)
    13337. 

  13337. {
    13338. 

  13338.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13339. 

  13339.   mng_uint8p     pWorkrow;
    13340. 

  13340.   mng_uint8p     pOutrow;
    13341. 

  13341.   mng_int32      iX;
    13342. 

  13342. 

  13343. #ifdef MNG_SUPPORT_TRACE
    13344. 

  13344.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8_A8, MNG_LC_START);
    13345. 

  13345. #endif
    13346. 

  13346. 

  13347.   pWorkrow = pData->pRGBArow;
    13348. 

  13348.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13349. 

  13349.                               (pData->iCol * pBuf->iSamplesize) + 3;
    13350. 

  13350. 

  13351.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAREPLACE)
    13352. 

  13352.   {
    13353. 

  13353. #ifdef MNG_DECREMENT_LOOPS
    13354. 

  13354.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13355. 

  13355. #else
    13356. 

  13356.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13357. 

  13357. #endif
    13358. 

  13358.     {
    13359. 

  13359.       *pOutrow = *pWorkrow;
    13360. 

  13360. 

  13361.       pOutrow += 4;
    13362. 

  13362.       pWorkrow++;
    13363. 

  13363.     }
    13364. 

  13364.   }
    13365. 

  13365.   else
    13366. 

  13366.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAADD)
    13367. 

  13367.   {
    13368. 

  13368. #ifdef MNG_DECREMENT_LOOPS
    13369. 

  13369.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13370. 

  13370. #else
    13371. 

  13371.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13372. 

  13372. #endif
    13373. 

  13373.     {
    13374. 

  13374.       *pOutrow = (mng_uint8)(((mng_uint16)*pOutrow +
    13375. 

  13375.                               (mng_uint16)*pWorkrow) & 0xFF);
    13376. 

  13376. 

  13377.       pOutrow += 4;
    13378. 

  13378.       pWorkrow++;
    13379. 

  13379.     }
    13380. 

  13380.   }
    13381. 

  13381. 

  13382. #ifdef MNG_SUPPORT_TRACE
    13383. 

  13383.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA8_A8, MNG_LC_END);
    13384. 

  13384. #endif
    13385. 

  13385. 

  13386.   return MNG_NOERROR;
    13387. 

  13387. }
    13388. 

  13388. #endif /* MNG_NO_DELTA_PNG */
    13389. 

  13389. 

  13390. /* ************************************************************************** */
    13391. 

  13391. 

  13392. #ifndef MNG_NO_16BIT_SUPPORT
    13393. 

  13393. mng_retcode mng_delta_rgba16_rgba16 (mng_datap pData)
    13394. 

  13394. {
    13395. 

  13395.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13396. 

  13396.   mng_uint8p     pWorkrow;
    13397. 

  13397.   mng_uint8p     pOutrow;
    13398. 

  13398.   mng_int32      iX;
    13399. 

  13399. 

  13400. #ifdef MNG_SUPPORT_TRACE
    13401. 

  13401.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16_RGBA16, MNG_LC_START);
    13402. 

  13402. #endif
    13403. 

  13403. 

  13404.   pWorkrow = pData->pRGBArow;
    13405. 

  13405.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13406. 

  13406.                               (pData->iCol * pBuf->iSamplesize);
    13407. 

  13407. 

  13408.   if ((pData->iDeltatype == MNG_DELTATYPE_REPLACE          ) ||
    13409. 

  13409.       (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELREPLACE)    )
    13410. 

  13410.   {
    13411. 

  13411.     MNG_COPY (pOutrow, pWorkrow, (pData->iRowsamples << 3));
    13412. 

  13412.   }
    13413. 

  13413.   else
    13414. 

  13414.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKPIXELADD)
    13415. 

  13415.   {
    13416. 

  13416. #ifdef MNG_DECREMENT_LOOPS
    13417. 

  13417.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13418. 

  13418. #else
    13419. 

  13419.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13420. 

  13420. #endif
    13421. 

  13421.     {
    13422. 

  13422.       mng_put_uint16 (pOutrow,   (mng_uint16)((mng_get_uint16 (pOutrow  ) +
    13423. 

  13423.                                                mng_get_uint16 (pWorkrow  )) & 0xFFFF));
    13424. 

  13424.       mng_put_uint16 (pOutrow+2, (mng_uint16)((mng_get_uint16 (pOutrow+2) +
    13425. 

  13425.                                                mng_get_uint16 (pWorkrow+2)) & 0xFFFF));
    13426. 

  13426.       mng_put_uint16 (pOutrow+4, (mng_uint16)((mng_get_uint16 (pOutrow+4) +
    13427. 

  13427.                                                mng_get_uint16 (pWorkrow+4)) & 0xFFFF));
    13428. 

  13428.       mng_put_uint16 (pOutrow+6, (mng_uint16)((mng_get_uint16 (pOutrow+6) +
    13429. 

  13429.                                                mng_get_uint16 (pWorkrow+6)) & 0xFFFF));
    13430. 

  13430. 

  13431.       pOutrow  += 8;
    13432. 

  13432.       pWorkrow += 8;
    13433. 

  13433.     }
    13434. 

  13434.   }
    13435. 

  13435. 

  13436. #ifdef MNG_SUPPORT_TRACE
    13437. 

  13437.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16_RGBA16, MNG_LC_END);
    13438. 

  13438. #endif
    13439. 

  13439. 

  13440.   return MNG_NOERROR;
    13441. 

  13441. }
    13442. 

  13442. #endif
    13443. 

  13443. 

  13444. /* ************************************************************************** */
    13445. 

  13445. 

  13446. #ifndef MNG_NO_DELTA_PNG
    13447. 

  13447. #ifndef MNG_NO_16BIT_SUPPORT
    13448. 

  13448. mng_retcode mng_delta_rgba16_rgb16 (mng_datap pData)
    13449. 

  13449. {
    13450. 

  13450.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13451. 

  13451.   mng_uint8p     pWorkrow;
    13452. 

  13452.   mng_uint8p     pOutrow;
    13453. 

  13453.   mng_int32      iX;
    13454. 

  13454. 

  13455. #ifdef MNG_SUPPORT_TRACE
    13456. 

  13456.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16_RGB16, MNG_LC_START);
    13457. 

  13457. #endif
    13458. 

  13458. 

  13459.   pWorkrow = pData->pRGBArow;
    13460. 

  13460.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13461. 

  13461.                               (pData->iCol * pBuf->iSamplesize);
    13462. 

  13462. 

  13463.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORREPLACE)
    13464. 

  13464.   {
    13465. 

  13465. #ifdef MNG_DECREMENT_LOOPS
    13466. 

  13466.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13467. 

  13467. #else
    13468. 

  13468.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13469. 

  13469. #endif
    13470. 

  13470.     {
    13471. 

  13471.       mng_put_uint16 (pOutrow,   mng_get_uint16 (pWorkrow  ));
    13472. 

  13472.       mng_put_uint16 (pOutrow+2, mng_get_uint16 (pWorkrow+2));
    13473. 

  13473.       mng_put_uint16 (pOutrow+4, mng_get_uint16 (pWorkrow+4));
    13474. 

  13474. 

  13475.       pOutrow  += 8;
    13476. 

  13476.       pWorkrow += 6;
    13477. 

  13477.     }
    13478. 

  13478.   }
    13479. 

  13479.   else
    13480. 

  13480.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKCOLORADD)
    13481. 

  13481.   {
    13482. 

  13482. #ifdef MNG_DECREMENT_LOOPS
    13483. 

  13483.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13484. 

  13484. #else
    13485. 

  13485.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13486. 

  13486. #endif
    13487. 

  13487.     {
    13488. 

  13488.       mng_put_uint16 (pOutrow,   (mng_uint16)((mng_get_uint16 (pOutrow  ) +
    13489. 

  13489.                                                mng_get_uint16 (pWorkrow  )) & 0xFFFF));
    13490. 

  13490.       mng_put_uint16 (pOutrow+2, (mng_uint16)((mng_get_uint16 (pOutrow+2) +
    13491. 

  13491.                                                mng_get_uint16 (pWorkrow+2)) & 0xFFFF));
    13492. 

  13492.       mng_put_uint16 (pOutrow+4, (mng_uint16)((mng_get_uint16 (pOutrow+4) +
    13493. 

  13493.                                                mng_get_uint16 (pWorkrow+4)) & 0xFFFF));
    13494. 

  13494. 

  13495.       pOutrow  += 8;
    13496. 

  13496.       pWorkrow += 6;
    13497. 

  13497.     }
    13498. 

  13498.   }
    13499. 

  13499. 

  13500. #ifdef MNG_SUPPORT_TRACE
    13501. 

  13501.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16_RGB16, MNG_LC_END);
    13502. 

  13502. #endif
    13503. 

  13503. 

  13504.   return MNG_NOERROR;
    13505. 

  13505. }
    13506. 

  13506. #endif
    13507. 

  13507. 

  13508. /* ************************************************************************** */
    13509. 

  13509. 

  13510. #ifndef MNG_NO_16BIT_SUPPORT
    13511. 

  13511. mng_retcode mng_delta_rgba16_a16 (mng_datap pData)
    13512. 

  13512. {
    13513. 

  13513.   mng_imagedatap pBuf = ((mng_imagep)pData->pStoreobj)->pImgbuf;
    13514. 

  13514.   mng_uint8p     pWorkrow;
    13515. 

  13515.   mng_uint8p     pOutrow;
    13516. 

  13516.   mng_int32      iX;
    13517. 

  13517. 

  13518. #ifdef MNG_SUPPORT_TRACE
    13519. 

  13519.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16_A16, MNG_LC_START);
    13520. 

  13520. #endif
    13521. 

  13521. 

  13522.   pWorkrow = pData->pRGBArow;
    13523. 

  13523.   pOutrow  = pBuf->pImgdata + (pData->iRow * pBuf->iRowsize   ) +
    13524. 

  13524.                               (pData->iCol * pBuf->iSamplesize);
    13525. 

  13525. 

  13526.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAREPLACE)
    13527. 

  13527.   {
    13528. 

  13528. #ifdef MNG_DECREMENT_LOOPS
    13529. 

  13529.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13530. 

  13530. #else
    13531. 

  13531.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13532. 

  13532. #endif
    13533. 

  13533.     {
    13534. 

  13534.       mng_put_uint16 (pOutrow+6, mng_get_uint16 (pWorkrow));
    13535. 

  13535. 

  13536.       pOutrow  += 8;
    13537. 

  13537.       pWorkrow += 2;
    13538. 

  13538.     }
    13539. 

  13539.   }
    13540. 

  13540.   else
    13541. 

  13541.   if (pData->iDeltatype == MNG_DELTATYPE_BLOCKALPHAADD)
    13542. 

  13542.   {
    13543. 

  13543. #ifdef MNG_DECREMENT_LOOPS
    13544. 

  13544.     for (iX = pData->iRowsamples; iX > 0; iX--)
    13545. 

  13545. #else
    13546. 

  13546.     for (iX = 0; iX < pData->iRowsamples; iX++)
    13547. 

  13547. #endif
    13548. 

  13548.     {
    13549. 

  13549.       mng_put_uint16 (pOutrow+6, (mng_uint16)((mng_get_uint16 (pOutrow+6) +
    13550. 

  13550.                                                mng_get_uint16 (pWorkrow)) & 0xFFFF));
    13551. 

  13551. 

  13552.       pOutrow  += 8;
    13553. 

  13553.       pWorkrow += 2;
    13554. 

  13554.     }
    13555. 

  13555.   }
    13556. 

  13556. 

  13557. #ifdef MNG_SUPPORT_TRACE
    13558. 

  13558.   MNG_TRACE (pData, MNG_FN_DELTA_RGBA16_A16, MNG_LC_END);
    13559. 

  13559. #endif
    13560. 

  13560. 

  13561.   return MNG_NOERROR;
    13562. 

  13562. }
    13563. 

  13563. #endif
    13564. 

  13564. #endif /* MNG_NO_DELTA_PNG */
    13565. 

  13565. 

  13566. /* ************************************************************************** */
    13567. 

  13567. /* *                                                                        * */
    13568. 

  13568. /* * Delta-image row routines - scale the delta to bitdepth of target       * */
    13569. 

  13569. /* *                                                                        * */
    13570. 

  13570. /* ************************************************************************** */
    13571. 

  13571. 

  13572. #ifndef MNG_NO_DELTA_PNG
    13573. 

  13573. #ifndef MNG_NO_1_2_4BIT_SUPPORT
    13574. 

  13574. mng_retcode mng_scale_g1_g2 (mng_datap pData)
    13575. 

  13575. {
    13576. 

  13576.   mng_uint8p pWorkrow = pData->pRGBArow;
    13577. 

  13577.   mng_int32  iX;
    13578. 

  13578. 

  13579. #ifdef MNG_SUPPORT_TRACE
    13580. 

  13580.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G2, MNG_LC_START);
    13581. 

  13581. #endif
    13582. 

  13582. 

  13583. #ifdef MNG_DECREMENT_LOOPS
    13584. 

  13584.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13585. 

  13585. #else
    13586. 

  13586.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13587. 

  13587. #endif
    13588. 

  13588.   {
    13589. 

  13589.     *pWorkrow = (mng_uint8)(*pWorkrow << 1);
    13590. 

  13590.     pWorkrow++;
    13591. 

  13591.   }
    13592. 

  13592. 

  13593. #ifdef MNG_SUPPORT_TRACE
    13594. 

  13594.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G2, MNG_LC_END);
    13595. 

  13595. #endif
    13596. 

  13596. 

  13597.   return MNG_NOERROR;
    13598. 

  13598. }
    13599. 

  13599. 

  13600. /* ************************************************************************** */
    13601. 

  13601. 

  13602. mng_retcode mng_scale_g1_g4 (mng_datap pData)
    13603. 

  13603. {
    13604. 

  13604.   mng_uint8p pWorkrow = pData->pRGBArow;
    13605. 

  13605.   mng_int32  iX;
    13606. 

  13606. 

  13607. #ifdef MNG_SUPPORT_TRACE
    13608. 

  13608.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G4, MNG_LC_START);
    13609. 

  13609. #endif
    13610. 

  13610. 

  13611. #ifdef MNG_DECREMENT_LOOPS
    13612. 

  13612.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13613. 

  13613. #else
    13614. 

  13614.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13615. 

  13615. #endif
    13616. 

  13616.   {
    13617. 

  13617.     *pWorkrow = (mng_uint8)(*pWorkrow << 3);
    13618. 

  13618.     pWorkrow++;
    13619. 

  13619.   }
    13620. 

  13620. 

  13621. #ifdef MNG_SUPPORT_TRACE
    13622. 

  13622.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G4, MNG_LC_END);
    13623. 

  13623. #endif
    13624. 

  13624. 

  13625.   return MNG_NOERROR;
    13626. 

  13626. }
    13627. 

  13627. 

  13628. /* ************************************************************************** */
    13629. 

  13629. 

  13630. mng_retcode mng_scale_g1_g8 (mng_datap pData)
    13631. 

  13631. {
    13632. 

  13632.   mng_uint8p pWorkrow = pData->pRGBArow;
    13633. 

  13633.   mng_int32  iX;
    13634. 

  13634. 

  13635. #ifdef MNG_SUPPORT_TRACE
    13636. 

  13636.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G8, MNG_LC_START);
    13637. 

  13637. #endif
    13638. 

  13638. 

  13639. #ifdef MNG_DECREMENT_LOOPS
    13640. 

  13640.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13641. 

  13641. #else
    13642. 

  13642.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13643. 

  13643. #endif
    13644. 

  13644.   {
    13645. 

  13645.     *pWorkrow = (mng_uint8)(*pWorkrow << 7);
    13646. 

  13646.     pWorkrow++;
    13647. 

  13647.   }
    13648. 

  13648. 

  13649. #ifdef MNG_SUPPORT_TRACE
    13650. 

  13650.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G8, MNG_LC_END);
    13651. 

  13651. #endif
    13652. 

  13652. 

  13653.   return MNG_NOERROR;
    13654. 

  13654. }
    13655. 

  13655. 

  13656. /* ************************************************************************** */
    13657. 

  13657. 

  13658. #ifndef MNG_NO_16BIT_SUPPORT
    13659. 

  13659. mng_retcode mng_scale_g1_g16 (mng_datap pData)
    13660. 

  13660. {
    13661. 

  13661.   mng_uint8p pWorkrow = pData->pRGBArow;
    13662. 

  13662.   mng_uint8p pOutrow  = pData->pRGBArow;
    13663. 

  13663.   mng_int32  iX;
    13664. 

  13664. 

  13665. #ifdef MNG_SUPPORT_TRACE
    13666. 

  13666.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G16, MNG_LC_START);
    13667. 

  13667. #endif
    13668. 

  13668. 

  13669.   pWorkrow = pWorkrow + (pData->iRowsamples - 1);
    13670. 

  13670.   pOutrow  = pOutrow  + ((pData->iRowsamples - 1) << 1);
    13671. 

  13671. /*  pWorkrow = (mng_uint8p)((mng_uint32)pWorkrow + pData->iRowsamples - 1); */
    13672. 

  13672. /*  pOutrow  = (mng_uint8p)((mng_uint32)pOutrow  + ((pData->iRowsamples - 1) << 1)); */
    13673. 

  13673. 

  13674. #ifdef MNG_DECREMENT_LOOPS
    13675. 

  13675.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13676. 

  13676. #else
    13677. 

  13677.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13678. 

  13678. #endif
    13679. 

  13679.   {
    13680. 

  13680.     *(pOutrow+1) = 0;
    13681. 

  13681.     *pOutrow     = (mng_uint8)(*pWorkrow << 7);
    13682. 

  13682. 

  13683.     pWorkrow--;
    13684. 

  13684.     pOutrow -= 2;
    13685. 

  13685.   }
    13686. 

  13686. 

  13687. #ifdef MNG_SUPPORT_TRACE
    13688. 

  13688.   MNG_TRACE (pData, MNG_FN_SCALE_G1_G16, MNG_LC_END);
    13689. 

  13689. #endif
    13690. 

  13690. 

  13691.   return MNG_NOERROR;
    13692. 

  13692. }
    13693. 

  13693. #endif
    13694. 

  13694. 

  13695. /* ************************************************************************** */
    13696. 

  13696. 

  13697. mng_retcode mng_scale_g2_g4 (mng_datap pData)
    13698. 

  13698. {
    13699. 

  13699.   mng_uint8p pWorkrow = pData->pRGBArow;
    13700. 

  13700.   mng_int32  iX;
    13701. 

  13701. 

  13702. #ifdef MNG_SUPPORT_TRACE
    13703. 

  13703.   MNG_TRACE (pData, MNG_FN_SCALE_G2_G4, MNG_LC_START);
    13704. 

  13704. #endif
    13705. 

  13705. 

  13706. #ifdef MNG_DECREMENT_LOOPS
    13707. 

  13707.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13708. 

  13708. #else
    13709. 

  13709.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13710. 

  13710. #endif
    13711. 

  13711.   {
    13712. 

  13712.     *pWorkrow = (mng_uint8)(*pWorkrow << 2);
    13713. 

  13713.     pWorkrow++;
    13714. 

  13714.   }
    13715. 

  13715. 

  13716. #ifdef MNG_SUPPORT_TRACE
    13717. 

  13717.   MNG_TRACE (pData, MNG_FN_SCALE_G2_G4, MNG_LC_END);
    13718. 

  13718. #endif
    13719. 

  13719. 

  13720.   return MNG_NOERROR;
    13721. 

  13721. }
    13722. 

  13722. 

  13723. /* ************************************************************************** */
    13724. 

  13724. 

  13725. mng_retcode mng_scale_g2_g8 (mng_datap pData)
    13726. 

  13726. {
    13727. 

  13727.   mng_uint8p pWorkrow = pData->pRGBArow;
    13728. 

  13728.   mng_int32  iX;
    13729. 

  13729. 

  13730. #ifdef MNG_SUPPORT_TRACE
    13731. 

  13731.   MNG_TRACE (pData, MNG_FN_SCALE_G2_G8, MNG_LC_START);
    13732. 

  13732. #endif
    13733. 

  13733. 

  13734. #ifdef MNG_DECREMENT_LOOPS
    13735. 

  13735.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13736. 

  13736. #else
    13737. 

  13737.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13738. 

  13738. #endif
    13739. 

  13739.   {
    13740. 

  13740.     *pWorkrow = (mng_uint8)(*pWorkrow << 6);
    13741. 

  13741.     pWorkrow++;
    13742. 

  13742.   }
    13743. 

  13743. 

  13744. #ifdef MNG_SUPPORT_TRACE
    13745. 

  13745.   MNG_TRACE (pData, MNG_FN_SCALE_G2_G8, MNG_LC_END);
    13746. 

  13746. #endif
    13747. 

  13747. 

  13748.   return MNG_NOERROR;
    13749. 

  13749. }
    13750. 

  13750. 

  13751. /* ************************************************************************** */
    13752. 

  13752. 

  13753. #ifndef MNG_NO_16BIT_SUPPORT
    13754. 

  13754. mng_retcode mng_scale_g2_g16 (mng_datap pData)
    13755. 

  13755. {
    13756. 

  13756.   mng_uint8p pWorkrow = pData->pRGBArow;
    13757. 

  13757.   mng_uint8p pOutrow  = pData->pRGBArow;
    13758. 

  13758.   mng_int32  iX;
    13759. 

  13759. 

  13760. #ifdef MNG_SUPPORT_TRACE
    13761. 

  13761.   MNG_TRACE (pData, MNG_FN_SCALE_G2_G16, MNG_LC_START);
    13762. 

  13762. #endif
    13763. 

  13763. 

  13764.   pWorkrow = pWorkrow + (pData->iRowsamples - 1);
    13765. 

  13765.   pOutrow  = pOutrow  + ((pData->iRowsamples - 1) << 1);
    13766. 

  13766. /*  pWorkrow = (mng_uint8p)((mng_uint32)pWorkrow + pData->iRowsamples - 1); */
    13767. 

  13767. /*  pOutrow  = (mng_uint8p)((mng_uint32)pOutrow  + ((pData->iRowsamples - 1) << 1)); */
    13768. 

  13768. 

  13769. #ifdef MNG_DECREMENT_LOOPS
    13770. 

  13770.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13771. 

  13771. #else
    13772. 

  13772.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13773. 

  13773. #endif
    13774. 

  13774.   {
    13775. 

  13775.     *(pOutrow+1) = 0;
    13776. 

  13776.     *pOutrow     = (mng_uint8)(*pWorkrow << 6);
    13777. 

  13777. 

  13778.     pWorkrow--;
    13779. 

  13779.     pOutrow -= 2;
    13780. 

  13780.   }
    13781. 

  13781. 

  13782. #ifdef MNG_SUPPORT_TRACE
    13783. 

  13783.   MNG_TRACE (pData, MNG_FN_SCALE_G2_G16, MNG_LC_END);
    13784. 

  13784. #endif
    13785. 

  13785. 

  13786.   return MNG_NOERROR;
    13787. 

  13787. }
    13788. 

  13788. #endif
    13789. 

  13789. 

  13790. /* ************************************************************************** */
    13791. 

  13791. 

  13792. mng_retcode mng_scale_g4_g8 (mng_datap pData)
    13793. 

  13793. {
    13794. 

  13794.   mng_uint8p pWorkrow = pData->pRGBArow;
    13795. 

  13795.   mng_int32  iX;
    13796. 

  13796. 

  13797. #ifdef MNG_SUPPORT_TRACE
    13798. 

  13798.   MNG_TRACE (pData, MNG_FN_SCALE_G4_G8, MNG_LC_START);
    13799. 

  13799. #endif
    13800. 

  13800. 

  13801. #ifdef MNG_DECREMENT_LOOPS
    13802. 

  13802.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13803. 

  13803. #else
    13804. 

  13804.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13805. 

  13805. #endif
    13806. 

  13806.   {
    13807. 

  13807.     *pWorkrow = (mng_uint8)(*pWorkrow << 4);
    13808. 

  13808.     pWorkrow++;
    13809. 

  13809.   }
    13810. 

  13810. 

  13811. #ifdef MNG_SUPPORT_TRACE
    13812. 

  13812.   MNG_TRACE (pData, MNG_FN_SCALE_G4_G8, MNG_LC_END);
    13813. 

  13813. #endif
    13814. 

  13814. 

  13815.   return MNG_NOERROR;
    13816. 

  13816. }
    13817. 

  13817. 

  13818. /* ************************************************************************** */
    13819. 

  13819. 

  13820. #ifndef MNG_NO_16BIT_SUPPORT
    13821. 

  13821. mng_retcode mng_scale_g4_g16 (mng_datap pData)
    13822. 

  13822. {
    13823. 

  13823.   mng_uint8p pWorkrow = pData->pRGBArow;
    13824. 

  13824.   mng_uint8p pOutrow  = pData->pRGBArow;
    13825. 

  13825.   mng_int32  iX;
    13826. 

  13826. 

  13827. #ifdef MNG_SUPPORT_TRACE
    13828. 

  13828.   MNG_TRACE (pData, MNG_FN_SCALE_G4_G16, MNG_LC_START);
    13829. 

  13829. #endif
    13830. 

  13830. 

  13831.   pWorkrow = pWorkrow + (pData->iRowsamples - 1);
    13832. 

  13832.   pOutrow  = pOutrow  + ((pData->iRowsamples - 1) << 1);
    13833. 

  13833. /*  pWorkrow = (mng_uint8p)((mng_uint32)pWorkrow + pData->iRowsamples - 1); */
    13834. 

  13834. /*  pOutrow  = (mng_uint8p)((mng_uint32)pOutrow  + ((pData->iRowsamples - 1) << 1)); */
    13835. 

  13835. 

  13836. #ifdef MNG_DECREMENT_LOOPS
    13837. 

  13837.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13838. 

  13838. #else
    13839. 

  13839.   for (iX = 0; iX < pData->iRowsamples; iX++)
    13840. 

  13840. #endif
    13841. 

  13841.   {
    13842. 

  13842.     *(pOutrow+1) = 0;
    13843. 

  13843.     *pOutrow     = (mng_uint8)(*pWorkrow << 4);
    13844. 

  13844. 

  13845.     pWorkrow--;
    13846. 

  13846.     pOutrow -= 2;
    13847. 

  13847.   }
    13848. 

  13848. 

  13849. #ifdef MNG_SUPPORT_TRACE
    13850. 

  13850.   MNG_TRACE (pData, MNG_FN_SCALE_G4_G16, MNG_LC_END);
    13851. 

  13851. #endif
    13852. 

  13852. 

  13853.   return MNG_NOERROR;
    13854. 

  13854. }
    13855. 

  13855. #endif
    13856. 

  13856. #endif /* MNG_NO_1_2_4BIT_SUPPORT */
    13857. 

  13857. 

  13858. /* ************************************************************************** */
    13859. 

  13859. 

  13860. #ifndef MNG_NO_16BIT_SUPPORT
    13861. 

  13861. mng_retcode mng_scale_g8_g16 (mng_datap pData)
    13862. 

  13862. {
    13863. 

  13863.   mng_uint8p pWorkrow = pData->pRGBArow;
    13864. 

  13864.   mng_uint8p pOutrow  = pData->pRGBArow;
    13865. 

  13865.   mng_int32  iX;
    13866. 

  13866. 

  13867. #ifdef MNG_SUPPORT_TRACE
    13868. 

  13868.   MNG_TRACE (pData, MNG_FN_SCALE_G8_G16, MNG_LC_START);
    13869. 

  13869. #endif
    13870. 

  13870. 

  13871.   pWorkrow = pWorkrow + (pData->iRowsamples - 1);
    13872. 

  13872.   pOutrow  = pOutrow  + ((pData->iRowsamples - 1) << 1);
    13873. 

  13873. /*  pWorkrow = (mng_uint8p)((mng_uint32)pWorkrow + pData->iRowsamples - 1); */
    13874. 

  13874. /*  pOutrow  = (mng_uint8p)((mng_uint32)pOutrow  + ((pData->iRowsamples - 1) << 1)); */
    13875. 

  13875. 

  13876. #ifdef MNG_DECREMENT_LOOPS
    13877. 

  13877.   for (iX = pData->iRowsamples; iX > 0; iX--)
    13878. 

  13878. #else
    13879.