PageRenderTime 60ms CodeModel.GetById 23ms 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

Large files files are truncated, but you can click here to view the full file

    

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

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

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

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

  5. /* *                                                                        * */
    6. 

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

  7. /* * file      : libmng_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.   …
    1009.

Large files files are truncated, but you can click here to view the full file