blob: 4bc4a709b087b7ff89c5a904cccde7bcd0098441 [file] [log] [blame]
Pierre Ossman6e5cd5d2014-02-28 11:54:34 +01001/* Copyright 2009-2014 Pierre Ossman for Cendio AB
Pierre Ossman67b2b2f2009-03-06 10:12:55 +00002 *
3 * This is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This software is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this software; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16 * USA.
17 */
18
19namespace rfb {
20
21
22inline Pixel PixelFormat::pixelFromBuffer(const rdr::U8* buffer) const
23{
24 Pixel p;
25
26 p = 0;
27
28 if (bigEndian) {
29 switch (bpp) {
30 case 32:
31 p |= ((Pixel)*(buffer++)) << 24;
32 p |= ((Pixel)*(buffer++)) << 16;
33 case 16:
34 p |= ((Pixel)*(buffer++)) << 8;
35 case 8:
36 p |= *buffer;
37 }
38 } else {
39 p |= buffer[0];
40 if (bpp >= 16) {
41 p |= ((Pixel)buffer[1]) << 8;
Pierre Ossman67e7b292009-03-09 09:52:54 +000042 if (bpp == 32) {
Pierre Ossman67b2b2f2009-03-06 10:12:55 +000043 p |= ((Pixel)buffer[2]) << 16;
Pierre Ossman67e7b292009-03-09 09:52:54 +000044 p |= ((Pixel)buffer[3]) << 24;
45 }
Pierre Ossman67b2b2f2009-03-06 10:12:55 +000046 }
47 }
48
49 return p;
50}
51
52
Pierre Ossman19501b82009-03-31 14:06:53 +000053inline void PixelFormat::bufferFromPixel(rdr::U8* buffer, Pixel p) const
54{
55 if (bigEndian) {
56 switch (bpp) {
57 case 32:
58 *(buffer++) = (p >> 24) & 0xff;
59 *(buffer++) = (p >> 16) & 0xff;
60 case 16:
61 *(buffer++) = (p >> 8) & 0xff;
62 case 8:
63 *(buffer++) = (p >> 0) & 0xff;
64 }
65 } else {
66 buffer[0] = (p >> 0) & 0xff;
67 if (bpp >= 16) {
68 buffer[1] = (p >> 8) & 0xff;
69 if (bpp == 32) {
70 buffer[2] = (p >> 16) & 0xff;
71 buffer[3] = (p >> 24) & 0xff;
72 }
73 }
74 }
75}
76
77
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +010078inline Pixel PixelFormat::pixelFromRGB(rdr::U16 red, rdr::U16 green, rdr::U16 blue) const
Pierre Ossman8b874e42014-01-20 17:23:51 +010079{
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +010080 Pixel p;
Pierre Ossman8b874e42014-01-20 17:23:51 +010081
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +010082 /* We don't need to mask since we shift out unwanted bits */
83 p = ((Pixel)red >> (16 - redBits)) << redShift;
84 p |= ((Pixel)green >> (16 - greenBits)) << greenShift;
85 p |= ((Pixel)blue >> (16 - blueBits)) << blueShift;
86
87 return p;
88}
89
90
91inline Pixel PixelFormat::pixelFromRGB(rdr::U8 red, rdr::U8 green, rdr::U8 blue) const
92{
93 Pixel p;
94
95 p = ((Pixel)red >> (8 - redBits)) << redShift;
96 p |= ((Pixel)green >> (8 - greenBits)) << greenShift;
97 p |= ((Pixel)blue >> (8 - blueBits)) << blueShift;
98
99 return p;
100}
101
102
103inline void PixelFormat::rgbFromPixel(Pixel p, rdr::U16 *r, rdr::U16 *g, rdr::U16 *b) const
104{
105 int mb, rb, gb, bb;
106
107 /* Bit replication is much cheaper than multiplication and division */
108
109 mb = minBits;
110 rb = redBits;
111 gb = greenBits;
112 bb = blueBits;
113
114 *r = (p >> redShift) << (16 - rb);
115 *g = (p >> greenShift) << (16 - gb);
116 *b = (p >> blueShift) << (16 - bb);
117
118 while (mb < 16) {
119 *r = *r | (*r >> rb);
120 *g = *g | (*g >> gb);
121 *b = *b | (*b >> bb);
122 mb <<= 1;
123 rb <<= 1;
124 gb <<= 1;
125 bb <<= 1;
Pierre Ossman8b874e42014-01-20 17:23:51 +0100126 }
127}
128
129
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100130inline void PixelFormat::rgbFromPixel(Pixel p, rdr::U8 *r, rdr::U8 *g, rdr::U8 *b) const
Pierre Ossman8b874e42014-01-20 17:23:51 +0100131{
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100132 int mb, rb, gb, bb;
Pierre Ossman8b874e42014-01-20 17:23:51 +0100133
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100134 /* Bit replication is much cheaper than multiplication and division */
Pierre Ossman8b874e42014-01-20 17:23:51 +0100135
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100136 mb = minBits;
137 rb = redBits;
138 gb = greenBits;
139 bb = blueBits;
Pierre Ossman8b874e42014-01-20 17:23:51 +0100140
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100141 *r = (p >> redShift) << (8 - rb);
142 *g = (p >> greenShift) << (8 - gb);
143 *b = (p >> blueShift) << (8 - bb);
Pierre Ossman8b874e42014-01-20 17:23:51 +0100144
Pierre Ossmanb6b4dc62014-01-20 15:05:21 +0100145 while (mb < 8) {
146 *r = *r | (*r >> rb);
147 *g = *g | (*g >> gb);
148 *b = *b | (*b >> bb);
149 mb <<= 1;
150 rb <<= 1;
151 gb <<= 1;
152 bb <<= 1;
Pierre Ossman67b2b2f2009-03-06 10:12:55 +0000153 }
154}
155
156
157}
158