1 /* Libart_LGPL - library of basic graphic primitives
2 * Copyright (C) 1998 Raph Levien
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 */
20 #include <string.h> /* for memset */
21 #include "art_misc.h"
22 #include "art_rgb.h"
24 #include "config.h" /* for endianness */
26 /* Basic operators for manipulating 24-bit packed RGB buffers. */
28 #define COLOR_RUN_COMPLEX
30 #ifdef COLOR_RUN_SIMPLE
31 /* This is really slow. Is there any way we might speed it up?
32 Two ideas:
34 First, maybe we should be working at 32-bit alignment. Then,
35 this can be a simple loop over word stores.
37 Second, we can keep working at 24-bit alignment, but have some
38 intelligence about storing. For example, we can iterate over
39 4-pixel chunks (aligned at 4 pixels), with an inner loop
40 something like:
42 *buf++ = v1;
43 *buf++ = v2;
44 *buf++ = v3;
46 One source of extra complexity is the need to make sure linebuf is
47 aligned to a 32-bit boundary.
49 This second alternative has some complexity to it, but is
50 appealing because it really minimizes the memory bandwidth. */
51 void
52 art_rgb_fill_run (art_u8 *buf, art_u8 r, art_u8 g, art_u8 b, gint n)
53 {
54 int i;
56 if (r == g && g == b)
57 {
58 memset (buf, g, n + n + n);
59 }
60 else
61 {
62 for (i = 0; i < n; i++)
63 {
64 *buf++ = r;
65 *buf++ = g;
66 *buf++ = b;
67 }
68 }
69 }
70 #endif
72 #ifdef COLOR_RUN_COMPLEX
73 /* This implements the second of the two ideas above. The test results
74 are _very_ encouraging - it seems the speed is within 10% of
75 memset, which is quite good! */
76 /**
77 * art_rgb_fill_run: fill a buffer a solid RGB color.
78 * @buf: Buffer to fill.
79 * @r: Red, range 0..255.
80 * @g: Green, range 0..255.
81 * @b: Blue, range 0..255.
82 * @n: Number of RGB triples to fill.
83 *
84 * Fills a buffer with @n copies of the (@r, @g, @b) triple. Thus,
85 * locations @buf (inclusive) through @buf + 3 * @n (exclusive) are
86 * written.
87 *
88 * The implementation of this routine is very highly optimized.
89 **/
90 void
91 art_rgb_fill_run (art_u8 *buf, art_u8 r, art_u8 g, art_u8 b, int n)
92 {
93 int i;
94 unsigned int v1, v2, v3;
96 if (r == g && g == b)
97 {
98 memset (buf, g, n + n + n);
99 }
100 else
101 {
102 if (n < 8)
103 {
104 for (i = 0; i < n; i++)
105 {
106 *buf++ = r;
107 *buf++ = g;
108 *buf++ = b;
109 }
110 } else {
111 /* handle prefix up to byte alignment */
112 /* I'm worried about this cast on sizeof(long) != sizeof(uchar *)
113 architectures, but it _should_ work. */
114 for (i = 0; ((unsigned long)buf) & 3; i++)
115 {
116 *buf++ = r;
117 *buf++ = g;
118 *buf++ = b;
119 }
120 #ifndef WORDS_BIGENDIAN
121 v1 = r | (g << 8) | (b << 16) | (r << 24);
122 v3 = (v1 << 8) | b;
123 v2 = (v3 << 8) | g;
124 #else
125 v1 = (r << 24) | (g << 16) | (b << 8) | r;
126 v2 = (v1 << 8) | g;
127 v3 = (v2 << 8) | b;
128 #endif
129 for (; i < n - 3; i += 4)
130 {
131 ((art_u32 *)buf)[0] = v1;
132 ((art_u32 *)buf)[1] = v2;
133 ((art_u32 *)buf)[2] = v3;
134 buf += 12;
135 }
136 /* handle postfix */
137 for (; i < n; i++)
138 {
139 *buf++ = r;
140 *buf++ = g;
141 *buf++ = b;
142 }
143 }
144 }
145 }
146 #endif
148 /**
149 * art_rgb_run_alpha: Render semitransparent color over RGB buffer.
150 * @buf: Buffer for rendering.
151 * @r: Red, range 0..255.
152 * @g: Green, range 0..255.
153 * @b: Blue, range 0..255.
154 * @alpha: Alpha, range 0..256.
155 * @n: Number of RGB triples to render.
156 *
157 * Renders a sequential run of solid (@r, @g, @b) color over @buf with
158 * opacity @alpha.
159 **/
160 void
161 art_rgb_run_alpha (art_u8 *buf, art_u8 r, art_u8 g, art_u8 b, int alpha, int n)
162 {
163 int i;
164 int v;
166 for (i = 0; i < n; i++)
167 {
168 v = *buf;
169 *buf++ = v + (((r - v) * alpha + 0x80) >> 8);
170 v = *buf;
171 *buf++ = v + (((g - v) * alpha + 0x80) >> 8);
172 v = *buf;
173 *buf++ = v + (((b - v) * alpha + 0x80) >> 8);
174 }
175 }