Initial commit

common/rfb/PixelFormatBPP.cxx

@@ -0,0 +1,155 @@
+/* Copyright 2014 Pierre Ossman for Cendio AB
+ * 
+ * This is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this software; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
+ * USA.
+ */
+
+#define CONCAT2(a,b) a##b
+#define CONCAT2E(a,b) CONCAT2(a,b)
+
+#define UIN CONCAT2E(U,INBPP)
+#define UOUT CONCAT2E(U,OUTBPP)
+
+#define SWAP16(n) ((((n) & 0xff) << 8) | (((n) >> 8) & 0xff))
+#define SWAP32(n) (((n) >> 24) | (((n) & 0x00ff0000) >> 8) | \
+                   (((n) & 0x0000ff00) << 8) | ((n) << 24))
+
+#define SWAPIN CONCAT2E(SWAP,INBPP)
+#define SWAPOUT CONCAT2E(SWAP,OUTBPP)
+
+#if INBPP == 32
+
+void PixelFormat::directBufferFromBufferFrom888(rdr::UOUT* dst,
+                                                const PixelFormat &srcPF,
+                                                const rdr::U8* src,
+                                                int w, int h,
+                                                int dstStride,
+                                                int srcStride) const
+{
+  const rdr::U8 *r, *g, *b;
+  int dstPad, srcPad;
+
+  const rdr::U8 *redDownTable, *greenDownTable, *blueDownTable;
+
+  redDownTable = &downconvTable[(redBits-1)*256];
+  greenDownTable = &downconvTable[(greenBits-1)*256];
+  blueDownTable = &downconvTable[(blueBits-1)*256];
+
+  if (srcPF.bigEndian) {
+    r = src + (24 - srcPF.redShift)/8;
+    g = src + (24 - srcPF.greenShift)/8;
+    b = src + (24 - srcPF.blueShift)/8;
+  } else {
+    r = src + srcPF.redShift/8;
+    g = src + srcPF.greenShift/8;
+    b = src + srcPF.blueShift/8;
+  }
+
+  dstPad = (dstStride - w);
+  srcPad = (srcStride - w) * 4;
+  while (h--) {
+    int w_ = w;
+    while (w_--) {
+      rdr::UOUT d;
+
+      d = redDownTable[*r] << redShift;
+      d |= greenDownTable[*g] << greenShift;
+      d |= blueDownTable[*b] << blueShift;
+
+#if OUTBPP != 8
+      if (endianMismatch)
+        d = SWAPOUT(d);
+#endif
+
+      *dst = d;
+
+      dst++;
+      r += 4;
+      g += 4;
+      b += 4;
+    }
+    dst += dstPad;
+    r += srcPad;
+    g += srcPad;
+    b += srcPad;
+  }
+}
+
+#endif /* INBPP == 32 */
+
+#if OUTBPP == 32
+
+void PixelFormat::directBufferFromBufferTo888(rdr::U8* dst,
+                                              const PixelFormat &srcPF,
+                                              const rdr::UIN* src,
+                                              int w, int h,
+                                              int dstStride,
+                                              int srcStride) const
+{
+  rdr::U8 *r, *g, *b, *x;
+  int dstPad, srcPad;
+
+  const rdr::U8 *redUpTable, *greenUpTable, *blueUpTable;
+
+  redUpTable = &upconvTable[(srcPF.redBits-1)*256];
+  greenUpTable = &upconvTable[(srcPF.greenBits-1)*256];
+  blueUpTable = &upconvTable[(srcPF.blueBits-1)*256];
+
+  if (bigEndian) {
+    r = dst + (24 - redShift)/8;
+    g = dst + (24 - greenShift)/8;
+    b = dst + (24 - blueShift)/8;
+    x = dst + (24 - (48 - redShift - greenShift - blueShift))/8;
+  } else {
+    r = dst + redShift/8;
+    g = dst + greenShift/8;
+    b = dst + blueShift/8;
+    x = dst + (48 - redShift - greenShift - blueShift)/8;
+  }
+
+  dstPad = (dstStride - w) * 4;
+  srcPad = (srcStride - w);
+  while (h--) {
+    int w_ = w;
+    while (w_--) {
+      rdr::UIN s;
+
+      s = *src;
+
+#if INBPP != 8
+      if (srcPF.endianMismatch)
+        s = SWAPIN(s);
+#endif
+
+      *r = redUpTable[(s >> srcPF.redShift) & 0xff];
+      *g = greenUpTable[(s >> srcPF.greenShift) & 0xff];
+      *b = blueUpTable[(s >> srcPF.blueShift) & 0xff];
+      *x = 0;
+
+      r += 4;
+      g += 4;
+      b += 4;
+      x += 4;
+      src++;
+    }
+    r += dstPad;
+    g += dstPad;
+    b += dstPad;
+    x += dstPad;
+    src += srcPad;
+  }
+}
+
+#endif /* OUTBPP == 32 */