/apps/desktop/libvncserver/tabletrans24template.c

http://ftk.googlecode.com/ · C · 281 lines · 187 code · 36 blank · 58 comment · 16 complexity · a55b6d1a39c38c9c03c5ea0897929839 MD5 · raw file

  1. /*
  2. * tabletranstemplate.c - template for translation using lookup tables.
  3. *
  4. * This file shouldn't be compiled. It is included multiple times by
  5. * translate.c, each time with different definitions of the macros IN and OUT.
  6. *
  7. * For each pair of values IN and OUT, this file defines two functions for
  8. * translating a given rectangle of pixel data. One uses a single lookup
  9. * table, and the other uses three separate lookup tables for the red, green
  10. * and blue values.
  11. *
  12. * I know this code isn't nice to read because of all the macros, but
  13. * efficiency is important here.
  14. */
  15. /*
  16. * OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
  17. * Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge.
  18. * All Rights Reserved.
  19. *
  20. * This is free software; you can redistribute it and/or modify
  21. * it under the terms of the GNU General Public License as published by
  22. * the Free Software Foundation; either version 2 of the License, or
  23. * (at your option) any later version.
  24. *
  25. * This software is distributed in the hope that it will be useful,
  26. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  28. * GNU General Public License for more details.
  29. *
  30. * You should have received a copy of the GNU General Public License
  31. * along with this software; if not, write to the Free Software
  32. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  33. * USA.
  34. */
  35. #if !defined(BPP)
  36. #error "This file shouldn't be compiled."
  37. #error "It is included as part of translate.c"
  38. #endif
  39. #if BPP == 24
  40. /*
  41. * rfbTranslateWithSingleTableINtoOUT translates a rectangle of pixel data
  42. * using a single lookup table.
  43. */
  44. static void
  45. rfbTranslateWithSingleTable24to24 (char *table, rfbPixelFormat *in,
  46. rfbPixelFormat *out,
  47. char *iptr, char *optr,
  48. int bytesBetweenInputLines,
  49. int width, int height)
  50. {
  51. uint8_t *ip = (uint8_t *)iptr;
  52. uint8_t *op = (uint8_t *)optr;
  53. int ipextra = bytesBetweenInputLines - width * 3;
  54. uint8_t *opLineEnd;
  55. uint8_t *t = (uint8_t *)table;
  56. int shift = rfbEndianTest?0:8;
  57. uint8_t c;
  58. while (height > 0) {
  59. opLineEnd = op + width*3;
  60. while (op < opLineEnd) {
  61. *(uint32_t*)op = t[((*(uint32_t *)ip)>>shift)&0x00ffffff];
  62. if(!rfbEndianTest)
  63. memmove(op,op+1,3);
  64. if (out->bigEndian != in->bigEndian) {
  65. c = op[0]; op[0] = op[2]; op[2] = c;
  66. }
  67. op += 3;
  68. ip += 3;
  69. }
  70. ip += ipextra;
  71. height--;
  72. }
  73. }
  74. /*
  75. * rfbTranslateWithRGBTablesINtoOUT translates a rectangle of pixel data
  76. * using three separate lookup tables for the red, green and blue values.
  77. */
  78. static void
  79. rfbTranslateWithRGBTables24to24 (char *table, rfbPixelFormat *in,
  80. rfbPixelFormat *out,
  81. char *iptr, char *optr,
  82. int bytesBetweenInputLines,
  83. int width, int height)
  84. {
  85. uint8_t *ip = (uint8_t *)iptr;
  86. uint8_t *op = (uint8_t *)optr;
  87. int ipextra = bytesBetweenInputLines - width*3;
  88. uint8_t *opLineEnd;
  89. uint8_t *redTable = (uint8_t *)table;
  90. uint8_t *greenTable = redTable + 3*(in->redMax + 1);
  91. uint8_t *blueTable = greenTable + 3*(in->greenMax + 1);
  92. uint32_t outValue,inValue;
  93. int shift = rfbEndianTest?0:8;
  94. while (height > 0) {
  95. opLineEnd = op+3*width;
  96. while (op < opLineEnd) {
  97. inValue = ((*(uint32_t *)ip)>>shift)&0x00ffffff;
  98. outValue = (redTable[(inValue >> in->redShift) & in->redMax] |
  99. greenTable[(inValue >> in->greenShift) & in->greenMax] |
  100. blueTable[(inValue >> in->blueShift) & in->blueMax]);
  101. memcpy(op,&outValue,3);
  102. op += 3;
  103. ip+=3;
  104. }
  105. ip += ipextra;
  106. height--;
  107. }
  108. }
  109. #else
  110. #define IN_T CONCAT3E(uint,BPP,_t)
  111. #define OUT_T CONCAT3E(uint,BPP,_t)
  112. #define rfbTranslateWithSingleTable24toOUT \
  113. CONCAT4E(rfbTranslateWithSingleTable,24,to,BPP)
  114. #define rfbTranslateWithSingleTableINto24 \
  115. CONCAT4E(rfbTranslateWithSingleTable,BPP,to,24)
  116. #define rfbTranslateWithRGBTables24toOUT \
  117. CONCAT4E(rfbTranslateWithRGBTables,24,to,BPP)
  118. #define rfbTranslateWithRGBTablesINto24 \
  119. CONCAT4E(rfbTranslateWithRGBTables,BPP,to,24)
  120. /*
  121. * rfbTranslateWithSingleTableINtoOUT translates a rectangle of pixel data
  122. * using a single lookup table.
  123. */
  124. static void
  125. rfbTranslateWithSingleTable24toOUT (char *table, rfbPixelFormat *in,
  126. rfbPixelFormat *out,
  127. char *iptr, char *optr,
  128. int bytesBetweenInputLines,
  129. int width, int height)
  130. {
  131. uint8_t *ip = (uint8_t *)iptr;
  132. OUT_T *op = (OUT_T *)optr;
  133. int ipextra = bytesBetweenInputLines - width*3;
  134. OUT_T *opLineEnd;
  135. OUT_T *t = (OUT_T *)table;
  136. int shift = rfbEndianTest?0:8;
  137. while (height > 0) {
  138. opLineEnd = op + width;
  139. while (op < opLineEnd) {
  140. *(op++) = t[((*(uint32_t *)ip)>>shift)&0x00ffffff];
  141. ip+=3;
  142. }
  143. ip += ipextra;
  144. height--;
  145. }
  146. }
  147. /*
  148. * rfbTranslateWithRGBTablesINtoOUT translates a rectangle of pixel data
  149. * using three separate lookup tables for the red, green and blue values.
  150. */
  151. static void
  152. rfbTranslateWithRGBTables24toOUT (char *table, rfbPixelFormat *in,
  153. rfbPixelFormat *out,
  154. char *iptr, char *optr,
  155. int bytesBetweenInputLines,
  156. int width, int height)
  157. {
  158. uint8_t *ip = (uint8_t *)iptr;
  159. OUT_T *op = (OUT_T *)optr;
  160. int ipextra = bytesBetweenInputLines - width*3;
  161. OUT_T *opLineEnd;
  162. OUT_T *redTable = (OUT_T *)table;
  163. OUT_T *greenTable = redTable + in->redMax + 1;
  164. OUT_T *blueTable = greenTable + in->greenMax + 1;
  165. uint32_t inValue;
  166. int shift = rfbEndianTest?0:8;
  167. while (height > 0) {
  168. opLineEnd = &op[width];
  169. while (op < opLineEnd) {
  170. inValue = ((*(uint32_t *)ip)>>shift)&0x00ffffff;
  171. *(op++) = (redTable[(inValue >> in->redShift) & in->redMax] |
  172. greenTable[(inValue >> in->greenShift) & in->greenMax] |
  173. blueTable[(inValue >> in->blueShift) & in->blueMax]);
  174. ip+=3;
  175. }
  176. ip += ipextra;
  177. height--;
  178. }
  179. }
  180. /*
  181. * rfbTranslateWithSingleTableINto24 translates a rectangle of pixel data
  182. * using a single lookup table.
  183. */
  184. static void
  185. rfbTranslateWithSingleTableINto24 (char *table, rfbPixelFormat *in,
  186. rfbPixelFormat *out,
  187. char *iptr, char *optr,
  188. int bytesBetweenInputLines,
  189. int width, int height)
  190. {
  191. IN_T *ip = (IN_T *)iptr;
  192. uint8_t *op = (uint8_t *)optr;
  193. int ipextra = bytesBetweenInputLines / sizeof(IN_T) - width;
  194. uint8_t *opLineEnd;
  195. uint8_t *t = (uint8_t *)table;
  196. while (height > 0) {
  197. opLineEnd = op + width * 3;
  198. while (op < opLineEnd) {
  199. memcpy(op,&t[3*(*(ip++))],3);
  200. op += 3;
  201. }
  202. ip += ipextra;
  203. height--;
  204. }
  205. }
  206. /*
  207. * rfbTranslateWithRGBTablesINto24 translates a rectangle of pixel data
  208. * using three separate lookup tables for the red, green and blue values.
  209. */
  210. static void
  211. rfbTranslateWithRGBTablesINto24 (char *table, rfbPixelFormat *in,
  212. rfbPixelFormat *out,
  213. char *iptr, char *optr,
  214. int bytesBetweenInputLines,
  215. int width, int height)
  216. {
  217. IN_T *ip = (IN_T *)iptr;
  218. uint8_t *op = (uint8_t *)optr;
  219. int ipextra = bytesBetweenInputLines / sizeof(IN_T) - width;
  220. uint8_t *opLineEnd;
  221. uint8_t *redTable = (uint8_t *)table;
  222. uint8_t *greenTable = redTable + 3*(in->redMax + 1);
  223. uint8_t *blueTable = greenTable + 3*(in->greenMax + 1);
  224. uint32_t outValue;
  225. while (height > 0) {
  226. opLineEnd = op+3*width;
  227. while (op < opLineEnd) {
  228. outValue = (redTable[(*ip >> in->redShift) & in->redMax] |
  229. greenTable[(*ip >> in->greenShift) & in->greenMax] |
  230. blueTable[(*ip >> in->blueShift) & in->blueMax]);
  231. memcpy(op,&outValue,3);
  232. op += 3;
  233. ip++;
  234. }
  235. ip += ipextra;
  236. height--;
  237. }
  238. }
  239. #undef IN_T
  240. #undef OUT_T
  241. #undef rfbTranslateWithSingleTable24toOUT
  242. #undef rfbTranslateWithRGBTables24toOUT
  243. #undef rfbTranslateWithSingleTableINto24
  244. #undef rfbTranslateWithRGBTablesINto24
  245. #endif