b2f800afd8a4c509a0238b85ef64caada77c2d51
4 /**************************************************************************
6 * Copyright 2009 VMware, Inc.
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the
11 * "Software"), to deal in the Software without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sub license, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
24 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
25 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
26 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
33 * Pixel format accessor functions.
35 * @author Jose Fonseca <jfonseca@vmware.com>
43 sys
.path
.insert(0, os
.path
.join(os
.path
.dirname(sys
.argv
[0]), '../../auxiliary/util'))
45 from u_format_pack
import *
48 def is_format_supported(format
):
49 '''Determines whether we actually have the plumbing necessary to generate the
50 to read/write to/from this format.'''
52 # FIXME: Ideally we would support any format combination here.
54 if format
.layout
!= PLAIN
:
58 channel
= format
.channels
[i
]
59 if channel
.type not in (VOID
, UNSIGNED
, SIGNED
, FLOAT
):
61 if channel
.type == FLOAT
and channel
.size
not in (16, 32 ,64):
64 if format
.colorspace
not in ('rgb', 'srgb'):
70 def generate_format_read(format
, dst_channel
, dst_native_type
, dst_suffix
):
71 '''Generate the function to read pixels from a particular format'''
73 name
= format
.short_name()
75 src_native_type
= native_type(format
)
78 print 'lp_tile_%s_swizzle_%s(%s *dst, const uint8_t *src, unsigned src_stride, unsigned x0, unsigned y0, unsigned w, unsigned h)' % (name
, dst_suffix
, dst_native_type
)
80 print ' unsigned x, y;'
81 print ' const uint8_t *src_row = src + y0*src_stride;'
82 print ' for (y = 0; y < h; ++y) {'
83 print ' const %s *src_pixel = (const %s *)(src_row + x0*%u);' % (src_native_type
, src_native_type
, format
.stride())
84 print ' for (x = 0; x < w; ++x) {'
87 if format
.colorspace
in ('rgb', 'srgb'):
89 swizzle
= format
.swizzles
[i
]
91 names
[swizzle
] += 'rgba'[i
]
92 elif format
.colorspace
== 'zs':
93 swizzle
= format
.swizzles
[0]
101 if format
.layout
== PLAIN
:
102 if not format
.is_array():
103 print ' %s pixel = *src_pixel++;' % src_native_type
106 src_channel
= format
.channels
[i
]
107 width
= src_channel
.size
110 mask
= (1 << width
) - 1
112 value
= '(%s >> %u)' % (value
, shift
)
113 if shift
+ width
< format
.block_size():
114 value
= '(%s & 0x%x)' % (value
, mask
)
115 value
= conversion_expr(src_channel
, dst_channel
, dst_native_type
, value
, clamp
=False)
116 print ' %s %s = %s;' % (dst_native_type
, names
[i
], value
)
121 print ' %s %s;' % (dst_native_type
, names
[i
])
123 src_channel
= format
.channels
[i
]
125 value
= '(*src_pixel++)'
126 value
= conversion_expr(src_channel
, dst_channel
, dst_native_type
, value
, clamp
=False)
127 print ' %s = %s;' % (names
[i
], value
)
128 elif src_channel
.size
:
129 print ' ++src_pixel;'
134 if format
.colorspace
in ('rgb', 'srgb'):
135 swizzle
= format
.swizzles
[i
]
137 value
= names
[swizzle
]
138 elif swizzle
== SWIZZLE_0
:
140 elif swizzle
== SWIZZLE_1
:
141 value
= get_one(dst_channel
)
144 elif format
.colorspace
== 'zs':
148 value
= get_one(dst_channel
)
151 print ' TILE_PIXEL(dst, x, y, %u) = %s; /* %s */' % (i
, value
, 'rgba'[i
])
154 print ' src_row += src_stride;'
160 def pack_rgba(format
, src_channel
, r
, g
, b
, a
):
161 """Return an expression for packing r, g, b, a into a pixel of the
162 given format. Ex: '(b << 24) | (g << 16) | (r << 8) | (a << 0)'
164 assert format
.colorspace
in ('rgb', 'srgb')
165 inv_swizzle
= format
.inv_swizzles()
169 # choose r, g, b, or a depending on the inverse swizzle term
170 if inv_swizzle
[i
] == 0:
172 elif inv_swizzle
[i
] == 1:
174 elif inv_swizzle
[i
] == 2:
176 elif inv_swizzle
[i
] == 3:
182 dst_channel
= format
.channels
[i
]
183 dst_native_type
= native_type(format
)
184 value
= conversion_expr(src_channel
, dst_channel
, dst_native_type
, value
, clamp
=False)
185 term
= "((%s) << %d)" % (value
, shift
)
187 expr
= expr
+ " | " + term
191 width
= format
.channels
[i
].size
192 shift
= shift
+ width
196 def emit_unrolled_unswizzle_code(format
, src_channel
):
197 '''Emit code for writing a block based on unrolled loops.
198 This is considerably faster than the TILE_PIXEL-based code below.
200 dst_native_type
= 'uint%u_t' % format
.block_size()
201 print ' const unsigned dstpix_stride = dst_stride / %d;' % format
.stride()
202 print ' %s *dstpix = (%s *) dst;' % (dst_native_type
, dst_native_type
)
203 print ' unsigned int qx, qy, i;'
205 print ' for (qy = 0; qy < h; qy += TILE_VECTOR_HEIGHT) {'
206 print ' const unsigned py = y0 + qy;'
207 print ' for (qx = 0; qx < w; qx += TILE_VECTOR_WIDTH) {'
208 print ' const unsigned px = x0 + qx;'
209 print ' const uint8_t *r = src + 0 * TILE_C_STRIDE;'
210 print ' const uint8_t *g = src + 1 * TILE_C_STRIDE;'
211 print ' const uint8_t *b = src + 2 * TILE_C_STRIDE;'
212 print ' const uint8_t *a = src + 3 * TILE_C_STRIDE;'
213 print ' (void) r; (void) g; (void) b; (void) a; /* silence warnings */'
214 print ' for (i = 0; i < TILE_C_STRIDE; i += 2) {'
215 print ' const uint32_t pixel0 = %s;' % pack_rgba(format
, src_channel
, "r[i+0]", "g[i+0]", "b[i+0]", "a[i+0]")
216 print ' const uint32_t pixel1 = %s;' % pack_rgba(format
, src_channel
, "r[i+1]", "g[i+1]", "b[i+1]", "a[i+1]")
217 print ' const unsigned offset = (py + tile_y_offset[i]) * dstpix_stride + (px + tile_x_offset[i]);'
218 print ' dstpix[offset + 0] = pixel0;'
219 print ' dstpix[offset + 1] = pixel1;'
221 print ' src += TILE_X_STRIDE;'
226 def emit_tile_pixel_unswizzle_code(format
, src_channel
):
227 '''Emit code for writing a block based on the TILE_PIXEL macro.'''
228 dst_native_type
= native_type(format
)
230 inv_swizzle
= format
.inv_swizzles()
232 print ' unsigned x, y;'
233 print ' uint8_t *dst_row = dst + y0*dst_stride;'
234 print ' for (y = 0; y < h; ++y) {'
235 print ' %s *dst_pixel = (%s *)(dst_row + x0*%u);' % (dst_native_type
, dst_native_type
, format
.stride())
236 print ' for (x = 0; x < w; ++x) {'
238 if format
.layout
== PLAIN
:
239 if not format
.is_array():
240 print ' %s pixel = 0;' % dst_native_type
243 dst_channel
= format
.channels
[i
]
244 width
= dst_channel
.size
245 if inv_swizzle
[i
] is not None:
246 value
= 'TILE_PIXEL(src, x, y, %u)' % inv_swizzle
[i
]
247 value
= conversion_expr(src_channel
, dst_channel
, dst_native_type
, value
, clamp
=False)
249 value
= '(%s << %u)' % (value
, shift
)
250 print ' pixel |= %s;' % value
252 print ' *dst_pixel++ = pixel;'
255 dst_channel
= format
.channels
[i
]
256 if inv_swizzle
[i
] is not None:
257 value
= 'TILE_PIXEL(src, x, y, %u)' % inv_swizzle
[i
]
258 value
= conversion_expr(src_channel
, dst_channel
, dst_native_type
, value
, clamp
=False)
259 print ' *dst_pixel++ = %s;' % value
261 print ' ++dst_pixel;'
266 print ' dst_row += dst_stride;'
270 def generate_format_write(format
, src_channel
, src_native_type
, src_suffix
):
271 '''Generate the function to write pixels to a particular format'''
273 name
= format
.short_name()
276 print 'lp_tile_%s_unswizzle_%s(const %s *src, uint8_t *dst, unsigned dst_stride, unsigned x0, unsigned y0, unsigned w, unsigned h)' % (name
, src_suffix
, src_native_type
)
278 if format
.layout
== PLAIN \
279 and format
.colorspace
== 'rgb' \
280 and format
.block_size() <= 32 \
281 and format
.is_pot() \
282 and not format
.is_mixed() \
283 and (format
.channels
[0].type == UNSIGNED \
284 or format
.channels
[1].type == UNSIGNED
):
285 emit_unrolled_unswizzle_code(format
, src_channel
)
287 emit_tile_pixel_unswizzle_code(format
, src_channel
)
292 def generate_swizzle(formats
, dst_channel
, dst_native_type
, dst_suffix
):
293 '''Generate the dispatch function to read pixels from any format'''
295 for format
in formats
:
296 if is_format_supported(format
):
297 generate_format_read(format
, dst_channel
, dst_native_type
, dst_suffix
)
300 print 'lp_tile_swizzle_%s(enum pipe_format format, %s *dst, const void *src, unsigned src_stride, unsigned x, unsigned y, unsigned w, unsigned h)' % (dst_suffix
, dst_native_type
)
302 print ' void (*func)(%s *dst, const uint8_t *src, unsigned src_stride, unsigned x0, unsigned y0, unsigned w, unsigned h);' % dst_native_type
304 print ' lp_tile_swizzle_count += 1;'
306 print ' switch(format) {'
307 for format
in formats
:
308 if is_format_supported(format
):
309 print ' case %s:' % format
.name
310 print ' func = &lp_tile_%s_swizzle_%s;' % (format
.short_name(), dst_suffix
)
313 print ' debug_printf("%s: unsupported format %s\\n", __FUNCTION__, util_format_name(format));'
316 print ' func(dst, (const uint8_t *)src, src_stride, x, y, w, h);'
321 def generate_unswizzle(formats
, src_channel
, src_native_type
, src_suffix
):
322 '''Generate the dispatch function to write pixels to any format'''
324 for format
in formats
:
325 if is_format_supported(format
):
326 generate_format_write(format
, src_channel
, src_native_type
, src_suffix
)
329 print 'lp_tile_unswizzle_%s(enum pipe_format format, const %s *src, void *dst, unsigned dst_stride, unsigned x, unsigned y, unsigned w, unsigned h)' % (src_suffix
, src_native_type
)
332 print ' void (*func)(const %s *src, uint8_t *dst, unsigned dst_stride, unsigned x0, unsigned y0, unsigned w, unsigned h);' % src_native_type
334 print ' lp_tile_unswizzle_count += 1;'
336 print ' switch(format) {'
337 for format
in formats
:
338 if is_format_supported(format
):
339 print ' case %s:' % format
.name
340 print ' func = &lp_tile_%s_unswizzle_%s;' % (format
.short_name(), src_suffix
)
343 print ' debug_printf("%s: unsupported format %s\\n", __FUNCTION__, util_format_name(format));'
346 print ' func(src, (uint8_t *)dst, dst_stride, x, y, w, h);'
353 for arg
in sys
.argv
[1:]:
354 formats
.extend(parse(arg
))
356 print '/* This file is autogenerated by lp_tile_soa.py from u_format.csv. Do not edit directly. */'
358 # This will print the copyright message on the top of this file
359 print __doc__
.strip()
361 print '#include "pipe/p_compiler.h"'
362 print '#include "util/u_format.h"'
363 print '#include "util/u_math.h"'
364 print '#include "util/u_half.h"'
365 print '#include "lp_tile_soa.h"'
368 print 'unsigned lp_tile_unswizzle_count = 0;'
369 print 'unsigned lp_tile_swizzle_count = 0;'
372 print 'const unsigned char'
373 print 'tile_offset[TILE_VECTOR_HEIGHT][TILE_VECTOR_WIDTH] = {'
374 print ' { 0, 1, 4, 5},'
375 print ' { 2, 3, 6, 7},'
376 print ' { 8, 9, 12, 13},'
377 print ' { 10, 11, 14, 15}'
380 print '/* Note: these lookup tables could be replaced with some'
381 print ' * bit-twiddling code, but this is a little faster.'
383 print 'static unsigned tile_x_offset[TILE_VECTOR_WIDTH * TILE_VECTOR_HEIGHT] = {'
384 print ' 0, 1, 0, 1, 2, 3, 2, 3,'
385 print ' 0, 1, 0, 1, 2, 3, 2, 3'
388 print 'static unsigned tile_y_offset[TILE_VECTOR_WIDTH * TILE_VECTOR_HEIGHT] = {'
389 print ' 0, 0, 1, 1, 0, 0, 1, 1,'
390 print ' 2, 2, 3, 3, 2, 2, 3, 3'
394 channel
= Channel(UNSIGNED
, True, 8)
395 native_type
= 'uint8_t'
398 generate_swizzle(formats
, channel
, native_type
, suffix
)
399 generate_unswizzle(formats
, channel
, native_type
, suffix
)
402 if __name__
== '__main__':